@renoxar/koolie 1.25.0

package/.koolie/core/tests/erhebungen/cc-overlay-fuellen.py

@@ -0,0 +1,277 @@
+# -*- coding: utf-8 -*-
+"""Fuellt die claude-code-Installation der Messumgebung mit den Overlay-Werten.
+
+Aufruf:  python cc-overlay-fuellen.py <zielverzeichnis>
+
+NEU MIT S5 (Lehre aus 0.65.0): Die Werte werden aus dem QUELL-OVERLAY des
+Uebungsrepositoriums ABGELEITET, nicht im Skript gepflegt. Die Vorgaengerfassung
+fuehrte eine Handliste, in der `.github/**` stand, obwohl das Uebungs-Overlay seit
+0.63.0 `.github/workflows/**` sagt - genau die Drift, die 0.65.0 in den
+Laufzeittraegern gefunden hat.
+
+    Marken, Wurzeln und Namenslisten gehoeren abgeleitet, nicht gepflegt.
+
+Zwei Quellen, beide versioniert:
+
+  1. `.koolie/project-overlay/OVERLAY.md`  - die QUELLE. Aus ihren Tabellen (Abschnitt 4
+     und 5) kommen die sechs Platzhalterwerte.
+  2. `.devin/config.json`          - die BINDENDE Schicht des Uebungsrepositoriums.
+     Aus ihr kommen die projekteigenen `Write`-Verbote, die der Kern gar nicht
+     erzeugt (Nur-Lese-Pfade, Abhaengigkeitsdateien). Sie werden auf `Edit(...)`
+     abgebildet, weil `claude-code` und `devin-desktop` zwei Namensraeume sind.
+
+Jede Ersetzung bricht bei abweichender Trefferzahl ab; geschrieben wird erst am Ende.
+"""
+import io
+import json
+import os
+import re
+import sys
+
+import ablage
+
+sys.stdout.reconfigure(encoding="utf-8")
+
+CC = os.path.abspath(sys.argv[1])
+DD = ablage.uebungsrepositorium()           # D-231: gesagt, nicht im Quelltext
+
+OVERLAY = os.path.join(DD, ".koolie/project-overlay", "OVERLAY.md")
+DEVIN_CONF = os.path.join(DD, ".devin", "config.json")
+
+
+# --- 1. Werte aus der QUELLE ableiten ---------------------------------------------
+def zellen(zeile):
+    if not zeile.startswith("|"):
+        return None
+    teile = zeile.split("|")
+    return [t.strip() for t in teile[1:-1]]
+
+
+def werte_aus_overlay(text):
+    """Platzhaltername -> Liste der Werte, aus jeder Tabellenzeile, die ihn fuehrt.
+
+    Gelesen wird die Zelle RECHTS von der Platzhalterzelle - in Abschnitt 4 heisst
+    sie `Wert`, in Abschnitt 5 `Befehl`. Der Zuschnitt haengt an der STELLUNG, nicht
+    an der Ueberschrift.
+    """
+    gefunden = {}
+    for zeile in text.replace("\r\n", "\n").split("\n"):
+        z = zellen(zeile)
+        if not z or len(z) < 3:
+            continue
+        for i, zelle in enumerate(z[:-1]):
+            m = re.fullmatch(r"`(<[A-Z_]+>)`", zelle)
+            if not m:
+                continue
+            name = m.group(1)
+            wertzelle = z[i + 1]
+            werte = re.findall(r"`([^`]+)`", wertzelle)
+            if not werte:
+                continue
+            if name in gefunden:
+                raise SystemExit("ABBRUCH: %s steht in zwei Tabellenzeilen" % name)
+            gefunden[name] = werte
+    return gefunden
+
+
+overlay_text = io.open(OVERLAY, encoding="utf-8", newline="").read()
+WERTE = werte_aus_overlay(overlay_text)
+
+GEBRAUCHT = ["<EXCLUDED_PATHS>", "<CI_CONFIG_PATHS>", "<QUALITY_GATE_CONFIG_PATHS>",
+             "<BUILD_COMMAND>", "<TEST_COMMAND>", "<LINT_COMMAND>",
+             # K-154 (D-407): Seit 1.5.0 fuehrt der Kern den Schlitz `write <READ_ONLY_PATHS>`,
+             # in dieser Berechtigungsdatei `Edit(<READ_ONLY_PATHS>)`. Bis 1.11.0 entfaltete
+             # das Skript ihn nicht und brach mit "Platzhalter uebrig" ab.
+             "<READ_ONLY_PATHS>"]
+fehlt = [n for n in GEBRAUCHT if n not in WERTE]
+if fehlt:
+    raise SystemExit("ABBRUCH: im Quell-Overlay nicht gefunden: %r" % fehlt)
+for name in GEBRAUCHT:
+    print("aus OVERLAY.md: %-30s %s" % (name, ", ".join(WERTE[name])))
+
+
+# --- 2. settings.json -------------------------------------------------------------
+def entfalte(liste, marke, werte, huelle):
+    """Ersetzt genau einen Eintrag huelle(marke) durch huelle(w) je Wert."""
+    ziel = huelle % marke
+    if liste.count(ziel) != 1:
+        raise SystemExit("ABBRUCH: %r steht %dx statt 1x" % (ziel, liste.count(ziel)))
+    i = liste.index(ziel)
+    return liste[:i] + [huelle % w for w in werte] + liste[i + 1:]
+
+
+pfad = os.path.join(CC, ".claude", "settings.json")
+_roh_settings = io.open(pfad, encoding="utf-8", newline="").read()
+CRLF_SETTINGS = "\r\n" in _roh_settings
+d = json.loads(_roh_settings)
+p = d["permissions"]
+
+p["deny"] = entfalte(p["deny"], "<EXCLUDED_PATHS>", WERTE["<EXCLUDED_PATHS>"], "Read(%s)")
+p["deny"] = entfalte(p["deny"], "<EXCLUDED_PATHS>", WERTE["<EXCLUDED_PATHS>"], "Edit(%s)")
+p["deny"] = entfalte(p["deny"], "<CI_CONFIG_PATHS>", WERTE["<CI_CONFIG_PATHS>"], "Edit(%s)")
+p["deny"] = entfalte(p["deny"], "<QUALITY_GATE_CONFIG_PATHS>",
+                     WERTE["<QUALITY_GATE_CONFIG_PATHS>"], "Edit(%s)")
+p["deny"] = entfalte(p["deny"], "<READ_ONLY_PATHS>", WERTE["<READ_ONLY_PATHS>"], "Edit(%s)")
+# Seit 1.18.2 fuehrt das Pack ZWEI Befehlswerkzeuge (D-469). Hier stand nur die Huelle
+# 'Bash(%s)', und das Skript brach beim ersten Baumbau danach mit "Platzhalter uebrig:
+# PowerShell(<BUILD_COMMAND>)" ab (1.19.0, gemessen). Die Huellen werden deshalb aus dem
+# Korb abgeleitet: jedes Werkzeug, das den Schlitz traegt.
+for _schlitz in ("<BUILD_COMMAND>", "<TEST_COMMAND>", "<LINT_COMMAND>"):
+    _huellen = sorted({e.split("(", 1)[0] for e in p["ask"] if e.endswith("(%s)" % _schlitz)})
+    if not _huellen:
+        raise SystemExit("ABBRUCH: %s steht in keiner Huelle des ask-Korbs" % _schlitz)
+    for _werkzeug in _huellen:
+        p["ask"] = entfalte(p["ask"], _schlitz, WERTE[_schlitz], _werkzeug + "(%s)")
+
+# --- 3. Die projekteigenen Schreibverbote aus der BINDENDEN Schicht ----------------
+# Gebraucht werden die Schreibverbote, die das PROJEKT eingetragen hat - die
+# Nur-Lese-Pfade und die Abhaengigkeitsdateien. Die uebrigen Eintraege der
+# devin-Berechtigungsdatei erzeugt der Kern selbst, und zwar unter den STRUKTURNAMEN
+# des jeweiligen Packs (`AGENTS.md` gegen `CLAUDE.md`, `.devin/**` gegen `.claude/**`).
+# Wer sie mitnimmt, traegt fremde Pfade in eine Berechtigungsdatei.
+#
+# Die Trennung wird ABGELEITET, nicht gepflegt: Eine frische devin-desktop-Installation
+# in einem leeren Verzeichnis liefert genau den vom Kern erzeugten Bestand; was in der
+# Projektdatei darueber hinaussteht, gehoert dem Projekt.
+import shutil                                                            # noqa: E402
+import subprocess                                                        # noqa: E402
+import tempfile                                                          # noqa: E402
+
+devin = json.loads(io.open(DEVIN_CONF, encoding="utf-8", newline="").read())
+ref = tempfile.mkdtemp(prefix="lw-ref-")
+try:
+    shutil.copytree(os.path.join(CC, ".koolie/core"), os.path.join(ref, ".koolie/core"))
+    r = subprocess.run([sys.executable, os.path.join(ref, ".koolie/core", "install.py"),
+                        "--client", "devin-desktop", "--root", ref],
+                       capture_output=True, text=True, encoding="utf-8", errors="replace")
+    if r.returncode != 0:
+        raise SystemExit("ABBRUCH: Referenzinstallation scheiterte:\n" + r.stdout[-1500:])
+    kern = json.loads(io.open(os.path.join(ref, ".devin", "config.json"),
+                              encoding="utf-8", newline="").read())["permissions"]["deny"]
+finally:
+    shutil.rmtree(ref, ignore_errors=True)
+
+# Die Platzhalter der Referenz mit denselben Werten entfalten, sonst zaehlten
+# `Write(<CI_CONFIG_PATHS>)` und sein entfalteter Wert als zwei verschiedene Regeln.
+kern_entfaltet = []
+for regel in kern:
+    m = re.fullmatch(r"(\w+)\((<[A-Z_]+>)\)", regel)
+    if m and m.group(2) in WERTE:
+        kern_entfaltet += ["%s(%s)" % (m.group(1), w) for w in WERTE[m.group(2)]]
+    else:
+        kern_entfaltet.append(regel)
+
+eigen = [x for x in devin["permissions"]["deny"]
+         if x.startswith("Write(") and x not in kern_entfaltet]
+print("Referenzinstallation devin-desktop: %d deny-Regeln vom Kern; "
+      "projekteigene Schreibverbote: %d" % (len(kern), len(eigen)))
+nachgetragen = []
+for x in eigen:
+    regel = "Edit(%s)" % re.fullmatch(r"Write\((.*)\)", x).group(1)
+    if regel not in p["deny"]:
+        p["deny"].append(regel)
+        nachgetragen.append(regel)
+for r_ in nachgetragen:
+    print("   nachgetragen:", r_)
+
+rest = [x for korb in ("deny", "ask", "allow") for x in p[korb] if "<" in x and ">" in x]
+if rest:
+    raise SystemExit("ABBRUCH: Platzhalter uebrig: %r" % rest)
+
+neu_settings = json.dumps(d, ensure_ascii=False, indent=2) + "\n"
+
+# --- 4. Laufzeitfassung des Overlays ----------------------------------------------
+quelle = io.open(os.path.join(DD, ".devin", "rules", "20-project-overlay.md"),
+                 encoding="utf-8", newline="").read().replace("\r\n", "\n")
+ziel_pfad = os.path.join(CC, ".claude", "rules", "20-project-overlay.md")
+_roh_vorlage = io.open(ziel_pfad, encoding="utf-8", newline="").read()
+CRLF_OVERLAY = "\r\n" in _roh_vorlage
+vorlage = _roh_vorlage.replace("\r\n", "\n")
+
+# Der Kopf ist clientabhaengig: devin-desktop traegt YAML-Frontmatter, claude-code
+# einen Kommentarblock. Der Koerper ist inhaltlich identisch (sagt die Vorlage selbst).
+kopf_ende = vorlage.index("# Project Overlay")
+kopf = vorlage[:kopf_ende]
+koerper = quelle[quelle.index("# Project Overlay"):]
+if koerper.count(".devin/") < 1:
+    raise SystemExit("ABBRUCH: kein .devin/ im Koerper - Ersetzung wuerde nichts tun")
+anzahl = koerper.count(".devin/")
+koerper = koerper.replace(".devin/", ".claude/")
+anzahl_agents = koerper.count("AGENTS.md")
+koerper = koerper.replace("AGENTS.md", "CLAUDE.md")
+neu_overlay = kopf + koerper
+
+# --- 5. Waechter: der Wert der Quelle steht in der Laufzeitfassung -----------------
+# Genau der Abgleich, den Pruefung 59 im Repositorium fuehrt - hier auf dem Messbaum,
+# damit ein Meszaufbau nicht still den alten Wert traegt (Befund 0.65.0).
+for wert in WERTE["<EXCLUDED_PATHS>"]:
+    if wert not in neu_overlay:
+        raise SystemExit("ABBRUCH: %r steht nicht in der Laufzeitfassung" % wert)
+print("Waechter: alle %d Werte von <EXCLUDED_PATHS> stehen in der Laufzeitfassung"
+      % len(WERTE["<EXCLUDED_PATHS>"]))
+
+# --- 6. Die Overlay-Regelerweiterungen (Ebene 5) und ihr Verweis im Manifest --------
+# K-154 (D-407): Der Packwechsel laesst die Regelerweiterungen des Projekts zurueck
+# (`K-44`) - im Uebungsrepositorium `21-overlay-coding-guidelines.md` unter `.devin/rules/`.
+# Das Overlay-Manifest des Messbaums verwies danach mit `DOC-001` auf einen Pfad des Packs
+# `devin-desktop`, und der Validator meldete im Nachlauf von 1.11.0 in jedem Baum einen
+# Fehler, der nicht dem Lauf gehoerte. Die Erweiterung wird deshalb mit der Abbildung des
+# Kerns (`render_rule`) in die Form dieses Packs gebracht, und der Verweis zieht mit.
+import importlib.util                                                    # noqa: E402
+
+sys.path.insert(0, os.path.join(CC, ".koolie", "core"))
+_spec = importlib.util.spec_from_file_location(
+    "_install_cc", os.path.join(CC, ".koolie", "core", "install.py"))
+_install = importlib.util.module_from_spec(_spec)
+_spec.loader.exec_module(_install)
+_man_cc = json.loads(io.open(os.path.join(CC, ".koolie", "core", "clients", "claude-code",
+                                          "manifest.json"), encoding="utf-8").read())
+erweiterungen = {}
+_dd_regeln = os.path.join(DD, ".devin", "rules")
+for name in sorted(os.listdir(_dd_regeln)):
+    if not re.fullmatch(r"2[1-9]-overlay-[A-Za-z0-9_-]+\.md", name):
+        continue
+    roh = io.open(os.path.join(_dd_regeln, name), encoding="utf-8", newline="").read()
+    crlf = "\r\n" in roh
+    neu = _install.render_rule(roh.replace("\r\n", "\n"), _man_cc)
+    if crlf:
+        neu = neu.replace("\n", "\r\n")
+    erweiterungen[name] = neu
+
+man_pfad = os.path.join(CC, ".koolie", "project-overlay", "overlay-manifest.yaml")
+neu_man = io.open(man_pfad, encoding="utf-8", newline="").read()
+for name in erweiterungen:
+    alt = ".devin/rules/" + name
+    if neu_man.count(alt) > 1:
+        raise SystemExit("ABBRUCH: %r steht %dx im Overlay-Manifest" % (alt, neu_man.count(alt)))
+    neu_man = neu_man.replace(alt, ".claude/rules/" + name)
+# Gewacht wird ueber die VERWEISFELDER, nicht ueber jede Nennung: Die `notes` des
+# Uebungs-Manifests nennen `.devin/rules/20-project-overlay.md` als Prosa, und ein
+# Waechter ueber den ganzen Text brach beim ersten Probelauf daran ab.
+rest_man = re.findall(r"rule_file:\s*[\"']?(\.devin/[^\s\"']+)", neu_man)
+if rest_man:
+    raise SystemExit("ABBRUCH: Overlay-Manifest verweist weiter auf das Pack devin-desktop: %r"
+                     % rest_man)
+
+# --- 7. schreiben -----------------------------------------------------------------
+# Die Zeilenenden der ueberschriebenen Dateien bleiben erhalten (K-154).
+if CRLF_SETTINGS:
+    neu_settings = neu_settings.replace("\n", "\r\n")
+if CRLF_OVERLAY:
+    neu_overlay = neu_overlay.replace("\n", "\r\n")
+daten_s = neu_settings.encode("utf-8")
+daten_o = neu_overlay.encode("utf-8")
+daten_m = neu_man.encode("utf-8")
+daten_e = {name: text.encode("utf-8") for name, text in erweiterungen.items()}
+io.open(pfad, "wb").write(daten_s)
+io.open(ziel_pfad, "wb").write(daten_o)
+io.open(man_pfad, "wb").write(daten_m)
+for name, daten in daten_e.items():
+    io.open(os.path.join(CC, ".claude", "rules", name), "wb").write(daten)
+    print("Regelerweiterung uebertragen:", name)
+print("Zeilenenden erhalten: settings.json %s, 20-project-overlay.md %s"
+      % ("CRLF" if CRLF_SETTINGS else "LF", "CRLF" if CRLF_OVERLAY else "LF"))
+print("settings.json: deny=%d ask=%d allow=%d" % (len(p["deny"]), len(p["ask"]), len(p["allow"])))
+print("20-project-overlay.md: %d x .devin/ -> .claude/, %d x AGENTS.md -> CLAUDE.md"
+      % (anzahl, anzahl_agents))
+print("OK")

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

@@ -0,0 +1,178 @@
+# -*- coding: utf-8 -*-
+"""Legt je Zelle von Buendel 4 EIN Dossier an - Erwartung und Beleg nebeneinander.
+
+    python dossier-b4.py
+
+Ergebnis: `belege/dossier/SK-NNN-XNN.md`, neunzehn Dateien. Jede traegt
+
+  1. die Zeile des Testblatts, Spalte fuer Spalte (Vorbedingung, Eingabe,
+     Erwartetes Verhalten, Unzulaessiges Verhalten, Ergebnisstatus),
+  2. die Kennzahlen und Merkmale beider Laeufe aus der Auswertung,
+  3. die vollstaendige Antwort des Haupt- und des Kontrollaufs.
+
+🔴 WARUM DAS EIN EIGENES WERKZEUG IST. Die Bewertung einer Zelle verlangt, die
+Erwartung gegen den Beleg zu halten. Beides lag an drei verschiedenen Orten: die
+Erwartung in einem der drei Testblaetter, die Kennzahlen in einer 328-Zeilen-Datei,
+die Antwort in bis zu vier Belegdateien je Zelle. Wer so bewertet, blaettert - und
+wer blaettert, vergleicht irgendwann aus dem Gedaechtnis.
+
+⚠️ Das Dossier BEWERTET NICHT. Es legt nebeneinander; das Urteil faellt ein Mensch
+oder ein Lauf, der beides gelesen hat.
+"""
+import io
+import os
+import re
+import subprocess
+import sys
+import time
+
+import ablage
+
+sys.stdout.reconfigure(encoding="utf-8")
+
+BELEGE = ablage.belege()
+ZIEL = os.path.join(BELEGE, "dossier")
+KERN = os.path.join(ablage.WURZEL, ".koolie/core")   # D-231: abgeleitet
+# 🔴 DIE AUSWERTUNG WIRD GEFAHREN, NICHT GESUCHT (D-232). Hier stand der
+# Dateiname `auswertung-2026-09-20.log` - ein DATUM im Quelltext, und damit
+# dieselbe Bauform wie die drei `--erwarte`-Sollwerte von D-225: Er stimmte
+# fuer den Messtag, fuer den er geschrieben wurde, und fuer keinen danach. Der
+# Nachlauf hat am 2026-09-21 ausgewertet, und dieses Werkzeug brach ab mit
+# "erst auswerten-b4.py" - obwohl die Auswertung gefahren war.
+#
+#   Ein Werkzeug, das die Ausgabe eines anderen beim Namen nennt, wartet auf
+#   den Tag, an dem jemand diesen Namen anders waehlt.
+#
+# Das Dossier faehrt die Auswertung deshalb SELBST und legt ihr Protokoll mit
+# dem Datum DIESES Laufes neben die Belege. Damit kann ein Dossier auch nicht
+# mehr aus einem alten Protokoll gebaut werden, ohne dass es auffaellt.
+AUSWERTEN = os.path.join(os.path.dirname(os.path.abspath(__file__)),
+                         "auswerten-b4.py")
+AUSWERTUNG = os.path.join(BELEGE, "auswertung-%s.log"
+                          % time.strftime("%Y-%m-%d"))
+
+BLAETTER = {
+    "SK-010": "fw-review-support",
+    "SK-011": "fw-docs-update",
+    "SK-012": "fw-mr-description",
+}
+SPALTEN = ["Test-ID", "Ziel", "Vorbedingung", "Eingabe", "Erwartetes Verhalten",
+           "Unzulaessiges Verhalten", "Pruefmethode", "Ergebnisstatus"]
+
+
+def lies(pfad):
+    return io.open(pfad, encoding="utf-8", newline="").read()
+
+
+def blattzeilen():
+    """Je Zellenkennung die Spalten ihrer Zeile im Testblatt."""
+    zeilen = {}
+    for praefix, skill in BLAETTER.items():
+        pfad = os.path.join(KERN, "framework", "skills", skill, "TESTS.md")
+        for z in lies(pfad).splitlines():
+            if not z.startswith("| " + praefix + "-"):
+                continue
+            felder = [f.strip() for f in z.strip().strip("|").split(" | ")]
+            kennung = felder[0]
+            zeilen[kennung] = (skill, felder)
+    return zeilen
+
+
+def auswertung_fahren():
+    """Faehrt `auswerten-b4.py` und legt sein Protokoll neben die Belege."""
+    umg = dict(os.environ, PYTHONIOENCODING="utf-8")
+    p = subprocess.run([sys.executable, AUSWERTEN], capture_output=True,
+                       text=True, encoding="utf-8", errors="replace", env=umg)
+    text = (p.stdout or "") + (p.stderr or "")
+    if p.returncode != 0:
+        raise SystemExit("ABBRUCH: auswerten-b4.py endete mit Exit %d:%s%s"
+                         % (p.returncode, chr(10), text[-1500:]))
+    io.open(AUSWERTUNG, "w", encoding="utf-8", newline="").write(text)
+    print("Auswertung gefahren:", AUSWERTUNG)
+    return text
+
+
+def auswertungsbloecke():
+    """Je Zelle der Block aus Abschnitt 2 der Auswertung."""
+    text = auswertung_fahren()
+    bloecke = {}
+    teile = re.split(r"\n--- (SK-\d{3}-[A-Z]\d{2}) ", text)
+    for i in range(1, len(teile) - 1, 2):
+        kennung = teile[i]
+        rest = teile[i + 1]
+        ende = rest.find("\n--- ")
+        schnitt = rest if ende < 0 else rest[:ende]
+        ende2 = schnitt.find("\n====")
+        bloecke[kennung] = (schnitt if ende2 < 0 else schnitt[:ende2]).rstrip()
+    return bloecke
+
+
+def laufkennungen(kennung):
+    """sk010p01 / ksk010p01, dazu die Turns, soweit es Belege gibt."""
+    kern = kennung.lower().replace("-", "")
+    namen = []
+    for vor in ("", "k"):
+        for anhang in ("t1", ""):
+            name = vor + kern + anhang
+            if os.path.isfile(os.path.join(BELEGE, name + "-antwort.md")):
+                namen.append(name)
+    return namen
+
+
+def main():
+    os.makedirs(ZIEL, exist_ok=True)
+    zeilen = blattzeilen()
+    bloecke = auswertungsbloecke()
+    fehlend = sorted(set(zeilen) - set(bloecke))
+    gebaut = 0
+    for kennung in sorted(zeilen):
+        skill, felder = zeilen[kennung]
+        teile = ["# Dossier %s (`%s`)" % (kennung, skill), ""]
+        teile.append("> ⚠️ Dieses Dossier **bewertet nicht**. Es legt die Erwartung des "
+                     "Testblatts neben den Beleg des Laufs.")
+        teile.append("")
+        teile.append("## 1. Die Zeile des Testblatts")
+        teile.append("")
+        teile.append("Quelle: `.koolie/core/framework/skills/%s/TESTS.md`" % skill)
+        teile.append("")
+        for name, wert in zip(SPALTEN, felder):
+            teile.append("**%s**" % name)
+            teile.append("")
+            teile.append(wert if wert else "*(leer)*")
+            teile.append("")
+        teile.append("## 2. Was gemessen wurde")
+        teile.append("")
+        teile.append("```")
+        teile.append(bloecke.get(kennung, "(kein Block in der Auswertung gefunden)"))
+        teile.append("```")
+        teile.append("")
+        teile.append("## 3. Die Antworten der Laeufe")
+        teile.append("")
+        namen = laufkennungen(kennung)
+        if not namen:
+            teile.append("🔴 **Keine Antwortdatei gefunden.**")
+        for name in namen:
+            art = "Kontrollauf" if name.startswith("k") else "Hauptlauf"
+            turn = " – zweiter Turn" if not name.endswith("t1") and (name + "t1") in namen \
+                else (" – erster Turn" if name.endswith("t1") else "")
+            teile.append("### %s `%s`%s" % (art, name, turn))
+            teile.append("")
+            teile.append(lies(os.path.join(BELEGE, name + "-antwort.md")).rstrip())
+            teile.append("")
+        io.open(os.path.join(ZIEL, kennung + ".md"), "w", encoding="utf-8",
+                newline="").write("\n".join(teile) + "\n")
+        gebaut += 1
+        print("%-12s %d Lauf/Laeufe, %6d Zeichen"
+              % (kennung, len(namen),
+                 os.path.getsize(os.path.join(ZIEL, kennung + ".md"))))
+    print()
+    print("%d Dossiers unter %s" % (gebaut, ZIEL))
+    if fehlend:
+        print("🔴 OHNE Auswertungsblock:", ", ".join(fehlend))
+    else:
+        print("🟢 Jede Zelle hat eine Blattzeile UND einen Auswertungsblock.")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

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

@@ -0,0 +1,202 @@
+# -*- coding: utf-8 -*-
+"""Legt je Zelle von Buendel 5 EIN Dossier an - Erwartung und Beleg nebeneinander.
+
+    python dossier-b5.py
+
+Ergebnis: `belege/dossier/RE-001-XNN.md`, fuenfzehn Dateien. Jede traegt
+
+  1. die Zeile des Testblatts, Spalte fuer Spalte (Vorbedingung, Eingabe,
+     Erwartetes Verhalten, Unzulaessiges Verhalten, Ergebnisstatus),
+  2. die Kennzahlen und Merkmale beider Laeufe aus der Auswertung,
+  3. die vollstaendige Antwort des Haupt- und des Kontrollaufs.
+
+🔴 WARUM DAS EIN EIGENES WERKZEUG IST. Die Bewertung einer Zelle verlangt, die
+Erwartung gegen den Beleg zu halten. Beides lag an drei verschiedenen Orten: die
+Erwartung in einem der drei Testblaetter, die Kennzahlen in einer 328-Zeilen-Datei,
+die Antwort in bis zu vier Belegdateien je Zelle. Wer so bewertet, blaettert - und
+wer blaettert, vergleicht irgendwann aus dem Gedaechtnis.
+
+⚠️ Das Dossier BEWERTET NICHT. Es legt nebeneinander; das Urteil faellt ein Mensch
+oder ein Lauf, der beides gelesen hat.
+"""
+import io
+import os
+import re
+import subprocess
+import sys
+import time
+
+import ablage
+
+sys.stdout.reconfigure(encoding="utf-8")
+
+BELEGE = ablage.belege()
+ZIEL = os.path.join(BELEGE, "dossier")
+KERN = os.path.join(ablage.WURZEL, ".koolie/core")   # D-231: abgeleitet
+# 🔴 DIE AUSWERTUNG WIRD GEFAHREN, NICHT GESUCHT (D-232). Hier stand der
+# Dateiname `auswertung-2026-09-20.log` - ein DATUM im Quelltext, und damit
+# dieselbe Bauform wie die drei `--erwarte`-Sollwerte von D-225: Er stimmte
+# fuer den Messtag, fuer den er geschrieben wurde, und fuer keinen danach. Der
+# Nachlauf hat am 2026-09-21 ausgewertet, und dieses Werkzeug brach ab mit
+# "erst auswerten-b4.py" - obwohl die Auswertung gefahren war.
+#
+#   Ein Werkzeug, das die Ausgabe eines anderen beim Namen nennt, wartet auf
+#   den Tag, an dem jemand diesen Namen anders waehlt.
+#
+# Das Dossier faehrt die Auswertung deshalb SELBST und legt ihr Protokoll mit
+# dem Datum DIESES Laufes neben die Belege. Damit kann ein Dossier auch nicht
+# mehr aus einem alten Protokoll gebaut werden, ohne dass es auffaellt.
+AUSWERTEN = os.path.join(os.path.dirname(os.path.abspath(__file__)),
+                         "auswerten-b5.py")
+AUSWERTUNG = os.path.join(BELEGE, "auswertung-%s.log"
+                          % time.strftime("%Y-%m-%d"))
+
+# 🔴 ABGELEITET STATT GEPFLEGT (D-237). `dossier-b4.py` fuehrt die Zuordnung
+# Kennungspraefix -> Skill als Handliste UND setzt den Ablageort auf
+# `framework/skills/<skill>/TESTS.md`. Beides ist fuer Buendel 5 falsch:
+# `role-re-ticket` liegt unter `framework/role-packs/<pack>/skills/`, und
+# eine Handliste haette den Ort nicht mitgefuehrt. `ablage.blaetter()` sucht
+# jede `TESTS.md` des Frameworks und nimmt den Praefix aus der ERSTEN SPALTE
+# ihrer Zeilen - aus dem Blatt selbst, nicht aus seinem Dateinamen.
+SPALTEN = ["Test-ID", "Ziel", "Vorbedingung", "Eingabe", "Erwartetes Verhalten",
+           "Unzulaessiges Verhalten", "Pruefmethode", "Ergebnisstatus"]
+
+
+def lies(pfad):
+    return io.open(pfad, encoding="utf-8", newline="").read()
+
+
+def blattzeilen():
+    """Je Zellenkennung die Spalten ihrer Zeile im Testblatt - abgeleitet.
+
+    Der Ort des Blattes kommt aus `ablage.blaetter()`; gelesen werden nur die
+    Praefixe, die DIESE Erhebung misst (aus `auswerten-b5.PAARE`).
+    """
+    karte = ablage.blaetter()
+    zeilen = {}
+    for praefix, eintrag in karte.items():
+        pfad = os.path.join(ablage.WURZEL, eintrag["blatt"].replace("/", os.sep))
+        for z in lies(pfad).splitlines():
+            if not z.startswith("| " + praefix + "-"):
+                continue
+            felder = [f.strip() for f in z.strip().strip("|").split(" | ")]
+            zeilen[felder[0]] = (eintrag["skill"], felder)
+    return {k: v for k, v in zeilen.items() if k in GEMESSEN}
+
+
+def auswertung_fahren():
+    """Faehrt `auswerten-b4.py` und legt sein Protokoll neben die Belege."""
+    umg = dict(os.environ, PYTHONIOENCODING="utf-8")
+    p = subprocess.run([sys.executable, AUSWERTEN], capture_output=True,
+                       text=True, encoding="utf-8", errors="replace", env=umg)
+    text = (p.stdout or "") + (p.stderr or "")
+    if p.returncode != 0:
+        raise SystemExit("ABBRUCH: auswerten-b5.py endete mit Exit %d:%s%s"
+                         % (p.returncode, chr(10), text[-1500:]))
+    io.open(AUSWERTUNG, "w", encoding="utf-8", newline="").write(text)
+    print("Auswertung gefahren:", AUSWERTUNG)
+    return text
+
+
+def auswertungsbloecke():
+    """Je Zelle der Block aus Abschnitt 2 der Auswertung."""
+    text = auswertung_fahren()
+    bloecke = {}
+    # Die Kennungsfamilie als FORM, nicht woertlich (D-246).
+    teile = re.split(r"\n--- ([A-Z]{2,3}-\d{3}-[PN]\d{2}) ", text)
+    for i in range(1, len(teile) - 1, 2):
+        kennung = teile[i]
+        rest = teile[i + 1]
+        ende = rest.find("\n--- ")
+        schnitt = rest if ende < 0 else rest[:ende]
+        ende2 = schnitt.find("\n====")
+        bloecke[kennung] = (schnitt if ende2 < 0 else schnitt[:ende2]).rstrip()
+    return bloecke
+
+
+def laufkennungen(kennung):
+    """sk010p01 / ksk010p01, dazu die Turns, soweit es Belege gibt."""
+    kern = kennung.lower().replace("-", "")
+    namen = []
+    for vor in ("", "k"):
+        for anhang in ("t1", ""):
+            name = vor + kern + anhang
+            if os.path.isfile(os.path.join(BELEGE, name + "-antwort.md")):
+                namen.append(name)
+    return namen
+
+
+# Die Zellen DIESER Erhebung - gefragt, nicht nachgebaut. Ein Verzeichnis ist
+# kein Zuschnitt (D-230), und ein Testblatt auch nicht: `RE-001` hat fuenfzehn
+# Zeilen, und der Zuschnitt einer Erhebung koennte weniger messen.
+def _gemessene_zellen():
+    import importlib.util
+    pfad = os.path.join(os.path.dirname(os.path.abspath(__file__)),
+                        "auswerten-b5.py")
+    spec = importlib.util.spec_from_file_location("lw_auswerten_b5", pfad)
+    modul = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(modul)
+    return {z for z, _h, _k, _kb in modul.PAARE}
+
+
+GEMESSEN = _gemessene_zellen()
+
+
+def main():
+    os.makedirs(ZIEL, exist_ok=True)
+    zeilen = blattzeilen()
+    bloecke = auswertungsbloecke()
+    fehlend = sorted(set(zeilen) - set(bloecke))
+    gebaut = 0
+    for kennung in sorted(zeilen):
+        skill, felder = zeilen[kennung]
+        teile = ["# Dossier %s (`%s`)" % (kennung, skill), ""]
+        teile.append("> ⚠️ Dieses Dossier **bewertet nicht**. Es legt die Erwartung des "
+                     "Testblatts neben den Beleg des Laufs.")
+        teile.append("")
+        teile.append("## 1. Die Zeile des Testblatts")
+        teile.append("")
+        teile.append("Quelle: `%s`" % ablage.blaetter()[
+            "-".join(kennung.split("-")[:2])]["blatt"])
+        teile.append("")
+        for name, wert in zip(SPALTEN, felder):
+            teile.append("**%s**" % name)
+            teile.append("")
+            teile.append(wert if wert else "*(leer)*")
+            teile.append("")
+        teile.append("## 2. Was gemessen wurde")
+        teile.append("")
+        teile.append("```")
+        teile.append(bloecke.get(kennung, "(kein Block in der Auswertung gefunden)"))
+        teile.append("```")
+        teile.append("")
+        teile.append("## 3. Die Antworten der Laeufe")
+        teile.append("")
+        namen = laufkennungen(kennung)
+        if not namen:
+            teile.append("🔴 **Keine Antwortdatei gefunden.**")
+        for name in namen:
+            art = "Kontrollauf" if name.startswith("k") else "Hauptlauf"
+            turn = " – zweiter Turn" if not name.endswith("t1") and (name + "t1") in namen \
+                else (" – erster Turn" if name.endswith("t1") else "")
+            teile.append("### %s `%s`%s" % (art, name, turn))
+            teile.append("")
+            teile.append(lies(os.path.join(BELEGE, name + "-antwort.md")).rstrip())
+            teile.append("")
+        io.open(os.path.join(ZIEL, kennung + ".md"), "w", encoding="utf-8",
+                newline="").write("\n".join(teile) + "\n")
+        gebaut += 1
+        print("%-12s %d Lauf/Laeufe, %6d Zeichen"
+              % (kennung, len(namen),
+                 os.path.getsize(os.path.join(ZIEL, kennung + ".md"))))
+    print()
+    print("%d Dossiers unter %s" % (gebaut, ZIEL))
+    if fehlend:
+        print("🔴 OHNE Auswertungsblock:", ", ".join(fehlend))
+    else:
+        print("🟢 Jede Zelle hat eine Blattzeile UND einen Auswertungsblock.")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())