@renoxar/koolie 1.25.0

package/.koolie/core/tests/scripts/hook-overlay-status.py

@@ -0,0 +1,120 @@
+#!/usr/bin/env python3
+"""
+Framework-Hook: SessionStart - Overlay-Status als Zusatzkontext melden.
+
+Status: entwurf. Hook-Mechanismus [DOK]; Ausgabeschema "hookSpecificOutput.additionalContext"
+laut Dokumentation [DOK]. Was die Nutzlast im einzelnen traegt, ist nicht
+dokumentiert - dieselbe benannte Grenze wie bei Zeile R5 der Faehigkeitsmatrix.
+
+Aufruf:
+
+    hook-overlay-status.py <projektverzeichnis> <regelablage>
+
+Beide Werte kommen aus der Semantikabbildung des Client Packs: das Projektverzeichnis aus
+hook_project_dir_var, die Regelablage aus runtime_placeholders["<RULES_DIR>"]. Der Kern
+nennt weder die eine Variable noch den einen Pfad - er ist werkzeugneutral (D-02, D-30).
+
+Warum als Argumente und nicht ueber die Umgebung: Der Wert steht damit in dem Kommando,
+das der Client ohnehin ausfuehrt. Ob ein Client Umgebungsvariablen an den Hook-Prozess
+weiterreicht, ist fuer kein Pack belegt - dieselbe Begruendung, aus der D-31 den Schalter
+--fail-closed ins Kommando gelegt hat.
+
+Ohne Argumente bleibt ein Notweg: das Arbeitsverzeichnis und ausschliesslich
+.koolie/project-overlay/OVERLAY.md. Der Notweg ist nicht der vorgesehene Pfad. Ob das
+Arbeitsverzeichnis beim Sitzungsstart das Projektverzeichnis ist, ist unbelegt, und ohne
+Regelablage entfaellt der zweite Kandidat - die gerenderte Overlay-Regeldatei traegt den
+Status ebenso wie das Overlay selbst.
+
+Seit 0.33.0 wertet dieser Hook **alle** lesbaren Traeger aus, nicht den ersten mit Treffer,
+und er benutzt dafuer dieselbe Funktion wie der Validator (overlay_status.py). Vorher
+hatte er drei Defekte, alle drei gemessen (B08): Er verglich als Praefix - 'aktivierung-
+ausstehend' galt damit als aktiv, genau der Wert, den D-44 im Validator ausgeschlossen hat;
+sein Suchmuster verlangte einen Doppelpunkt und traf damit die Steckbriefzeile
+'| Overlay-Status | ... |' nie; und er brach beim ersten Treffer ab, sodass eine aktive
+Laufzeitregel gegen ein inaktives Quell-Overlay gewann. Ein Widerspruch wird jetzt als
+solcher gemeldet, nicht als 'inaktiv' - die Folge ist dieselbe, der Grund nicht.
+
+Das Skript blockiert nie; es informiert.
+"""
+import json
+import os
+import sys
+
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+from overlay_status import (AKTIV, auswerten, status_angaben,  # noqa: E402
+                            version_angaben, versionen_auswerten)
+
+argumente = [a for a in sys.argv[1:] if not a.startswith("-")]
+root = argumente[0] if argumente else os.getcwd()
+regelablage = argumente[1] if len(argumente) > 1 else None
+
+candidates = []
+if regelablage:
+    # Die Laufzeitregel heisst bei cursor 20-project-overlay.mdc (CR-2026-155): Der
+    # Client laedt nur diese Endung. Das Skript kennt kein Manifest und nimmt die
+    # Datei, die in der Regelablage liegt.
+    for endung in (".md", ".mdc"):
+        kandidat = os.path.join(root, *regelablage.replace("\\", "/").split("/"),
+                                "20-project-overlay" + endung)
+        if os.path.exists(kandidat) or endung == ".md":
+            candidates.append(kandidat)
+candidates.append(os.path.join(root, ".koolie/project-overlay", "OVERLAY.md"))
+
+# Alle lesbaren Traeger, nicht der erste mit Treffer: Zwei Dateien, die verschiedene
+# Staende erklaeren, sind der Befund - nicht eine Fundstelle, die man auswaehlt.
+angaben = []
+versionen = []
+gelesen = []
+for path in candidates:
+    try:
+        with open(path, encoding="utf-8") as fh:
+            text = fh.read()
+    except OSError:
+        continue
+    gelesen.append(os.path.relpath(path, root).replace(os.sep, "/"))
+    angaben.extend(status_angaben(text))
+    versionen.extend(version_angaben(text))
+
+status, begruendung = auswerten(angaben)
+
+version = "unbekannt"
+try:
+    with open(os.path.join(root, ".koolie/core", "VERSION"), encoding="utf-8") as fh:
+        version = fh.read().strip()
+except OSError:
+    pass
+
+herkunft = ("gelesen: " + ", ".join(gelesen)) if gelesen else "keine Overlay-Datei lesbar"
+context = (
+    f"Framework-Statusmeldung: Framework-Version {version}; "
+    f"Project-Overlay-Status: {status} ({begruendung}; {herkunft}). "
+    + ("" if status == AKTIV else
+       "Da das Overlay nicht als aktiv erklaert ist, arbeite ausschliesslich im Modus M1 "
+       "Read-only Analysis und weise die Nutzerin oder den Nutzer darauf hin "
+       "(Wurzel-Anweisungsdatei, Abschnitt 3) - ausgenommen M6 mit Mandat, um das "
+       "Overlay einzurichten (Skill fw-overlay-pflege).")
+)
+
+# Seit 1.17.0 (CR-2026-156, D-452): der Versionswiderspruch und das Mandat. Beide nennen,
+# was zu tun ist - der Blockade-Hinweis gilt auch fuer eine Meldung, die nichts sperrt.
+befund_version = versionen_auswerten(versionen)
+if befund_version:
+    context += (" Overlay-Version: " + befund_version + ". Weise darauf hin und nenne den "
+                "Weg: den Wert im Steckbrief von OVERLAY.md berichtigen (M6) und danach "
+                "'python .koolie/core/mandat.py abgleichen' im eigenen Terminal.")
+try:
+    sys.path.insert(0, os.path.join(root, ".koolie", "core"))
+    import mandat  # noqa: E402
+    if os.path.normcase(mandat.PROJEKTWURZEL) == os.path.normcase(os.path.realpath(root)):
+        aktiv = mandat.gueltiges_mandat()
+        if aktiv:
+            context += (" Mandat fuer M6 aktiv: Rolle %s, Umfang %s, noch %d Minuten - du "
+                        "darfst Entscheidungen des Menschen in diesen Teil des Overlays "
+                        "eintragen." % (aktiv["rolle"], ", ".join(aktiv["umfang"]),
+                                        aktiv["_rest_min"]))
+except Exception:  # noqa: BLE001 - der Hook informiert nur und darf nie scheitern
+    pass
+
+print(json.dumps({"hookSpecificOutput": {"hookEventName": "SessionStart",
+                                         "additionalContext": context}}, ensure_ascii=False))
+sys.exit(0)

package/.koolie/core/tests/scripts/mermaid_renderer.py

@@ -0,0 +1,67 @@
+#!/usr/bin/env python3
+"""
+Gemeinsamer Aufruf des Mermaid-Renderers - fuer den Validator und die Word-Fassung.
+
+Warum dieses Modul existiert (K-145, D-398): Der Bau (`build/build-docx.py`) uebergab dem
+Renderer `mmdc` eine Puppeteer-Konfiguration mit einem gefundenen Browser, der Validator
+(`validate-framework.py --mermaid`) nicht. Auf einem Arbeitsplatz ohne den Browser, den
+Puppeteer selbst herunterlaedt, meldete der Validator deshalb JEDEN Mermaid-Block als
+ungueltig - auch unveraenderte -, waehrend der Bau im selben Arbeitsgang alle Diagramme
+renderte. Gemessen am 2026-09-25: ohne die Konfiguration "Could not find
+chrome-headless-shell", mit ihr gerendert. Beide Werkzeuge suchen den Browser jetzt hier.
+
+Das Modul hat keine Abhaengigkeit ausser der Standardbibliothek, weil der Validator auch
+in einer Installation ohne `build/` laeuft (Lieferumfang `nutzung`, D-367).
+
+WAS DIESES MODUL NICHT LEISTET: Es unterscheidet einen Fehler der Umgebung von einem Fehler
+des Diagramms nur an der Fehlerausgabe des Renderers. Eine Meldung, die es nicht kennt,
+gilt als Fehler des Diagramms - die strengere Lesart.
+"""
+from __future__ import annotations
+
+import json
+import os
+import re
+
+# Meldungen, mit denen der Renderer sagt, dass ihm der Browser fehlt oder nicht startet.
+# Sie betreffen den Arbeitsplatz, nicht das Diagramm.
+UMGEBUNGSFEHLER_RE = re.compile(
+    r"Could not find (?:Chrome|Chromium|chrome-headless-shell|expected browser)"
+    r"|Failed to launch the browser process"
+    r"|Browser was not found",
+    re.I)
+
+
+def browserpfad() -> str | None:
+    """Ein Chromium-artiger Browser fuer den Mermaid-Renderer - oder None.
+
+    Zuerst die ausdrueckliche Angabe der Umgebung, dann die ueblichen Ablageorte. Auf
+    einem Windows-Arbeitsplatz ist Edge immer vorhanden; einen eigenen Chromium
+    herunterzuladen ist damit unnoetig.
+    """
+    gesetzt = os.environ.get("PUPPETEER_EXECUTABLE_PATH")
+    if gesetzt and os.path.exists(gesetzt):
+        return gesetzt
+    kandidaten = [
+        r"C:\Program Files (x86)\Microsoft\Edge\Application\msedge.exe",
+        r"C:\Program Files\Microsoft\Edge\Application\msedge.exe",
+        r"C:\Program Files\Google\Chrome\Application\chrome.exe",
+        "/usr/bin/chromium", "/usr/bin/chromium-browser", "/usr/bin/google-chrome",
+    ]
+    for pfad in kandidaten:
+        if os.path.exists(pfad):
+            return pfad
+    return None
+
+
+def puppeteer_konfiguration(pfad: str, browser: str) -> str:
+    """Schreibt die Konfiguration, die `mmdc -p` liest, und gibt ihren Pfad zurueck."""
+    with open(pfad, "w", encoding="utf-8") as fh:
+        json.dump({"executablePath": browser,
+                   "args": ["--no-sandbox", "--disable-gpu"]}, fh)
+    return pfad
+
+
+def ist_umgebungsfehler(fehlerausgabe: str) -> bool:
+    """True, wenn der Renderer an der Umgebung gescheitert ist und nicht am Diagramm."""
+    return bool(UMGEBUNGSFEHLER_RE.search(fehlerausgabe or ""))

package/.koolie/core/tests/scripts/overlay_status.py

@@ -0,0 +1,130 @@
+#!/usr/bin/env python3
+"""
+Gemeinsame Auswertung des Overlay-Status - fuer Validator und Status-Hook.
+
+Status: entwurf.
+
+Warum dieses Modul existiert: Der Status stand in zwei Werkzeugen und wurde zweimal
+verschieden ausgewertet. Der Validator vergleicht seit 0.28.0 **exakt** auf 'aktiv', weil
+ein Praefixvergleich den Wert 'aktivierung-ausstehend' als Aktivierung durchliess (B02,
+D-44) - ein Wert, der woertlich sagt, dass die Aktivierung aussteht. Der Hook prueft
+weiterhin als Praefix, kennt die Steckbriefzeile nicht und nimmt die erste Datei mit
+Treffer. Die Lehre war gezogen, aber nur in einer der beiden Funktionen; dasselbe Muster
+wie bei D-49.
+
+Der Hook importiert dieses Modul, **nicht** den Validator: Ein Hook, der bei jedem
+Sitzungsstart ein 2300-Zeilen-Skript laedt, waere ein Leistungs- und ein Fehlerrisiko, und
+er wuerde dessen Abhaengigkeiten mitschleppen. Dieses Modul hat keine Abhaengigkeit ausser
+'re'.
+
+WAS DIESES MODUL NICHT LEISTET: Es liest Erklaerungen, es prueft keine Wirkung. Dass ein
+Overlay 'aktiv' erklaert, heisst nicht, dass der Client seine Regeln laedt - das ist
+Gegenstand der Fachmatrix des jeweiligen Client Packs, nicht einer Textauswertung.
+"""
+from __future__ import annotations
+
+import re
+
+# Die beiden Schreibweisen, in denen eine Overlay-Datei ihren Status *erklaert*: als Zeile
+# im Steckbrief (Tabelle) und als Aussage im Aktivierungsabschnitt (Liste). Beide nur am
+# Zeilenanfang - eine Erwaehnung im Fliesstext oder in einem Ausnahmeregister ist keine
+# Erklaerung. Der Hook suchte bisher ohne Anker und ohne die Tabellenform; damit traf er
+# die Steckbriefzeile nie, weil dort kein Doppelpunkt steht.
+_TABELLE_RE = re.compile(r"^\|\s*Overlay-Status\s*\|\s*`?([^`|]+)", re.M)
+_LISTE_RE = re.compile(r"^-?\s*Overlay-Status:\s*`?([^`\n]+)", re.M)
+# Die Version, in denselben zwei Formen wie der Validator sie liest (Pruefung 13). Seit
+# 1.17.0 meldet der SessionStart-Hook einen Widerspruch sofort (CR-2026-156, D-452):
+# Im ersten Projekteinsatz stand an der Stelle der Version eine Zeile des
+# Aenderungsverlaufs, und die Statusmeldung der Sitzung sagte "aktiv" - der Schaden blieb
+# unsichtbar, bis jemand den Validator startete (Befund A3).
+_VERSION_TABELLE_RE = re.compile(r"^\|\s*Overlay-Version\s*\|\s*`?([^`|]+)", re.M)
+_VERSION_LISTE_RE = re.compile(r"^-?\s*Overlay-Version:\s*`?([^`\n·]+)", re.M)
+_SEMVER_RE = re.compile(r"^\d+\.\d+\.\d+$")
+
+# Zulaessige Statuswerte. Alles andere ist 'unbekannt' - auch ein nicht ausgefuellter
+# Platzhalter, und das ist der haeufigste Fall in einer frischen Installation.
+AKTIV = "aktiv"
+INAKTIV = "inaktiv"
+UNBEKANNT = "unbekannt"
+# ASCII-Umschrift wie im uebrigen Skripttext: Der Wert erscheint in der Hook-Meldung, und
+# die Nachbarsaetze dort sind ebenso geschrieben.
+WIDERSPRUECHLICH = "widerspruechlich"
+
+
+def status_angaben(text: str) -> list[str]:
+    """Alle Stellen, an denen ein Text den Overlay-Status erklaert - in Lesereihenfolge."""
+    werte = []
+    for regex in (_TABELLE_RE, _LISTE_RE):
+        for m in regex.finditer(text):
+            werte.append(m.group(1).strip())
+    return werte
+
+
+def version_angaben(text: str) -> list[str]:
+    """Alle Stellen, an denen ein Text die Overlay-Version erklaert."""
+    werte = []
+    for regex in (_VERSION_TABELLE_RE, _VERSION_LISTE_RE):
+        for m in regex.finditer(text):
+            werte.append(m.group(1).strip())
+    return werte
+
+
+def versionen_auswerten(angaben: list[str]) -> str:
+    """Leerer Text, wenn die Versionsangaben uebereinstimmen - sonst der Befund.
+
+    Ein offener Platzhalter (<TBD: ...>) ist kein Befund: Er ist der Stand vor dem
+    Ausfuellen und Sache der Aktivierungspruefung.
+    """
+    werte = [a for a in angaben if not a.startswith("<")]
+    if not werte:
+        return ""
+    ungueltig = [w for w in werte if not _SEMVER_RE.match(w)]
+    if ungueltig:
+        return "keine Version der Form x.y.z: '%s'" % ungueltig[0][:60]
+    if len(set(werte)) > 1:
+        return "die Versionsangaben widersprechen sich: " + ", ".join(sorted(set(werte)))
+    return ""
+
+
+def normalisieren(wert: str) -> str:
+    """Ein einzelner erklaerter Wert, auf einen der vier Statuswerte abgebildet.
+
+    Exakter Vergleich, kein Praefix: 'aktivierung-ausstehend' ist keine Aktivierung
+    (D-44). Auszeichnungen und Anfuehrungszeichen fallen weg, der Wortlaut nicht.
+    """
+    w = wert.strip().strip("`*_ ").strip().lower()
+    if w == AKTIV:
+        return AKTIV
+    if w == INAKTIV:
+        return INAKTIV
+    return UNBEKANNT
+
+
+def auswerten(angaben: list[str]) -> tuple[str, str]:
+    """Gesamtstatus aus allen Erklaerungen. Rueckgabe: (status, begruendung).
+
+    Regeln, und jede hat einen Befund hinter sich:
+
+    * **Keine Erklaerung** -> 'unbekannt'. Eine fehlende Angabe ist keine Inaktivitaet;
+      sie ist eine unvollstaendige Konfiguration, und der Unterschied gehoert in die
+      Meldung.
+    * **Widerspruch** -> 'widersprüchlich', nicht 'inaktiv' und nicht 'unbekannt'. Beide
+      wuerden verschweigen, dass eine Erklaerung da ist und nicht stimmt; wer die Meldung
+      liest, suchte dann einen fehlenden Eintrag und faende einen widerspruechlichen
+      (B08). Die Folge ist dieselbe wie bei 'inaktiv' - nur lesend -, der Grund nicht.
+    * **Ein unbekannter Wert neben einem bekannten** ist ebenfalls ein Widerspruch: Eine
+      Datei mit ausgefuelltem Status und eine mit offenem Platzhalter erklaeren nicht
+      dasselbe.
+    """
+    if not angaben:
+        return UNBEKANNT, "keine Angabe zum Overlay-Status gefunden"
+    werte = [normalisieren(a) for a in angaben]
+    eindeutig = set(werte)
+    if len(eindeutig) > 1:
+        return (WIDERSPRUECHLICH,
+                "die Statusangaben widersprechen sich: "
+                + ", ".join("'%s'" % a.strip() for a in angaben))
+    status = werte[0]
+    if status == UNBEKANNT:
+        return UNBEKANNT, "Statuswert nicht ausgefuellt oder unbekannt: '%s'" % angaben[0].strip()
+    return status, "%d Angabe(n), alle '%s'" % (len(angaben), status)

package/.koolie/core/tests/scripts/probe-pruefungen.py

@@ -0,0 +1,110 @@
+#!/usr/bin/env python3
+"""Wirkungsnachweis nach D-23 fuer die Pruefungen 4, 6, 8, 14, 18 bis 66 und 68 bis 112, dazu fuer
+install.py (Clientwahl, Aktivierungspruefung, --list-skills, Schutz vorhandener
+Projektdateien bei der Erstinstallation, Auskunft ueber ignorierte Kerndateien,
+Overlay-Muster) und fuer den Praeparationswaechter dieses
+Skripts selbst.
+
+Die Aufzaehlung der Pruefungen steht hier in der Schreibweise, die Pruefung 40 aus den
+Sondenkennungen dieses Skripts ausrechnet und woertlich vergleicht (D-86). Bis 0.41.0
+stand an dieser Stelle eine Release-Chronik, die bei 0.29.0 endete: ein Register, das
+mit jedem Release falscher wurde, ohne dass ein Lauf davon Notiz nahm. Welches Release
+welche Sonde gebracht hat, steht im Aenderungsverlauf und nicht mehr hier.
+
+Aufruf (im Wurzelverzeichnis des Repositoriums):
+    python3 .koolie/core/tests/scripts/probe-pruefungen.py [PFAD] [--bahnen N]
+
+D-23 sagt: Eine Pruefung gilt erst als vorhanden, wenn sie eine bewusst gesetzte Sonde
+meldet. Dieses Skript fuehrt den Nachweis, statt ihn zu behaupten. Je Pruefung
+
+  * eine **Sonde**: ein bekannter Defekt in einer Kopie des Repositoriums - die Pruefung
+    MUSS ihn melden;
+  * eine **Gegenprobe**: ein Fall, der erlaubt ist und aehnlich aussieht - die Pruefung
+    DARF ihn nicht melden.
+
+Die kleinste Einheit ist die Sonde, die Gegenprobe oder - wo mehrere Faelle aufeinander
+aufbauen - das **Buendel**, nie einer seiner Teile. Jede Einheit traegt einen **Namen**
+und einen **Beschreibungssatz von 5 bis 30 Worten**; die Selbstprobe B1 zaehlt ihn nach.
+Die Einheiten laufen seit 0.46.0 **nebenlaeufig** auf mehreren Bahnen - jede auf ihrer
+eigenen Kopie, innerhalb eines Buendels weiterhin streng seriell (`--bahnen 1` faehrt
+den seriellen Lauf von frueher). Ihre **Laufzeit** steht am Ende, langsamste zuerst, und
+zwar unterhalb einer Trennlinie: Die Ergebniszeilen daruber sind die zeilengleiche
+Abnahmeform nach D-49, und eine Laufzeit ist nie zweimal dieselbe (CR-2026-068).
+
+Die Gegenprobe ist der Teil, den man weglassen kann und nicht weglassen sollte: Eine
+Pruefung, die alles meldet, besteht jede Sonde. Die Gegenproben hier treffen genau die
+Faelle, an denen die jeweilige Pruefung zu breit haette werden koennen - die erklaerende
+Nennung eines Dateinamens im Fliesstext, ein Begriff ohne Manifestfeld, die Schutzmuster
+des durchsetzenden Hooks, ein Pack ohne Importsteuerung, Herkunftsangaben im Kommentar.
+
+Gearbeitet wird auf einer Kopie; das Repositorium selbst bleibt unberuehrt. Exit-Code 0 =
+alle Sonden gemeldet, keine Gegenprobe beanstandet **und jede Kopie wieder geloescht** -
+eine liegengebliebene meldet der Aufraeumer und zaehlt als Abweichung (D-96).
+
+Was dieses Skript **nicht** leistet: Es belegt, dass die Pruefungen wirken, nicht dass
+ihre Gegenstaende richtig sind. Die Grenze jeder einzelnen Pruefung steht in deren
+Kopfkommentar in validate-framework.py.
+"""
+import os
+import sys
+import time
+
+# Der Apparat und die Einheiten liegen seit 1.19.1 im Paket sonden/ neben diesem Skript
+# (K-174). Jeder Teil meldet seine Einheiten beim Laden an; geladen wird in der
+# Reihenfolge der Nummer, und das ist die Reihenfolge der Ausgabe (D-49).
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+from sonden.apparat import (  # noqa: E402
+    auswertung, BAHNEN, EINHEITEN, fahren, LISTE, NUR, waehle)
+from sonden import (  # noqa: E402,F401 - laden heisst anmelden
+    teil01_grundbestand_und_installation,
+    teil02_packs_mandat_mcp,
+    teil03_pruefungen_26_bis_36,
+    teil04_pruefungen_37_bis_45,
+    teil05_pruefungen_46_bis_55,
+    teil06_pruefungen_57_bis_65,
+    teil07_overlay_und_lieferung,
+    teil08_pruefungen_66_bis_80,
+    teil09_pruefmittel_81_und_82,
+    teil10_pruefungen_83_bis_95,
+    teil11_pruefungen_104_und_105,
+    teil12_pruefungen_106_und_107,
+    teil13_pfad_und_mustersemantik,
+    teil14_modi_ausnahmen_skills,
+    teil15_banner_und_nachlauf,
+    teil16_koexistenz,
+    teil17_paketquellen,
+    teil18_modusbindung_m3_m5)
+
+
+if LISTE:
+    for e in EINHEITEN:
+        print("%-11s %-6s %s" % (e.art, e.kennung, e.satz))
+    print("---")
+    print("%d Einheiten. Auswahl mit --nur <Kennung>[,<Kennung>...]" % len(EINHEITEN))
+    sys.exit(0)
+_GEWAEHLT = waehle(EINHEITEN, NUR)
+_TEILLAUF = len(_GEWAEHLT) != len(EINHEITEN)
+if _TEILLAUF:
+    print("=" * 78)
+    print("TEILLAUF: %d von %d Einheiten (--nur %s)"
+          % (len(_GEWAEHLT), len(EINHEITEN), ",".join(NUR)))
+    print("Das ist KEIN Abnahmelauf. Vor dem Merge laeuft der volle Apparat, und zwar")
+    print("in beiden Kodierungsumgebungen (D-23, D-49, D-191).")
+    print("=" * 78)
+    print()
+_beginn = time.perf_counter()
+fehler = fahren(_GEWAEHLT, BAHNEN)
+_wanduhr = time.perf_counter() - _beginn
+print()
+if _TEILLAUF:
+    print("Ergebnis (TEILLAUF, %d von %d Einheiten): %s"
+          % (len(_GEWAEHLT), len(EINHEITEN),
+             "alle gewaehlten Einheiten bestanden" if not fehler
+             else "%d Abweichung(en)" % fehler))
+else:
+    print("Ergebnis:", "alle Sonden und Gegenproben bestanden" if not fehler
+          else f"{fehler} Abweichung(en)")
+auswertung(_GEWAEHLT, _wanduhr, BAHNEN)
+if _TEILLAUF:
+    print("TEILLAUF - der Nachweis nach D-23 steht erst nach dem vollen Lauf.")
+sys.exit(1 if fehler else 0)

package/.koolie/core/tests/scripts/pruefungen/__init__.py

@@ -0,0 +1,4 @@
+"""Die Pruefungen des Validators validate-framework.py, nach Gegenstand geteilt (1.19.1, K-174).
+
+Der Einstieg ist validate-framework.py; dieses Paket hat keinen eigenen Aufruf.
+"""