@renoxar/koolie 1.25.0

package/.koolie/core/tests/erhebungen/messbaum-schnitt.py

@@ -0,0 +1,256 @@
+# -*- coding: utf-8 -*-
+"""Zwei Schnitte an einem Messbaum, je mit Waechter (seit 1.14.1, K-167, D-425).
+
+Aufruf:  python messbaum-schnitt.py aufzeichnungen <baum> [--tools-bleiben]
+         python messbaum-schnitt.py ohneskill <baum> <skill> [<skill> ...]
+
+`aufzeichnungen` - fuer JEDEN Messbaum, Haupt- wie Kontrolllauf, und vor jedem
+    Zuschnitt. Nimmt heraus, was die Praeparationen und die Erwartungen der Zellen
+    beschreibt: Antraege, Protokolle, Testblaetter, Testkatalog, Koederregister,
+    Chronik, Mentorenblatt. 🔴 Gemessen im Nachlauf von 1.14.0: Eine Suche ueber das
+    Repositorium fand in einem Aenderungsantrag die Beschreibung des Koeders `UEB-05`,
+    und der Lauf stuetzte seine Einstufung darauf. Bei der Vorpruefung von 1.14.1 lag
+    das Koederregister vollstaendig in `onboarding/exercises/README.md`, und jedes
+    `TESTS.md` nannte die Erwartung der Zelle, die gerade lief.
+    Die Trennlinie ist die von D-141: geschnitten wird AUFZEICHNUNG, nicht Regel. Ein
+    Messbaum braucht die Regelschicht; er braucht nicht die Geschichte, wie sie
+    gemessen wurde.
+
+`--tools-bleiben` (seit 1.19.0, D-473) - fuer den Baumbau von Buendel 4: Dort setzt
+    `historie-bauen-b4.py` die Praeparationen NACH dem Schnitt ueber
+    `tools/praeparationen.py` und `tools/messbaum-b4/` im Baum; ohne sie bricht er ab
+    (gemessen am 2026-09-29 beim Nachlauf K-86). `tools/` bleibt dann stehen und ist vom
+    Waechter ausgenommen - fuer den Lauf sperrt es die Regel `Read(tools/**)` des
+    Messbaums, wie in den Baeumen, gegen die die Hauptlaeufe gefahren sind.
+
+`ohneskill` - der Kontrollzuschnitt ohne den Skill. 🔴 Bis 1.14.0 leerte er nur die
+    Laufzeitablage `.claude/skills/`; die Kernfassung unter
+    `.koolie/core/framework/skills/` blieb lesbar, und `ksk004p01` baute den Plan
+    aus ihr nach. Jetzt faellt beides. Der Waechter prueft nicht, ob die Verzeichnisse
+    fehlen - das belegt sich selbst -, sondern ob ein Satz, der NUR in diesem Skill
+    steht, irgendwo im Baum ueberlebt hat (dieselbe Lehre wie der Stammwaechter von
+    D-205: gesucht wird nach dem, was die Schranke AUSMACHT).
+
+Beide Schnitte brechen mit Exit 1 ab, wenn ihr Waechter etwas findet - ein Messbaum
+mit Rest ist kein Messbaum (D-205).
+"""
+import io
+import os
+import re
+import shutil
+import sys
+
+sys.stdout.reconfigure(encoding="utf-8")
+sys.dont_write_bytecode = True
+
+# --- aufzeichnungen ------------------------------------------------------------------
+WEG = [
+    ".koolie/core/governance/change-requests",
+    ".koolie/core/governance/DECISION_LOG.md",
+    # Aus `tests/` nur, was Aufzeichnung oder Werkzeug der Framework-Entwicklung ist.
+    # 🔴 Die Hook-Skripte der Laufzeitschicht liegen in `tests/scripts/` und bleiben -
+    # gemessen am 2026-09-26: Der erste Schnitt nahm `tests/` ganz, und der Waechter des
+    # Aufbaus fand zwei Hook-Befehle ohne Skript. Ein Messbaum ohne Schutz-Hook misst
+    # einen anderen Client.
+    ".koolie/core/tests/protocols",
+    ".koolie/core/tests/erhebungen",
+    ".koolie/core/tests/TEST_CATALOG.md",
+    ".koolie/core/tests/scripts/probe-pruefungen.py",
+    ".koolie/core/tests/scripts/validate-framework.py",
+    # 🔴 Seit 1.19.1 sind Sondenskript und Validator Einstieg UND Paket (D-479). Die
+    # Liste kannte nur die Einstiege, und der Waechter fand beim ersten Baum danach 31
+    # Kennungen in den Paketen (gemessen am 2026-09-30, Messung zu 1.20.3, D-511).
+    ".koolie/core/tests/scripts/sonden",
+    ".koolie/core/tests/scripts/pruefungen",
+    ".koolie/core/tests/scripts/validate-output.py",
+    ".koolie/core/build",
+    ".koolie/core/CHANGELOG.md",
+    ".koolie/core/docs/ROADMAP.md",
+    ".koolie/core/onboarding/exercises/README.md",
+    "tools/mentorenblatt",
+    "tools/messbaum-b4",
+    "tools/praeparationen",
+    "tools/praeparationen.py",
+]
+# Jedes Testblatt, wo immer es liegt (Kern, Role Packs, gerenderte Ablage).
+WEG_NAME = {"TESTS.md"}
+
+# Zeilen, die fallen, ohne dass ihre Datei faellt: der Hinweis der Projekt-README auf
+# das Mentorenblatt und die Zeilen des Overlay-Aenderungsverlaufs, die von Messungen
+# erzaehlen. Das Overlay selbst ist Regelschicht und bleibt.
+ZEILEN = {
+    "README.md": [r"registrierte Präparationen", r"mentorenblatt"],
+    ".koolie/project-overlay/OVERLAY.md": [
+        r"^\|.*(UEB-\d\d|\b(SK|RE)-\d{3}-[PN]\d\d\b|Me(ß|ss)tag|Bündel|Nachlauf|Präparation)"],
+}
+
+# Was im geschnittenen Baum nicht mehr stehen darf: die Kennung einer Praeparation und
+# die Kennung einer Zelle. ⚠️ Gemessen am 2026-09-26, bevor der Waechter so eng wurde:
+# Die Woerter "Koeder", "Praeparation" und "Mentorenblatt" trafen 39 Zeilen - das
+# Onboarding (drei allgemeine Koeder der Uebung Ü6), Code-Kommentare des
+# Uebungsrepositoriums, die auf das gesperrte Mentorenblatt verweisen, und
+# Hook-Beschreibungen der Client Packs. Keine nannte eine Praeparation oder eine Zelle,
+# alle standen in jeder frueheren Messung; ein Waechter, der sie meldet, meldet Rauschen.
+VERRAT = [
+    re.compile(r"UEB-\d\d"),
+    re.compile(r"\b(SK|RE)-\d{3}-[PN]\d\d\b"),
+]
+# `.env` IST die Praeparation `UEB-04` (Gegenstand der `deny`-Regel auf Secret-Dateien)
+# und fuer den Lauf gesperrt; ihr Kopfkommentar nennt sich selbst.
+AUSGENOMMEN = {".env"}
+UEBERSPRINGEN = {".git", "node_modules"}
+
+
+def dateien(wurzel):
+    for d, unter, namen in os.walk(wurzel):
+        unter[:] = [u for u in unter if u not in UEBERSPRINGEN]
+        for n in namen:
+            yield os.path.join(d, n)
+
+
+def rel(wurzel, pfad):
+    return os.path.relpath(pfad, wurzel).replace(os.sep, "/")
+
+
+def weg(pfad):
+    def onexc(func, p, exc):
+        os.chmod(p, 0o700)
+        func(p)
+    if os.path.isdir(pfad):
+        shutil.rmtree(pfad, onexc=onexc)
+    elif os.path.lexists(pfad):
+        os.remove(pfad)
+
+
+def lies(pfad):
+    try:
+        return io.open(pfad, encoding="utf-8", newline="").read()
+    except (UnicodeDecodeError, OSError):
+        return None
+
+
+def aufzeichnungen(baum, tools_bleiben=False):
+    entfernt = 0
+    for r in WEG:
+        if tools_bleiben and r.startswith("tools/"):
+            continue
+        p = os.path.join(baum, *r.split("/"))
+        if os.path.lexists(p):
+            weg(p)
+            entfernt += 1
+            print("entfernt:", r)
+    for p in list(dateien(baum)):
+        if os.path.basename(p) in WEG_NAME:
+            os.remove(p)
+            entfernt += 1
+    print("entfernt: %d Testblaetter und Ablagen insgesamt" % entfernt)
+
+    for r, muster in ZEILEN.items():
+        p = os.path.join(baum, *r.split("/"))
+        text = lies(p)
+        if text is None:
+            continue
+        nl = "\r\n" if "\r\n" in text else "\n"
+        rx = [re.compile(m, re.IGNORECASE) for m in muster]
+        alt = text.split(nl)
+        neu = [z for z in alt if not any(x.search(z) for x in rx)]
+        if len(neu) != len(alt):
+            io.open(p, "wb").write(nl.join(neu).encode("utf-8"))
+            print("Zeilen: %s - %d entfernt" % (r, len(alt) - len(neu)))
+
+    # --- Waechter: nichts, was eine Praeparation oder eine Zelle verraet -------------
+    rest = []
+    for p in dateien(baum):
+        r = rel(baum, p)
+        if r in AUSGENOMMEN or (tools_bleiben and r.startswith("tools/")):
+            continue
+        text = lies(p)
+        if text is None:
+            continue
+        for i, z in enumerate(text.splitlines(), 1):
+            for x in VERRAT:
+                if x.search(z):
+                    rest.append("%s:%d  %s" % (r, i, z.strip()[:110]))
+                    break
+    if rest:
+        print("Waechter: %d Fundstellen, die eine Praeparation oder Zelle verraten:" % len(rest))
+        for z in rest[:40]:
+            print("  " + z)
+        raise SystemExit("ABBRUCH: der Baum verraet noch Praeparationen (%d Fundstellen)" % len(rest))
+    print("Waechter aufzeichnungen: 0 Fundstellen (Kennung einer Praeparation "
+          "oder einer Zelle)")
+
+
+# --- ohneskill ---------------------------------------------------------------------------
+SKILL_ABLAGEN = [".claude/skills", ".koolie/core/framework/skills"]
+MINDESTLAENGE = 50
+
+
+def stammsaetze(baum, skill):
+    """Die Zeilen des Skills, die NIRGENDS SONST im Baum stehen.
+
+    ⚠️ Gemessen am 2026-09-26: `fw-plan` zitiert die Kopfzeile der Planvorlage woertlich.
+    Wer nur gegen die anderen Skills abgleicht, haelt sie fuer einen Stammsatz, und der
+    Waechter meldet die Vorlage - Regelschicht, die der Kontrollbaum behalten muss.
+    """
+    kern = os.path.join(baum, ".koolie", "core", "framework", "skills")
+    eigen = lies(os.path.join(kern, skill, "SKILL.md"))
+    if eigen is None:
+        raise SystemExit("ABBRUCH: %s/SKILL.md fehlt im Kern - nichts zu schneiden" % skill)
+    eigene_ablagen = [os.path.join(baum, *r.split("/"), skill) for r in SKILL_ABLAGEN]
+    fremd = set()
+    for p in dateien(baum):
+        if any(p.startswith(a + os.sep) for a in eigene_ablagen):
+            continue
+        t = lies(p)
+        if t:
+            fremd.update(z.strip() for z in t.splitlines())
+    return [z.strip() for z in eigen.splitlines()
+            if len(z.strip()) >= MINDESTLAENGE and z.strip() not in fremd]
+
+
+def ohneskill(baum, skills):
+    stamm = {}
+    for skill in skills:
+        stamm[skill] = stammsaetze(baum, skill)
+        if not stamm[skill]:
+            raise SystemExit("ABBRUCH: kein Stammsatz fuer %s - der Waechter haette nichts zu suchen" % skill)
+    for r in SKILL_ABLAGEN:
+        ablage = os.path.join(baum, *r.split("/"))
+        if not os.path.isdir(ablage):
+            continue
+        for n in sorted(os.listdir(ablage)):
+            weg(os.path.join(ablage, n))
+        print("entfernt: %s/* (alle Skills)" % r)
+    for pflicht in ("CLAUDE.md", ".claude/rules/00-framework-core.md"):
+        if not os.path.isfile(os.path.join(baum, *pflicht.split("/"))):
+            raise SystemExit("ABBRUCH: %s fehlt - die Regelschicht ist mitgefallen" % pflicht)
+
+    rest = []
+    for p in dateien(baum):
+        text = lies(p)
+        if not text:
+            continue
+        for skill, saetze in stamm.items():
+            for s in saetze:
+                if s in text:
+                    rest.append("%s  %s  %s" % (skill, rel(baum, p), s[:80]))
+    if rest:
+        print("Waechter: %d Stammsaetze ueberleben:" % len(rest))
+        for z in rest[:20]:
+            print("  " + z)
+        raise SystemExit("ABBRUCH: %d Stammsaetze im Baum" % len(rest))
+    for skill, saetze in stamm.items():
+        print("Waechter ohneskill: %d Stammsaetze von %s, keiner im Baum" % (len(saetze), skill))
+    print("Regelschicht steht (CLAUDE.md, 00-framework-core.md)")
+
+
+if __name__ == "__main__":
+    if len(sys.argv) in (3, 4) and sys.argv[1] == "aufzeichnungen":
+        if len(sys.argv) == 4 and sys.argv[3] != "--tools-bleiben":
+            raise SystemExit("unbekannter Schalter: " + sys.argv[3])
+        aufzeichnungen(os.path.abspath(sys.argv[2]), len(sys.argv) == 4)
+    elif len(sys.argv) >= 4 and sys.argv[1] == "ohneskill":
+        ohneskill(os.path.abspath(sys.argv[2]), sys.argv[3:])
+    else:
+        raise SystemExit(__doc__.split("\n\n")[1])

package/.koolie/core/tests/erhebungen/messen.py

@@ -0,0 +1,72 @@
+# -*- coding: utf-8 -*-
+"""Der Einstieg in den Messapparat (CR-2026-160, D-473).
+
+    python messen.py REIHE.json pruefen            nur das Schema der Reihe
+    python messen.py REIHE.json aufbau             Sollstaende festhalten, Vertrauen setzen
+    python messen.py REIHE.json vorpruefung [K..]  Baeume herrichten und pruefen, nichts fahren
+    python messen.py REIHE.json lauf [K..]         fahren, was fehlt - Abbruch bei jedem Befund
+    python messen.py REIHE.json auswertung [FELD]  Tabelle je Lauf, Summen je FELD (variante, gruppe)
+    python messen.py REIHE.json aufraeumen         Vertrauen entfernen
+    python messen.py basis ZIEL CLIENT PRAEP.json  eine frische Installation als Basis bauen
+    python messen.py stand-marke PFAD [PFAD..]     Standmarke fuer eine Ergebniszelle (K-61)
+    python messen.py selbsttest                    der Apparat gegen die Attrappe, ohne Kontingent
+
+Die Reihe liegt in der Erhebungsablage; ihre Belege entstehen unter belege/NAME daneben.
+"""
+import io
+import json
+import os
+import sys
+
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+sys.stdout.reconfigure(encoding="utf-8")
+
+from apparat import baum, belege, laeufer, stand  # noqa: E402
+
+
+def main(argv: list) -> int:
+    if not argv:
+        print(__doc__)
+        return 2
+    if argv[0] == "selbsttest":
+        from apparat import selbsttest
+        return selbsttest.main()
+    if argv[0] == "stand-marke":
+        print(stand.marke(argv[1:]))
+        return 0
+    if argv[0] == "basis":
+        ziel, client, praep = argv[1], argv[2], argv[3]
+        schritte = json.loads(io.open(praep, encoding="utf-8").read())
+        soll = baum.basis_bauen(ziel, belege.KERN, client, schritte)
+        print(json.dumps(soll, indent=1))
+        return 0
+    reihe = laeufer.laden(argv[0])
+    befehl = argv[1] if len(argv) > 1 else "pruefen"
+    rest = argv[2:]
+    if befehl == "pruefen":
+        print(f"Reihe '{reihe.name}': {len(reihe.laeufe)} Laeufe, fahrbar")
+    elif befehl == "aufbau":
+        for b in laeufer.aufbau(reihe):
+            print("Sollstand und Vertrauen:", b)
+    elif befehl == "vorpruefung":
+        ergebnis = laeufer.vorpruefen(reihe, rest or None)
+        schlecht = 0
+        for k, befunde in ergebnis.items():
+            print(f"{k}: {'in Ordnung' if not befunde else '; '.join(befunde)}")
+            schlecht += bool(befunde) and befunde != ["(schon gefahren)"]
+        return 1 if schlecht else 0
+    elif befehl == "lauf":
+        laeufer.fahren(reihe, rest or None)
+    elif befehl == "auswertung":
+        print(belege.auswerten(reihe, rest[0] if rest else ""))
+    elif befehl == "aufraeumen":
+        laeufer.aufraeumen(reihe)
+        print("Vertrauen entfernt")
+    else:
+        print(__doc__)
+        return 2
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main(sys.argv[1:]))

package/.koolie/core/tests/erhebungen/node-waechter.py

@@ -0,0 +1,74 @@
+# -*- coding: utf-8 -*-
+"""Waechter ueber den GETEILTEN node_modules-Bestand.
+
+    python node-waechter.py vorher
+    python node-waechter.py nachher
+
+Alle 36 Baeume tragen dieselbe Verzeichnisverbindung auf
+`test-devin-framework/frontend/node_modules`. Das ist der Preis dafuer, dass der
+Testbefehl im Messbaum ueberhaupt laeuft - ein Baum aus `git archive HEAD`
+traegt kein `node_modules`, und 118 MB je Baum waeren 4 GB.
+
+🔴 Geteilt heisst: Ein Lauf, der dorthin schreibt, veraendert JEDEN Baum und das
+Uebungsrepositorium dazu. `frontend/node_modules/**` steht in <EXCLUDED_PATHS>
+und im deny-Korb; dieser Waechter belegt, dass die Sperre gehalten hat. Er
+zaehlt Dateien und Bytes - ein vollstaendiger Hashlauf ueber 9798 Dateien waere
+je Aufnahme teurer als sein Erkenntnisgewinn.
+
+Das Werkzeug schreibt seinen Zwischenstand (`.vite`, `.cache`) unterhalb von
+node_modules; solche Pfade werden gesondert ausgewiesen, damit eine erwartbare
+Aenderung nicht wie ein Schreibzugriff aussieht.
+"""
+import io
+import json
+import os
+import sys
+
+import ablage
+
+sys.stdout.reconfigure(encoding="utf-8")
+
+HIER = ablage.erhebung()
+# D-231: der Pfad wird gesagt, nicht im Quelltext gefuehrt.
+QUELLE = os.path.join(ablage.uebungsrepositorium(), "frontend", "node_modules")
+ZWISCHENSTAND = (".vite", ".cache", ".tmp")
+
+
+def aufnehmen():
+    dateien, bytes_, zwischen = 0, 0, 0
+    for wurzel, dirs, namen in os.walk(QUELLE):
+        rel = os.path.relpath(wurzel, QUELLE).replace("\\", "/")
+        ist_zwischen = any(t in rel.split("/") for t in ZWISCHENSTAND)
+        for name in namen:
+            try:
+                groesse = os.path.getsize(os.path.join(wurzel, name))
+            except OSError:
+                continue
+            if ist_zwischen:
+                zwischen += 1
+                continue
+            dateien += 1
+            bytes_ += groesse
+    return {"dateien": dateien, "bytes": bytes_, "zwischenstand": zwischen}
+
+
+was = sys.argv[1]
+ziel = os.path.join(HIER, "node-%s.json" % was)
+jetzt = aufnehmen()
+io.open(ziel, "wb").write(json.dumps(jetzt, indent=1).encode("utf-8"))
+print("%s: %d Dateien, %.1f MB (dazu %d Zwischenstandsdateien)"
+      % (was, jetzt["dateien"], jetzt["bytes"] / 1048576.0, jetzt["zwischenstand"]))
+
+vorher_pfad = os.path.join(HIER, "node-vorher.json")
+if was == "nachher" and os.path.isfile(vorher_pfad):
+    vorher = json.load(io.open(vorher_pfad, encoding="utf-8"))
+    gleich = (vorher["dateien"] == jetzt["dateien"]
+              and vorher["bytes"] == jetzt["bytes"])
+    if gleich:
+        print("UNVERAENDERT - kein Lauf hat in den geteilten Bestand geschrieben.")
+    else:
+        print("VERAENDERT: %d -> %d Dateien, %d -> %d Bytes"
+              % (vorher["dateien"], jetzt["dateien"],
+                 vorher["bytes"], jetzt["bytes"]))
+        print("🔴 Das ist ein Befund: Die Sperre auf frontend/node_modules/** hat "
+              "nicht gehalten, und der geteilte Bestand liegt in jedem Baum.")