@renoxar/koolie 1.25.0

package/.koolie/core/tests/erhebungen/apparat/laeufer.py

@@ -0,0 +1,155 @@
+# -*- coding: utf-8 -*-
+"""Der generische Laeufer: aufbauen, vorpruefen, fahren, auswerten, aufraeumen.
+
+Ein Lauf faehrt genau dann, wenn (1) er noch nicht im Kontingentbuch steht, (2) der Baum
+auf seinen Sollstand gebracht ist und (3) die Vorpruefung leer ist. Sonst bricht die
+REIHE ab - nicht nur der Lauf: Ein Befund der Vorpruefung ist fast immer ein Befund am
+Aufbau, und der naechste Lauf traege ihn mit.
+"""
+from __future__ import annotations
+
+import io
+import json
+import os
+import time
+
+from . import baum as baum_mod
+from . import belege as belege_mod
+from . import kontingent
+from . import vorpruefung
+from .clients import ADAPTER, adapter as adapter_fuer
+from .reihe import laden as reihe_laden
+
+BEKANNT = tuple(ADAPTER)
+
+
+def _soll_ordner(reihe) -> str:
+    return os.path.join(reihe.belege, "soll")
+
+
+def _soll_schreiben(reihe, schluessel: str, soll: dict) -> None:
+    os.makedirs(_soll_ordner(reihe), exist_ok=True)
+    io.open(os.path.join(_soll_ordner(reihe), schluessel + ".json"), "w",
+            encoding="utf-8").write(json.dumps(soll, indent=1))
+
+
+def _soll_lesen(reihe, schluessel: str) -> dict:
+    pfad = os.path.join(_soll_ordner(reihe), schluessel + ".json")
+    if not os.path.isfile(pfad):
+        raise RuntimeError(f"kein Sollstand '{schluessel}' - erst 'aufbau'")
+    return json.loads(io.open(pfad, encoding="utf-8").read())
+
+
+def aufbau(reihe) -> list:
+    """Sollstaende festhalten und Vertrauen setzen. Baut keine Basis - die sagt die Reihe."""
+    belege_mod.ablage_pruefen(reihe.belege)
+    a = adapter_fuer(reihe.client)
+    ohne = reihe.baum.get("ohne") or []
+    baeume = []
+    if reihe.baum["modus"] == "vorhanden":
+        for lauf in reihe.laeufe:
+            if not os.path.isdir(lauf.baum_vorhanden):
+                raise RuntimeError(f"{lauf.kennung}: Baum {lauf.baum_vorhanden} fehlt")
+            _soll_schreiben(reihe, lauf.kennung, baum_mod.sollstand(lauf.baum_vorhanden, ohne))
+            baeume.append(lauf.baum_vorhanden)
+    else:
+        basis = reihe.baum["basis"]
+        _soll_schreiben(reihe, "basis", baum_mod.sollstand(basis, ohne))
+        baeume = sorted({reihe.baumpfad(x) for x in reihe.laeufe})
+    if reihe.vorpruefung.get("vertrauen"):
+        a.vertrauen(baeume, True)
+    return baeume
+
+
+def _herrichten(reihe, lauf) -> tuple:
+    """(Baumpfad, Sollstand fuer die Vorpruefung) - der Baum steht danach auf dem Soll."""
+    ohne = reihe.baum.get("ohne") or []
+    if reihe.baum["modus"] == "vorhanden":
+        soll = _soll_lesen(reihe, lauf.kennung)
+        return lauf.baum_vorhanden, soll
+    soll = _soll_lesen(reihe, "basis")
+    pfad = reihe.baumpfad(lauf)
+    baum_mod.herrichten(reihe.baum["basis"], pfad, lauf.ziel_branch(reihe), soll,
+                        reihe.baum.get("remote"), ohne, reihe.baum.get("verbindungen"),
+                        reihe.baum.get("remote_hooks") or "")
+    return pfad, soll
+
+
+def vorpruefen(reihe, kennungen=None) -> dict:
+    """Die Vorpruefung fuer jeden Lauf, ohne zu fahren - eine Probe des ganzen Aufbaus."""
+    a = adapter_fuer(reihe.client)
+    aus = {}
+    for lauf in reihe.laeufe:
+        if kennungen and lauf.kennung not in kennungen:
+            continue
+        if kontingent.gefahren(reihe.belege, lauf.kennung):
+            aus[lauf.kennung] = ["(schon gefahren)"]
+            continue
+        pfad, soll = _herrichten(reihe, lauf)
+        aus[lauf.kennung] = vorpruefung.pruefen(reihe, lauf, a, soll, pfad)
+    return aus
+
+
+def fahren(reihe, kennungen=None, ausgabe=print) -> int:
+    a = adapter_fuer(reihe.client)
+    version = a.version()
+    gefahren = 0
+    for lauf in reihe.laeufe:
+        if kennungen and lauf.kennung not in kennungen:
+            continue
+        if kontingent.gefahren(reihe.belege, lauf.kennung):
+            ausgabe(f"{lauf.kennung}: schon gefahren")
+            continue
+        pfad, soll = _herrichten(reihe, lauf)
+        befunde = vorpruefung.pruefen(reihe, lauf, a, soll, pfad)
+        if befunde:
+            raise SystemExit(f"ABBRUCH vor {lauf.kennung} - Vorpruefung:\n  - " + "\n  - ".join(befunde))
+        hash_vorher = baum_mod.baumhash(pfad, reihe.baum.get("ohne") or [])
+        meta = {"reihe": reihe.name, "client": reihe.client, "clientversion": version,
+                "gruppe": lauf.gruppe, "variante": lauf.variante, "baum": pfad,
+                "branch": lauf.ziel_branch(reihe), "hash_vorher": hash_vorher,
+                "berechtigung": reihe.berechtigung, "einstellungen": reihe.einstellungen or None,
+                "zusatz": reihe.zusatz or None,
+                "unterverzeichnis": lauf.unterverzeichnis or None,
+                "zeit": time.strftime("%Y-%m-%dT%H:%M:%S")}
+        start = os.path.join(pfad, *lauf.unterverzeichnis.split("/")) if lauf.unterverzeichnis else pfad
+        if not os.path.isdir(start):
+            raise SystemExit(f"ABBRUCH vor {lauf.kennung}: Startverzeichnis {start} fehlt im Baum")
+        turns = [lauf.prompt] + lauf.folgeturns
+        sitzung = None
+        summe = {"usd": 0.0, "cache_neu": 0, "cache_gelesen": 0, "abweisungen": 0, "turns": 0}
+        for i, prompt in enumerate(turns):
+            erg = a.lauf(prompt, start, lauf.modell, reihe.berechtigung, sitzung,
+                         einstellungen=reihe.einstellungen or None, zusatz=reihe.zusatz or None)
+            belege_mod.sichern(reihe.belege, lauf.kennung, i, erg, dict(meta, turn=i + 1), a)
+            summe["usd"] += erg["usd"]
+            for k in ("cache_neu", "cache_gelesen", "abweisungen", "turns"):
+                summe[k] += int(erg.get(k) or 0)
+            sitzung = erg.get("sitzung") or sitzung
+            if erg.get("is_error"):
+                ausgabe(f"{lauf.kennung}: Turn {i + 1} meldet is_error - Folgeturns entfallen")
+                break
+        kontingent.eintragen(reihe.belege, lauf.kennung,
+                             dict(meta, modell=erg.get("modell"), kosten=erg.get("kosten", "gemessen"),
+                                  **{k: round(v, 4) if k == "usd" else v for k, v in summe.items()}))
+        gefahren += 1
+        ausgabe("%-24s %.3f USD  Abweisungen=%s  Cache neu/gelesen=%s/%s  erwartet: %s" % (
+            lauf.kennung, summe["usd"], summe["abweisungen"], summe["cache_neu"],
+            summe["cache_gelesen"], lauf.erwartung))
+    n, usd = kontingent.summe(reihe.belege)
+    ausgabe(f"Summe: {n} Laeufe, {usd:.2f} USD")
+    return gefahren
+
+
+def aufraeumen(reihe) -> None:
+    """Vertrauen entfernen; die Baeume bleiben stehen (Loeschen sagt der Mensch, D-262)."""
+    a = adapter_fuer(reihe.client)
+    if reihe.baum["modus"] == "vorhanden":
+        baeume = [x.baum_vorhanden for x in reihe.laeufe]
+    else:
+        baeume = sorted({reihe.baumpfad(x) for x in reihe.laeufe})
+    a.vertrauen(baeume, False)
+
+
+def laden(pfad: str):
+    return reihe_laden(pfad, BEKANNT)

package/.koolie/core/tests/erhebungen/apparat/reihe.py

@@ -0,0 +1,202 @@
+# -*- coding: utf-8 -*-
+"""Eine Reihe als Daten - und ihre Pruefung, bevor irgendetwas gebaut oder gefahren wird.
+
+Die Reihe liegt als JSON in der Erhebungsablage, nicht im Repositorium: Prompts und
+Erwartungen sind Aufzeichnung (D-222). Eine Reihe mit einem Fehler im Schema bricht beim
+Laden ab - sie haette sonst die ersten Laeufe bezahlt und am fuenften gemerkt, dass eine
+Kennung doppelt ist.
+
+Form (Pflicht ist, was ohne Standard steht):
+
+  {
+    "name": "1190-gleich",
+    "client": "claude-code",
+    "wurzel": "Verzeichnis der Messbaeume",
+    "kontingent": {"laeufe": 12, "usd": 8.0, "reserve_usd": 0.8},
+    "baum": {"modus": "fest" | "je_lauf" | "vorhanden",
+             "basis": "Pfad eines hergerichteten git-Baums (fest, je_lauf)",
+             "branch": "main", "remote": false, "ohne": ["node_modules"],
+             "verbindungen": {"frontend/node_modules": "geteilter Bestand"},
+             "remote_hooks": "Verzeichnis mit Hooks fuer das Wegwerf-Remote"},
+    "berechtigung": "bypassPermissions",
+    "einstellungen": "Einstellungsdatei AUSSERHALB der Baeume (claude-code: --settings)",
+    "zusatz": ["--mcp-config", "...", "--permission-prompt-tool", "..."],
+    "vorpruefung": {"hook": true, "vertrauen": true, "startmeldung": []},
+    "laeufe": [{"kennung": "...", "prompt": "..." | "prompt_datei": "...",
+                "folgeturns": ["..."], "erwartung": "...",
+                "gruppe": "koolie" | "referenz", "modell": null,
+                "branch": null, "variante": null, "baum": "nur bei modus vorhanden",
+                "unterverzeichnis": "Startverzeichnis relativ zum Baum, sonst die Wurzel"}]
+  }
+
+SEIT 1.21.0 (CR-2026-167) traegt die Reihe die Referenzgruppe der Vergleichsmessung (K-193):
+Einstellungen, die der Agent nicht aendern kann, liegen ausserhalb jedes Baums; Branch-Schutz
+und CI stehen als Hooks im Wegwerf-Remote; ein Lauf kann in einem Unterverzeichnis starten.
+'zusatz' reicht Argumente an den Client durch - etwa den Freigabe-Stellvertreter (freigabe.py),
+der im Druckmodus jede Rueckfrage beantwortet und protokolliert.
+"""
+from __future__ import annotations
+
+import io
+import json
+import os
+import re
+
+MODI = ("fest", "je_lauf", "vorhanden")
+GRUPPEN = ("koolie", "referenz")
+KENNUNG_RE = re.compile(r"^[a-z0-9][a-z0-9-]{0,40}$")
+
+
+class Reihenfehler(Exception):
+    """Die Reihe ist nicht fahrbar - gemeldet vor dem ersten Lauf."""
+
+
+class Lauf:
+    def __init__(self, d: dict, reihe: "Reihe") -> None:
+        self.kennung = d.get("kennung", "")
+        self.erwartung = d.get("erwartung", "")
+        self.gruppe = d.get("gruppe", "koolie")
+        self.modell = d.get("modell") or reihe.modell
+        self.branch = d.get("branch")
+        self.variante = d.get("variante")
+        self.unterverzeichnis = (d.get("unterverzeichnis") or "").replace("\\", "/").strip("/")
+        self.baum_vorhanden = d.get("baum")
+        self.folgeturns = list(d.get("folgeturns") or [])
+        if "prompt_datei" in d:
+            pfad = d["prompt_datei"]
+            if not os.path.isabs(pfad):
+                pfad = os.path.join(reihe.ablage, pfad)
+            self.prompt = io.open(pfad, encoding="utf-8").read() if os.path.isfile(pfad) else ""
+            self.prompt_quelle = pfad
+        else:
+            self.prompt = d.get("prompt", "")
+            self.prompt_quelle = "reihe"
+
+    def ziel_branch(self, reihe: "Reihe") -> str:
+        return self.branch or reihe.baum.get("branch", "main")
+
+
+class Reihe:
+    def __init__(self, d: dict, ablage: str) -> None:
+        self.roh = d
+        self.ablage = ablage
+        self.name = d.get("name", "")
+        self.client = d.get("client", "")
+        self.wurzel = d.get("wurzel", "")
+        self.modell = d.get("modell")
+        k = d.get("kontingent") or {}
+        self.max_laeufe = int(k.get("laeufe", 0))
+        self.max_usd = float(k.get("usd", 0))
+        self.reserve_usd = float(k.get("reserve_usd", 0.8))
+        self.baum = dict(d.get("baum") or {})
+        self.baum.setdefault("branch", "main")
+        self.baum.setdefault("remote", False)
+        self.baum.setdefault("ohne", ["node_modules"])
+        self.baum.setdefault("verbindungen", {})
+        self.baum.setdefault("remote_hooks", "")
+        self.berechtigung = d.get("berechtigung", "default")
+        self.einstellungen = d.get("einstellungen") or ""
+        self.zusatz = [str(x) for x in d.get("zusatz") or []]
+        if self.einstellungen and not os.path.isabs(self.einstellungen):
+            self.einstellungen = os.path.join(ablage, self.einstellungen)
+        v = dict(d.get("vorpruefung") or {})
+        v.setdefault("hook", True)
+        v.setdefault("vertrauen", True)
+        v.setdefault("startmeldung", [])
+        self.vorpruefung = v
+        self.laeufe = [Lauf(x, self) for x in d.get("laeufe") or []]
+
+    @property
+    def belege(self) -> str:
+        return os.path.join(self.ablage, "belege", self.name)
+
+    def lauf(self, kennung: str) -> Lauf:
+        for x in self.laeufe:
+            if x.kennung == kennung:
+                return x
+        raise Reihenfehler(f"keine Kennung '{kennung}' in der Reihe '{self.name}'")
+
+    def baumpfad(self, lauf: Lauf) -> str:
+        """Fester Pfad je Reihe (ein Prompt-Anfang, ein Cache) oder ein Baum je Lauf."""
+        modus = self.baum.get("modus")
+        if modus == "vorhanden":
+            return lauf.baum_vorhanden
+        if modus == "fest":
+            return os.path.join(self.wurzel, self.name)
+        return os.path.join(self.wurzel, self.name + "-" + lauf.kennung)
+
+
+def _unter(pfad: str, wurzel: str) -> bool:
+    p = os.path.normcase(os.path.abspath(pfad))
+    w = os.path.normcase(os.path.abspath(wurzel)).rstrip("\\/") + os.sep
+    return p.startswith(w)
+
+
+def pruefen(r: Reihe, clients_bekannt) -> list:
+    """Alle Schemafehler auf einmal - nicht den ersten."""
+    f = []
+    if not KENNUNG_RE.match(r.name or ""):
+        f.append(f"name '{r.name}': Kleinbuchstaben, Ziffern, Bindestrich")
+    if r.client not in clients_bekannt:
+        f.append(f"client '{r.client}' hat keinen Adapter (bekannt: {', '.join(sorted(clients_bekannt))})")
+    if r.max_laeufe <= 0 or r.max_usd <= 0:
+        f.append("kontingent: laeufe und usd muessen gesagt sein - ein Apparat ohne Deckel zaehlt nur")
+    modus = r.baum.get("modus")
+    if modus not in MODI:
+        f.append(f"baum.modus '{modus}' - erlaubt: {', '.join(MODI)}")
+    if modus in ("fest", "je_lauf"):
+        if not r.wurzel:
+            f.append("wurzel fehlt")
+        if not r.baum.get("basis"):
+            f.append("baum.basis fehlt")
+    if r.einstellungen:
+        if not os.path.isfile(r.einstellungen):
+            f.append(f"einstellungen '{r.einstellungen}' fehlt")
+        elif r.wurzel and _unter(r.einstellungen, r.wurzel):
+            f.append("einstellungen liegen unter der wurzel - im Messbaum erreichbar, keine "
+                     "Referenz (1.21.0)")
+    for rel, quelle in (r.baum.get("verbindungen") or {}).items():
+        teile = rel.replace("\\", "/").split("/")
+        if os.path.isabs(rel) or ".." in teile:
+            f.append(f"verbindungen: '{rel}' muss relativ im Baum liegen")
+        if not os.path.isdir(quelle):
+            f.append(f"verbindungen: Quelle '{quelle}' fehlt")
+    if r.baum.get("remote_hooks"):
+        if not r.baum.get("remote"):
+            f.append("remote_hooks ohne remote")
+        elif not os.path.isdir(r.baum["remote_hooks"]):
+            f.append(f"remote_hooks '{r.baum['remote_hooks']}' fehlt")
+    gesehen = set()
+    for x in r.laeufe:
+        if not KENNUNG_RE.match(x.kennung or ""):
+            f.append(f"Kennung '{x.kennung}': Kleinbuchstaben, Ziffern, Bindestrich")
+        if x.kennung in gesehen:
+            f.append(f"Kennung '{x.kennung}' doppelt")
+        gesehen.add(x.kennung)
+        if not x.prompt.strip():
+            f.append(f"{x.kennung}: Prompt leer ({x.prompt_quelle})")
+        if any(not t.strip() for t in x.folgeturns):
+            f.append(f"{x.kennung}: ein Folgeturn ist leer - Abbruch statt Rueckfall (1.14.2)")
+        if not x.erwartung.strip():
+            f.append(f"{x.kennung}: keine Erwartung - ein Lauf ohne Erwartung misst nichts")
+        if x.gruppe not in GRUPPEN:
+            f.append(f"{x.kennung}: gruppe '{x.gruppe}' - erlaubt: {', '.join(GRUPPEN)}")
+        if x.unterverzeichnis and (os.path.isabs(x.unterverzeichnis) or ":" in x.unterverzeichnis
+                                   or ".." in x.unterverzeichnis.split("/")):
+            f.append(f"{x.kennung}: unterverzeichnis '{x.unterverzeichnis}' muss im Baum liegen")
+        if modus == "vorhanden" and not x.baum_vorhanden:
+            f.append(f"{x.kennung}: bei modus 'vorhanden' braucht jeder Lauf 'baum'")
+        if modus == "fest" and x.branch and not x.branch.startswith("arbeit/"):
+            f.append(f"{x.kennung}: ein eigener Branch heisst 'arbeit/...' (K-172)")
+    if not r.laeufe:
+        f.append("keine Laeufe")
+    return f
+
+
+def laden(pfad: str, clients_bekannt) -> Reihe:
+    d = json.loads(io.open(pfad, encoding="utf-8").read())
+    r = Reihe(d, os.path.dirname(os.path.abspath(pfad)))
+    fehler = pruefen(r, clients_bekannt)
+    if fehler:
+        raise Reihenfehler("Reihe nicht fahrbar:\n  - " + "\n  - ".join(fehler))
+    return r

package/.koolie/core/tests/erhebungen/apparat/selbsttest.py

@@ -0,0 +1,280 @@
+# -*- coding: utf-8 -*-
+"""Der Apparat gegen einen Attrappen-Client - ohne Modell, ohne Kontingent (K-174, Frage b).
+
+Bis 1.18.2 hatte kein Messskript einen Test (D-436). Jeder Fall hier hat einen Anlass,
+der schon einmal Geld oder einen Befund gekostet hat; der Fall misst, dass der Apparat
+ihn heute abfaengt. Ein Fall, der nicht faellt, wenn sein Gegenstand fehlt, waere keiner:
+Die Gegenfaelle (T4, T5, T6) praeparieren genau den Fehler und verlangen die Meldung.
+
+Aufruf: python messen.py selbsttest   (Exit 0 = alle Faelle tragen)
+"""
+from __future__ import annotations
+
+import io
+import json
+import os
+import subprocess
+import tempfile
+
+from . import baum as baum_mod
+from . import belege as belege_mod
+from . import kontingent, laeufer, stand, vorpruefung
+from .clients import AdapterUnerhoben, Unerhoben, adapter
+from .reihe import Reihe, Reihenfehler, pruefen as reihe_pruefen
+
+FAELLE = []
+
+
+def fall(nummer, was):
+    def deko(f):
+        FAELLE.append((nummer, was, f))
+        return f
+    return deko
+
+
+def _basis(wurzel: str) -> str:
+    b = os.path.join(wurzel, "basis")
+    os.makedirs(b)
+    baum_mod.git(b, "init", "-q", "-b", "main")
+    baum_mod.git(b, "config", "core.autocrlf", "false")
+    io.open(os.path.join(b, "README.md"), "w", encoding="utf-8", newline="\n").write("Basis\n")
+    io.open(os.path.join(b, ".gitignore"), "w", encoding="utf-8", newline="\n").write(".env\n")
+    io.open(os.path.join(b, ".env"), "w", encoding="utf-8", newline="\n").write("SONDE=synthetisch\n")
+    baum_mod.git(b, "add", "-A")
+    baum_mod.git(b, *baum_mod.AUTOR, "commit", "-q", "-m", "Basis")
+    return b
+
+
+def _reihe(wurzel: str, basis: str, laeufe: list, usd=5.0, laeufe_max=10, reserve=0.0) -> Reihe:
+    ablage = os.path.join(wurzel, "ablage")
+    os.makedirs(ablage, exist_ok=True)
+    d = {"name": "selbsttest", "client": "attrappe", "wurzel": os.path.join(wurzel, "baeume"),
+         "kontingent": {"laeufe": laeufe_max, "usd": usd, "reserve_usd": reserve},
+         "baum": {"modus": "fest", "basis": basis}, "laeufe": laeufe}
+    r = Reihe(d, ablage)
+    fehler = reihe_pruefen(r, ("attrappe",))
+    assert not fehler, fehler
+    return r
+
+
+def _antworten(wurzel: str, antworten: dict) -> None:
+    pfad = os.path.join(wurzel, "attrappe.json")
+    io.open(pfad, "w", encoding="utf-8").write(json.dumps(antworten))
+    os.environ["LW_ATTRAPPE"] = pfad
+
+
+def _still(*_a, **_k):
+    pass
+
+
+@fall("T1", "eine kaputte Reihe meldet ALLE Schemafehler vor dem ersten Lauf")
+def t1(w):
+    r = Reihe({"name": "x", "client": "attrappe", "kontingent": {},
+               "baum": {"modus": "fest", "basis": "b"}, "wurzel": "w",
+               "laeufe": [{"kennung": "a", "prompt": "p", "erwartung": "e", "folgeturns": [" "]},
+                          {"kennung": "a", "prompt": "p", "erwartung": "e"}]}, w)
+    f = " | ".join(reihe_pruefen(r, ("attrappe",)))
+    for teil in ("kontingent", "doppelt", "Folgeturn ist leer"):
+        assert teil in f, f"'{teil}' nicht gemeldet: {f}"
+
+
+@fall("T2", "fester Baum: ein Lauf schreibt, aendert eine ignorierte Datei und legt eine an - "
+            "der naechste startet trotzdem auf dem Sollstand")
+def t2(w):
+    b = _basis(w)
+    _antworten(w, {"schreib": {"schreibe": {"neu.txt": "x", ".env": "VERAENDERT", "README.md": "y",
+                                            "tief/ordner/z.txt": "z"}},
+                   "lies": {"antwort": "gelesen"}})
+    r = _reihe(w, b, [{"kennung": "a1", "prompt": "schreib", "erwartung": "e"},
+                      {"kennung": "a2", "prompt": "lies", "erwartung": "e"},
+                      {"kennung": "a3", "prompt": "lies", "erwartung": "e"}])
+    laeufer.aufbau(r)
+    assert laeufer.fahren(r, ausgabe=_still) == 3
+    n, usd = kontingent.summe(r.belege)
+    assert (n, round(usd, 2)) == (3, 0.3), (n, usd)
+    pfad = r.baumpfad(r.laeufe[0])
+    assert io.open(os.path.join(pfad, ".env"), encoding="utf-8").read() == "SONDE=synthetisch\n"
+    assert not os.path.exists(os.path.join(pfad, "tief"))
+
+
+@fall("T3", "Arbeitsbranch (K-172): der Baum steht auf arbeit/..., der naechste Lauf wieder auf main")
+def t3(w):
+    b = _basis(w)
+    _antworten(w, {"": {}})
+    r = _reihe(w, b, [{"kennung": "b1", "prompt": "p", "erwartung": "e", "branch": "arbeit/b1"},
+                      {"kennung": "b2", "prompt": "p", "erwartung": "e"}])
+    laeufer.aufbau(r)
+    laeufer.fahren(r, ["b1"], ausgabe=_still)
+    pfad = r.baumpfad(r.laeufe[0])
+    assert baum_mod.git(pfad, "symbolic-ref", "--short", "HEAD") == "arbeit/b1"
+    laeufer.fahren(r, ["b2"], ausgabe=_still)
+    assert baum_mod.git(pfad, "symbolic-ref", "--short", "HEAD") == "main"
+
+
+@fall("T4", "Gegenfall HEAD: steht der Baum auf dem falschen Branch, meldet die Vorpruefung es (D-218)")
+def t4(w):
+    b = _basis(w)
+    _antworten(w, {"": {}})
+    r = _reihe(w, b, [{"kennung": "c1", "prompt": "p", "erwartung": "e", "branch": "arbeit/c1"}])
+    laeufer.aufbau(r)
+    pfad, soll = laeufer._herrichten(r, r.laeufe[0])
+    baum_mod.git(pfad, "checkout", "-q", "main")
+    befunde = vorpruefung.pruefen(r, r.laeufe[0], adapter("attrappe"), soll, pfad)
+    assert any(x.startswith("head: Branch") for x in befunde), befunde
+
+
+@fall("T5", "Gegenfall Zustand: ein Rest im Baum aendert den Baum-Hash, und die Vorpruefung meldet ihn")
+def t5(w):
+    b = _basis(w)
+    _antworten(w, {"": {}})
+    r = _reihe(w, b, [{"kennung": "d1", "prompt": "p", "erwartung": "e"}])
+    laeufer.aufbau(r)
+    pfad, soll = laeufer._herrichten(r, r.laeufe[0])
+    assert not vorpruefung.pruefen(r, r.laeufe[0], adapter("attrappe"), soll, pfad)
+    io.open(os.path.join(pfad, "rest.txt"), "w").write("vom vorigen Lauf")
+    befunde = vorpruefung.pruefen(r, r.laeufe[0], adapter("attrappe"), soll, pfad)
+    assert any(x.startswith("zustand:") for x in befunde), befunde
+
+
+@fall("T6", "Gegenfall Deckel: der Lauf, der das Kontingent reissen koennte, faehrt nicht")
+def t6(w):
+    b = _basis(w)
+    _antworten(w, {"": {"usd": 0.1}})
+    r = _reihe(w, b, [{"kennung": "e%d" % i, "prompt": "p", "erwartung": "e"} for i in range(4)],
+               usd=0.25, reserve=0.1)  # Reserve = was ein Lauf hoechstens kostet
+    laeufer.aufbau(r)
+    try:
+        laeufer.fahren(r, ausgabe=_still)
+        raise AssertionError("kein Abbruch")
+    except SystemExit as e:
+        assert "Kontingent" in str(e), e
+    assert kontingent.summe(r.belege)[0] == 2
+
+
+@fall("T7", "ein Lauf wird nicht doppelt gebucht, und eine gefahrene Kennung faehrt nicht noch einmal")
+def t7(w):
+    b = _basis(w)
+    _antworten(w, {"": {}})
+    r = _reihe(w, b, [{"kennung": "f1", "prompt": "p", "erwartung": "e"}])
+    laeufer.aufbau(r)
+    laeufer.fahren(r, ausgabe=_still)
+    assert laeufer.fahren(r, ausgabe=_still) == 0
+    try:
+        kontingent.eintragen(r.belege, "f1", {"usd": 1})
+        raise AssertionError("doppelt gebucht")
+    except RuntimeError:
+        pass
+
+
+@fall("T8", "Belege im Repositorium sind ein Abbruch (D-222)")
+def t8(w):
+    try:
+        belege_mod.ablage_pruefen(os.path.join(belege_mod.KERN, "tests", "erhebungen", "belege"))
+        raise AssertionError("kein Abbruch")
+    except RuntimeError:
+        pass
+
+
+@fall("T9", "die Standmarke ist gegen Zeilenenden fest und meldet einen fehlenden Gegenstand")
+def t9(w):
+    kern = os.path.join(w, "kern")
+    os.makedirs(kern)
+    io.open(os.path.join(kern, "a.md"), "wb").write(b"eins\r\nzwei\r\n")
+    m1 = stand.marke(["a.md"], kern)
+    io.open(os.path.join(kern, "a.md"), "wb").write(b"eins\nzwei\n")
+    assert stand.marke(["a.md"], kern) == m1
+    io.open(os.path.join(kern, "a.md"), "wb").write(b"eins\ndrei\n")
+    assert stand.marke(["a.md"], kern) != m1
+    try:
+        stand.marke(["fehlt.md"], kern)
+        raise AssertionError("kein Abbruch")
+    except RuntimeError:
+        pass
+
+
+@fall("T10", "ein unerhobener Client sagt es - als Befund der Vorpruefung, nie als Erfolg (D-276)")
+def t10(w):
+    b = _basis(w)
+    r = _reihe(w, b, [{"kennung": "g1", "prompt": "p", "erwartung": "e"}])
+    laeufer.aufbau(r)
+    pfad, soll = laeufer._herrichten(r, r.laeufe[0])
+    befunde = vorpruefung.pruefen(r, r.laeufe[0], AdapterUnerhoben("kiro"), soll, pfad)
+    assert any("hook: nicht pruefbar" in x for x in befunde), befunde
+    assert any("vertrauen: nicht pruefbar" in x for x in befunde), befunde
+    try:
+        AdapterUnerhoben("kiro").lauf("p", pfad, None, "default")
+        raise AssertionError("gefahren")
+    except Unerhoben:
+        pass
+
+
+@fall("T11", "Referenzgruppe (1.21.0): Einstellungen im Messbaum, ein Startverzeichnis ausserhalb "
+             "und Remote-Hooks ohne Remote sind Schemafehler")
+def t11(w):
+    b = _basis(w)
+    innen = os.path.join(w, "baeume", "settings.json")
+    os.makedirs(os.path.dirname(innen))
+    io.open(innen, "w", encoding="utf-8").write("{}")
+    r = Reihe({"name": "x", "client": "attrappe", "wurzel": os.path.join(w, "baeume"),
+               "kontingent": {"laeufe": 1, "usd": 1}, "einstellungen": innen,
+               "baum": {"modus": "fest", "basis": b, "remote_hooks": w},
+               "laeufe": [{"kennung": "a", "prompt": "p", "erwartung": "e",
+                           "unterverzeichnis": "../nachbar"}]}, w)
+    f = " | ".join(reihe_pruefen(r, ("attrappe",)))
+    for teil in ("unter der wurzel", "muss im Baum liegen", "remote_hooks ohne remote"):
+        assert teil in f, f"'{teil}' nicht gemeldet: {f}"
+
+
+@fall("T12", "Referenzgruppe (1.21.0): der Lauf startet im Unterverzeichnis mit der Einstellungsdatei, "
+             "die Verbindung uebersteht das Zuruecksetzen und zaehlt nicht im Baum-Hash")
+def t12(w):
+    b = _basis(w)
+    os.makedirs(os.path.join(b, "frontend"))
+    io.open(os.path.join(b, "frontend", "a.ts"), "w", encoding="utf-8", newline="\n").write("x\n")
+    baum_mod.git(b, "add", "-A")
+    baum_mod.git(b, *baum_mod.AUTOR, "commit", "-q", "-m", "frontend")
+    quelle = os.path.join(w, "geteilt")
+    os.makedirs(quelle)
+    io.open(os.path.join(quelle, "paket.js"), "w").write("geteilt")
+    aussen = os.path.join(w, "referenz-settings.json")
+    io.open(aussen, "w", encoding="utf-8").write("{}")
+    _antworten(w, {"": {}})
+    r = Reihe({"name": "selbsttest", "client": "attrappe", "wurzel": os.path.join(w, "baeume"),
+               "kontingent": {"laeufe": 5, "usd": 5}, "einstellungen": aussen,
+               "baum": {"modus": "fest", "basis": b,
+                        "verbindungen": {"frontend/node_modules": quelle}},
+               "laeufe": [{"kennung": "h1", "prompt": "p", "erwartung": "e",
+                           "unterverzeichnis": "frontend", "gruppe": "referenz"},
+                          {"kennung": "h2", "prompt": "p", "erwartung": "e"}]},
+              os.path.join(w, "ablage"))
+    assert not reihe_pruefen(r, ("attrappe",)), reihe_pruefen(r, ("attrappe",))
+    laeufer.aufbau(r)
+    assert laeufer.fahren(r, ausgabe=_still) == 2
+    pfad = r.baumpfad(r.laeufe[0])
+    assert io.open(os.path.join(pfad, "frontend", "node_modules", "paket.js")).read() == "geteilt"
+    assert baum_mod.baumhash(pfad) == baum_mod.baumhash(b)
+    e = json.loads(io.open(os.path.join(r.belege, "h1-ergebnis.json"), encoding="utf-8").read())
+    assert os.path.normcase(e["start"]) == os.path.normcase(os.path.join(pfad, "frontend")), e
+    assert e["einstellungen"] == aussen, e
+
+
+def main() -> int:
+    schlecht = 0
+    for nummer, was, f in FAELLE:
+        with tempfile.TemporaryDirectory(prefix="lw-selbsttest-") as w:
+            try:
+                f(w)
+                print(f"trägt   {nummer}  {was}")
+            except Exception as e:  # jeder Fehler ist ein Befund dieses Falls
+                schlecht += 1
+                print(f"FÄLLT   {nummer}  {was}\n        {type(e).__name__}: {e}")
+            finally:
+                subprocess.run(["git", "gc", "--quiet"], cwd=w, capture_output=True)
+                for wurzel, _, files in os.walk(w):
+                    for fn in files:
+                        try:
+                            os.chmod(os.path.join(wurzel, fn), 0o666)
+                        except OSError:
+                            pass
+    print(f"\n{len(FAELLE) - schlecht} von {len(FAELLE)} Fällen tragen")
+    return 1 if schlecht else 0

package/.koolie/core/tests/erhebungen/apparat/stand.py

@@ -0,0 +1,30 @@
+# -*- coding: utf-8 -*-
+"""Die Standmarke einer Ergebniszelle (Pruefung 103, D-472, K-61).
+
+Die Rechnung steht an EINER Stelle - in validate-framework.py, stand_wert() -, und dieses
+Modul laedt sie von dort. Eine zweite Rechnung hier waere die Bauform, die der Validator
+bei zaehlen46.py schon einmal aufgeloest hat (D-259): zwei Stellen, die auseinanderlaufen,
+ohne dass es eine merkt. Die Sonde 103 rechnet bewusst selbst - sie ist die Gegenstelle.
+"""
+from __future__ import annotations
+
+import importlib.util
+import os
+
+from .belege import KERN
+
+
+def _validator():
+    pfad = os.path.join(KERN, "tests", "scripts", "validate-framework.py")
+    spec = importlib.util.spec_from_file_location("validate_framework", pfad)
+    modul = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(modul)
+    return modul
+
+
+def marke(pfade: list, kern: str = KERN) -> str:
+    """'[Stand: ...; pfad, pfad]' ueber die Gegenstandsdateien, Pfade relativ zum Kern."""
+    wert = _validator().stand_wert(kern, pfade)
+    if wert is None:
+        raise RuntimeError("ein Gegenstand fehlt: " + ", ".join(pfade))
+    return "[Stand: %s; %s]" % (wert, ", ".join(pfade))