@renoxar/koolie 1.25.0

package/.koolie/core/tests/scripts/sonden/teil15_banner_und_nachlauf.py

@@ -0,0 +1,193 @@
+"""Sonden zu 1.20.3: das Banner des Installationsdialogs (CR-2026-165, D-506, D-507).
+
+Teil des Sondenskripts probe-pruefungen.py, seit 1.19.1 in Module geteilt (K-174). Die
+Einheiten melden sich beim Laden dieses Moduls an; der Einstieg laedt die Module in der
+Reihenfolge ihrer Nummer, und das ist die Reihenfolge der Ausgabe (D-49). Ein Modul liest
+nur aus dem Apparat und aus frueheren Teilen.
+
+Das Banner ist keine Pruefung, sondern ein Werkzeug - die Einheiten sind Wirkungsnachweise
+wie T362 fuer den Kopierweg. Die Referenz ist der Antrag selbst: Anhang 5.1, 5.2, 5.4 und
+5.5 von CR-2026-165 tragen die Ausgabe zeichengenau, mit `<FRAMEWORK_OWNER>` an der Stelle
+des Namens (D-323). Eine Aenderung am Design aendert also Antrag und Asset zusammen - oder
+diese Einheiten melden sie."""
+from __future__ import annotations
+
+import importlib.util
+import io
+import os
+import re
+import sys
+
+from .apparat import (
+    aufraeumen, buendel, ersetze, kopie, lies, melde, notiz, P, Praeparationsfehler,
+    QUELLE, schreib, unterprozess)
+
+KERN_REL = ".koolie/core"
+CR_165 = ".koolie/core/governance/change-requests/CR-2026-165-installer-banner.md"
+PLATZHALTER = "<FRAMEWORK_OWNER>"
+
+
+def _banner_laden(kern: str):
+    spec = importlib.util.spec_from_file_location("banner_sonde_%d" % id(kern),
+                                                  os.path.join(kern, "banner.py"))
+    modul = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(modul)
+    return modul
+
+
+def _referenz(text: str, abschnitt: str) -> list:
+    """Der erste ```text-Block nach der Ueberschrift des Abschnitts im Antrag."""
+    m = re.search(r"^#+ " + re.escape(abschnitt) + r" .*?\n```text\n(.*?)```",
+                  text.replace("\r\n", "\n"), re.S | re.M)
+    if not m:
+        raise Praeparationsfehler("CR-2026-165: Referenzblock %s nicht gefunden" % abschnitt)
+    return m.group(1).rstrip("\n").split("\n")
+
+
+class _Strom(io.StringIO):
+    """Ein Ausgabestrom, der sich als Terminal ausgibt."""
+
+    def __init__(self, terminal: bool = True, kodierung: str = "utf-8") -> None:
+        super().__init__()
+        self._terminal, self._kodierung = terminal, kodierung
+
+    @property
+    def encoding(self) -> str:
+        return self._kodierung
+
+    def isatty(self) -> bool:
+        return self._terminal
+
+
+def _dialog(kern: str, *argv, env=None, kodierung="utf-8"):
+    umgebung = dict(os.environ)
+    umgebung.pop("KOOLIE_NO_BANNER", None)
+    umgebung.update(env or {})
+    return unterprozess([sys.executable, os.path.join(kern, "install_dialog.py"), *argv],
+                        input="q\n", env=umgebung, kodierung=kodierung)
+
+
+def sonden_installer_banner() -> None:
+    kern = os.path.join(QUELLE, *KERN_REL.split("/"))
+    b = _banner_laden(kern)
+    antrag = lies(P(QUELLE, *CR_165.split("/")))
+    ph = {"jahr": "2026", "name": PLATZHALTER, "lizenz": "GPL-3.0"}
+
+    # --- T506a-d: die vier Referenzen des Antrags -----------------------------------
+    voll = b.rendern_voll("0.1.0", ph)
+    ok = [z for z, _ in voll] == _referenz(antrag, "5.1")
+    melde("SONDE", "T506a", ok, "Die Vollvariante entspricht Anhang 5.1 des Antrags zeichengenau "
+                               "(25 Zeilen, der Hund ueber dem Rahmen)")
+    ok = [k.rstrip() for _, k in voll] == [z.rstrip() for z in _referenz(antrag, "5.2")]
+    melde("SONDE", "T506b", ok, "Die Farbzonen der Vollvariante entsprechen der Zonenkarte 5.2")
+    ok = [z for z, _ in b.rendern_kompakt("0.1.0", ph)] == _referenz(antrag, "5.4")
+    melde("SONDE", "T506c", ok, "Die Kompaktvariante entspricht Anhang 5.4 zeichengenau")
+    ok = [z for z, _ in b.rendern_text("0.1.0", ph)] == _referenz(antrag, "5.5")
+    melde("SONDE", "T506d", ok, "Die Textvariante entspricht Anhang 5.5 und ist ASCII")
+
+    # --- T506e: Auswahl nach Abschnitt 6 --------------------------------------------
+    fall = [({}, True, "utf-8", 80, False, True, "voll"),
+            ({}, True, "utf-8", 79, False, True, "kompakt"),
+            ({}, True, "utf-8", 66, False, True, "kompakt"),
+            ({}, True, "utf-8", 65, False, True, "text"),
+            ({}, False, "utf-8", 120, False, True, "text"),
+            ({}, True, "cp1252", 120, False, True, "text"),
+            ({}, True, "utf-8", 80, True, True, "kompakt"),
+            ({}, True, "utf-8", 81, True, True, "voll"),
+            ({"WT_SESSION": "x"}, True, "utf-8", 80, True, True, "voll"),
+            ({"WT_SESSION": "x"}, True, "utf-8", 120, True, False, "text"),
+            ({"KOOLIE_NO_BANNER": "1"}, True, "utf-8", 120, False, True, None)]
+    falsch = [f for f in fall if b.variante_waehlen(*f[:6]) != f[6]]
+    melde("SONDE", "T506e", not falsch,
+          "Die Auswahl folgt der Tabelle: Breite 80/66, Pipe, Kodierung, alte Windows-Konsole "
+          "ab 81, Terminalsteuerung, Abschaltung")
+    if falsch:
+        notiz("        abweichend: %r" % [(f[3], f[4], f[6]) for f in falsch])
+
+    # --- T506f: Farbstufe und NO_COLOR ------------------------------------------------
+    stufen = [({"COLORTERM": "truecolor"}, True, "true"), ({"COLORTERM": "24bit"}, True, "true"),
+              ({"TERM": "xterm-256color"}, True, "256"), ({"WT_SESSION": "x"}, True, "true"),
+              ({}, True, "mono"), ({"COLORTERM": "truecolor"}, False, "mono"),
+              ({"COLORTERM": "truecolor", "NO_COLOR": ""}, True, "mono"),
+              ({"COLORTERM": "truecolor", "TERM": "dumb"}, True, "mono")]
+    falsch = [s for s in stufen if b.farbstufe(s[0], s[1]) != s[2]]
+    farbig, ohne = _Strom(), _Strom()
+    b.ausgeben(farbig, umgebung={"COLORTERM": "truecolor"}, variante="voll")
+    b.ausgeben(ohne, umgebung={"COLORTERM": "truecolor", "NO_COLOR": "1"}, variante="voll")
+    zweihundert = b.rendern("voll", "256", "0.1.0", ph)
+    ok = (not falsch and "\x1b[" in farbig.getvalue() and "\x1b" not in ohne.getvalue()
+          and re.sub("\x1b\\[[0-9;]*m", "", farbig.getvalue()) == ohne.getvalue()
+          and "38;5;80" in "".join(zweihundert) and "38;2;" not in "".join(zweihundert))
+    melde("SONDE", "T506f", ok, "Farbe nur im Terminal und ohne NO_COLOR; ohne Farbe formgleich "
+                               "und ohne ein einziges Steuerzeichen; 256 Farben mit den Indizes")
+    if falsch:
+        notiz("        Farbstufe abweichend: %r" % falsch)
+
+    # --- T506g: der Dialog ueber eine Pipe und die beiden Schalter ---------------------
+    version = lies(os.path.join(kern, "VERSION")).strip()
+    p = _dialog(kern)
+    zeilen = p.stdout.splitlines()
+    ok_pipe = (p.returncode == 1 and zeilen[:1] == ["KOOLIE v" + version]
+               and "\x1b" not in p.stdout and zeilen[4:6] == ["", "Koolie %s - Installation in "
+                                                                 "ein Projekt" % version])
+    p1 = _dialog(kern, "--no-banner")
+    p2 = _dialog(kern, env={"KOOLIE_NO_BANNER": "1"})
+    ok_aus = all(q.returncode == 1 and q.stdout.startswith("Koolie %s - Installation" % version)
+                 for q in (p1, p2))
+    melde("SONDE", "T506g", ok_pipe and ok_aus,
+          "Ueber eine Pipe gibt der Dialog die Textvariante ohne Farbe aus, gefolgt von genau "
+          "einer Leerzeile; --no-banner und KOOLIE_NO_BANNER=1 unterdruecken sie")
+    if not (ok_pipe and ok_aus):
+        notiz("        Pipe %s, Schalter %s: %s" % (ok_pipe, ok_aus, " | ".join(zeilen[:6])))
+
+    # --- T506h: ASCII ohne Ausnahme -------------------------------------------------
+    p = _dialog(kern, kodierung="ascii")
+    ok = (p.returncode == 1 and "UnicodeEncodeError" not in p.stderr
+          and "Nichts installiert" in p.stdout and p.stdout.startswith("KOOLIE v"))
+    melde("SONDE", "T506h", ok, "Mit ASCII als Ausgabekodierung kommt die Textvariante, "
+                               "umschrieben, ohne UnicodeEncodeError")
+
+    # --- T506i/j: ein defektes Asset, ein nicht ladbares Modul -----------------------
+    wurzel = kopie()
+    try:
+        kk = P(wurzel, *KERN_REL.split("/"))
+        ersetze(P(kk, "banner.py"), ("HUND_ZONEN = (\r\n", "HUND_ZONEN = None and (\r\n"))
+        p = unterprozess([sys.executable, P(kk, "banner.py"), "--variante", "voll"])
+        ok = p.returncode == 0 and p.stdout.startswith("KOOLIE v") and "Traceback" not in p.stderr
+        melde("SONDE", "T506i", ok, "Ein defektes Asset faellt auf die Textvariante zurueck, "
+                                   "ohne Abbruch")
+        schreib(P(kk, "banner.py"), "raise RuntimeError('Sonde T506j')\r\n")
+        p = _dialog(kk)
+        ok = (p.returncode == 1 and p.stdout.startswith("Koolie ")
+              and "Nichts installiert" in p.stdout)
+        melde("SONDE", "T506j", ok, "Ein Banner-Modul, das nicht laedt, haelt den Dialog nicht "
+                                   "auf - er beginnt mit seiner ersten Zeile")
+    finally:
+        aufraeumen(os.path.dirname(wurzel))
+
+    # --- T506k: Fusszeile und Version aus ihren Quellen ------------------------------
+    hinweis = lies(os.path.join(kern, "LICENSE-HINWEIS.md"))
+    m = re.search(r"^Copyright © (\d{4}) (.+?)\r?$", hinweis, re.M)
+    fuss = b.fuss_lesen()
+    ok = (m is not None and fuss == {"jahr": m.group(1), "name": m.group(2), "lizenz": "GPL-3.0"}
+          and "SPDX-Kennung: `GPL-3.0-only`" in hinweis and b.version_lesen() == version)
+    wurzel = kopie()
+    try:
+        kk = P(wurzel, *KERN_REL.split("/"))
+        pf = P(kk, "LICENSE-HINWEIS.md")
+        t = lies(pf)
+        if t.count(m.group(0) if m else "\x00") != 1:
+            raise Praeparationsfehler("LICENSE-HINWEIS.md: Copyright-Zeile nicht genau einmal")
+        schreib(pf, t.replace(m.group(0), "Copyright liegt beim Rechteinhaber"))
+        p = unterprozess([sys.executable, P(kk, "banner.py"), "--variante", "text"])
+        ohne_name = p.stdout.splitlines()[3:4] == ["GPL-3.0 - " + b.REPOSITORIUM]
+    finally:
+        aufraeumen(os.path.dirname(wurzel))
+    melde("SONDE", "T506k", ok and ohne_name,
+          "Name, Jahr und Lizenz kommen aus dem Lizenzhinweis, die Version aus VERSION; fehlt "
+          "die Copyright-Zeile, entfaellt der Name")
+
+
+buendel(sonden_installer_banner,
+        "Das Banner des Installationsdialogs gegen die Referenzen des Antrags, seine Auswahl "
+        "und sein Verhalten im Fehlerfall (CR-2026-165, D-506, D-507)")

package/.koolie/core/tests/scripts/sonden/teil16_koexistenz.py

@@ -0,0 +1,114 @@
+"""Sonden zur Koexistenz mit fremden Agenten-Rahmenwerken (1.21.0): die Deklaration fremder
+Skills und ihre Grenze (Pruefung 111, K-31), der Korb, den Pruefung 72 weiter verlangt, und
+die Auskunft von install.py.
+
+Teil des Sondenskripts probe-pruefungen.py, seit 1.19.1 in Module geteilt (K-174). Die
+Einheiten melden sich beim Laden dieses Moduls an; der Einstieg laedt die Module in der
+Reihenfolge ihrer Nummer, und das ist die Reihenfolge der Ausgabe (D-49). Ein Modul liest
+nur aus dem Apparat und aus frueheren Teilen."""
+from __future__ import annotations
+
+import json
+import os
+import sys
+
+from .apparat import (
+    aufraeumen, buendel, installation, lies, melde, Praeparationsfehler, schreib, unterprozess,
+    validator_ausgabe)
+
+# Nachgebildet nach OpenSpec 1.13.2 (gemessen 2026-09-30): Frontmatter mit Feldern, die
+# Koolie nicht kennt, keine Metadatenzeilen, keine Testblaetter. SYNTHETISCH.
+FREMDER_SKILL = ("---\nname: openspec-explore\ndescription: Explore ideas before a change. "
+                 "SYNTHETISCH\nlicense: MIT\n---\n\n# Explore\n\nSYNTHETISCH\n")
+M111_STRUKTUR = "openspec-explore: EXAMPLES.md fehlt"
+M111_OFFEN = "(openspec-*) sind nicht deklariert"
+M111_UNZULAESSIG = "das Praefix koennte einen Koolie-Skill treffen"
+M111_OHNE = "eine Deklaration ohne Gegenstand"
+M72_FREMD = "der Skill 'openspec-explore' liegt in"
+M37_FREMD = "Skill(openspec-*)"
+M_AUSKUNFT = "fremdes Agenten-Rahmenwerk neben Koolie"
+M_DEKLARIEREN = "fremde_skills: openspec-"
+M111_BLOCK = "eines fremden Generators"
+M_ABBRUCH = "markierte(n) Block/Bloecke eines fremden Generators"
+BLOCK = "\n<!-- OPENSPEC:START -->\nSYNTHETISCH\n<!-- OPENSPEC:END -->\n"
+
+
+def _manifest(root: str) -> str:
+    return os.path.join(root, ".koolie", "project-overlay", "overlay-manifest.yaml")
+
+
+def _deklarieren(root: str, wert: str, urstand: str) -> None:
+    schreib(_manifest(root), urstand.rstrip("\n") + "\nfremde_skills: %s\n" % wert)
+
+
+def _install(root: str) -> str:
+    p = unterprozess([sys.executable, os.path.join(root, ".koolie", "core", "install.py"),
+                      "--client", "claude-code", "--root", root])
+    return (p.stdout or "") + (p.stderr or "")
+
+
+def sonden_fremde_skills() -> None:
+    """Pruefung 111 und die Auskunft an einer claude-code-Installation mit einem fremden Skill."""
+    root = installation("claude-code")
+    try:
+        aus = _install(root)
+        melde("GEGENPROBE", "111a", M_AUSKUNFT not in aus,
+              "Eine Installation ohne fremdes Rahmenwerk - keine Auskunft")
+        ablage = os.path.join(root, ".claude", "skills", "openspec-explore")
+        os.makedirs(ablage)
+        schreib(os.path.join(ablage, "SKILL.md"), FREMDER_SKILL)
+        os.makedirs(os.path.join(root, "openspec"))
+        schreib(os.path.join(root, "openspec", "config.yaml"), "schema: spec-driven\n")
+        aus = _install(root)
+        melde("SONDE", "111b", M_AUSKUNFT in aus and M_DEKLARIEREN in aus,
+              "install.py erkennt OpenSpec an Ablage und Skill und nennt die Deklaration")
+        aus = validator_ausgabe(root)
+        melde("SONDE", "111c", M111_STRUKTUR in aus and M111_OFFEN in aus,
+              "Ohne Deklaration prueft Pruefung 5 den fremden Skill als Koolie-Skill, und "
+              "Pruefung 111 nennt die fehlende Deklaration")
+        urstand = lies(_manifest(root))
+        _deklarieren(root, "openspec-", urstand)
+        aus = validator_ausgabe(root)
+        melde("GEGENPROBE", "111d", M111_STRUKTUR not in aus and M111_OFFEN not in aus,
+              "Deklariert - Pruefung 5 nimmt ihn aus, Pruefung 111 ist still")
+        melde("SONDE", "111e", M72_FREMD in aus,
+              "Den Korb verlangt Pruefung 72 weiter (D-238): ein fremder Skill ist ein "
+              "Werkzeug der Sitzung wie jeder andere")
+        perm = os.path.join(root, ".claude", "settings.json")
+        einstellungen = json.loads(lies(perm))
+        einstellungen["permissions"]["ask"].append("Skill(openspec-*)")
+        schreib(perm, json.dumps(einstellungen, ensure_ascii=False, indent=2) + "\n")
+        aus = validator_ausgabe(root)
+        melde("GEGENPROBE", "111f", M72_FREMD not in aus and M37_FREMD not in aus,
+              "Skill(openspec-*) im ask-Korb deckt den deklarierten Skill und gilt nicht "
+              "als Ausweitung")
+        _deklarieren(root, "fw-, speckit-", urstand)
+        testblatt = os.path.join(root, ".claude", "skills", "fw-plan", "TESTS.md")
+        if not os.path.isfile(testblatt):
+            raise Praeparationsfehler("fw-plan/TESTS.md fehlt in der Installation")
+        os.remove(testblatt)
+        aus = validator_ausgabe(root)
+        melde("SONDE", "111g", M111_UNZULAESSIG in aus and "fw-plan: TESTS.md fehlt" in aus,
+              "'fw-' als fremdes Praefix wird gemeldet und nimmt nichts aus - der Koolie-Skill "
+              "bleibt geprueft")
+        melde("SONDE", "111h", M111_OHNE in aus,
+              "Ein deklariertes Praefix ohne Skill ('speckit-') wird gemeldet")
+        wurzel = os.path.join(root, "CLAUDE.md")
+        schreib(wurzel, lies(wurzel) + BLOCK)
+        aus = validator_ausgabe(root)
+        melde("SONDE", "111i", M111_BLOCK in aus,
+              "Pruefung 111 warnt vor dem markierten Block eines Generators in der "
+              "Wurzel-Anweisung (Budget, K-185)")
+        p = unterprozess([sys.executable, os.path.join(root, ".koolie", "core", "install.py"),
+                          "--client", "claude-code", "--root", root, "--update"])
+        melde("SONDE", "111j", p.returncode != 0 and M_ABBRUCH in (p.stdout or "") + (p.stderr or "")
+              and BLOCK.strip() in lies(wurzel),
+              "install.py --update bricht vor dem Block ab, statt ihn mit der Wurzel-Anweisung "
+              "zu ueberschreiben - und der Block bleibt stehen (D-515)")
+    finally:
+        aufraeumen(os.path.dirname(root))
+
+
+buendel(sonden_fremde_skills,
+        "Pruefung 111 und die Auskunft zu fremden Rahmenwerken an einer claude-code-"
+        "Installation: sieben Sonden, drei Gegenproben")

package/.koolie/core/tests/scripts/sonden/teil17_paketquellen.py

@@ -0,0 +1,115 @@
+"""Sonden zu den Paketquellen (1.22.0): der Befehl koolie mit dem Banner vor install.py und
+der Bau der Pakete aus einem Release-Archiv (Pruefung 112, K-155).
+
+Teil des Sondenskripts probe-pruefungen.py, seit 1.19.1 in Module geteilt (K-174). Die
+Einheiten melden sich beim Laden dieses Moduls an; der Einstieg laedt die Module in der
+Reihenfolge ihrer Nummer, und das ist die Reihenfolge der Ausgabe (D-49). Ein Modul liest
+nur aus dem Apparat und aus frueheren Teilen."""
+from __future__ import annotations
+
+import os
+
+from .apparat import buendel, ersetze, fehlerfrei, gegenprobe, melde, P, sonde
+
+BEFEHL = "paketquellen/koolie_befehl.py"
+BAUEN = "paketquellen/bauen.py"
+M112 = "(Pruefung 112"
+M112_BANNER = "startet install.py ohne das Banner davor"
+M112_SCHALTER = "KOOLIE_NO_BANNER=1 schaltet das Banner nicht ab"
+M112_VERSION = "'--version' liefert"
+M112_BAU = "baut aus einem Wegwerfarchiv nicht ohne Befund"
+M112_FEHLT = "paketquellen/koolie.cmd: fehlt"
+
+
+def _p(root: str, rel: str) -> str:
+    return P(root, rel.replace("/", os.sep))
+
+
+# --- Pruefung 112: Die Paketquellen und das Banner (CR-2026-168, D-519, D-520) ---------
+#
+# Jede Sonde nimmt dem Befehl oder dem Bau genau eine Zusage: das Banner vor install.py,
+# den Schalter, die Version, das Fehlen eines npm-Installationsskripts, eine Datei des
+# Befehls. Die Suchtexte enthalten kein Zeilenende - die Kopie traegt die Form des
+# Arbeitsbaums.
+def _112_ohne_banner(root: str) -> None:
+    ersetze(_p(root, BEFEHL), ("    banner_ausgeben(argv)", "    pass  # SYNTHETISCH"))
+
+
+def _112_schalter(root: str) -> None:
+    ersetze(_p(root, BEFEHL), ("banner.ausgeben(argv=argv, version=version())",
+                               "banner.ausgeben(argv=argv, version=version(), umgebung={})"))
+
+
+def _112_version(root: str) -> None:
+    ersetze(_p(root, BEFEHL), ('print(f"koolie {version()}")', 'print("koolie 0.0.0")'))
+
+
+def _112_npm_skript(root: str) -> None:
+    ersetze(_p(root, BAUEN), ('"engines": {"node": ">=16"},',
+                              '"engines": {"node": ">=16"}, '
+                              '"scripts": {"postinstall": "node SYNTHETISCH"},'))
+
+
+def _112_ohne_huelle(root: str) -> None:
+    os.remove(_p(root, "paketquellen/koolie.cmd"))
+
+
+sonde("112a", "Ein Befehl koolie, der install.py ohne das Banner startet, wird gemeldet - auf "
+             "den Wegen der Paketquellen erschiene es nicht", _112_ohne_banner, M112_BANNER)
+sonde("112b", "Ein Befehl, der KOOLIE_NO_BANNER nicht an das Banner weitergibt, wird gemeldet",
+      _112_schalter, M112_SCHALTER)
+sonde("112c", "Ein Befehl, dessen --version nicht die Version aus VERSION nennt, wird gemeldet",
+      _112_version, M112_VERSION)
+sonde("112d", "Ein npm-Paket mit Installationsskript wird gemeldet - bauen.py prueft es nach",
+      _112_npm_skript, M112_BAU)
+sonde("112e", "Fehlt die Huelle koolie.cmd fuer Scoop, wird es gemeldet", _112_ohne_huelle,
+      M112_FEHLT)
+# Seit 1.24.0 (D-528, D-529): die Beschreibung fuer PyPI und npm mit absoluten Links und
+# die Vorabversion fuer TestPyPI.
+def _112_relative_links(root: str) -> None:
+    ersetze(_p(root, BAUEN), ("    return RELATIVER_LINK.sub(absolut, text)",
+                              "    return text  # SYNTHETISCH"))
+
+
+def _112_vorab(root: str) -> None:
+    ersetze(_p(root, BAUEN), ('return f"{version}.dev{vorab}", f"{version}-dev.{vorab}"',
+                              'return f"{version}.dev{vorab}", version'))
+
+
+def _112_vorgabe(root: str) -> None:
+    ersetze(_p(root, BEFEHL), (', "--vorgabe", os.getcwd()]).returncode', ']).returncode'))
+
+
+sonde("112i", "Ein Befehl, der dem Dialog das Verzeichnis des Aufrufs nicht als Vorgabe gibt, "
+              "wird gemeldet - uvx, pipx run und npx starten ihn im Projekt", _112_vorgabe,
+      "nimmt das Verzeichnis des Aufrufs")
+def _112_npm_privat(root: str) -> None:
+    ersetze(_p(root, BAUEN), ('"publishConfig": {"access": "public"},', ''))
+
+
+sonde("112j", "Ein npm-Paket mit Scope ohne oeffentlichen Zugang wird gemeldet - npm wiese "
+              "das Hochladen ab", _112_npm_privat, M112_BAU)
+sonde("112g", "Ein Bau, der die Links der Beschreibung relativ laesst, wird gemeldet - auf PyPI "
+              "und npm fuehrten sie ins Leere", _112_relative_links, M112_BAU)
+sonde("112h", "Eine Vorabversion, deren npm-Paket die Version der Marke traegt, wird gemeldet - "
+              "sie belegte die Version vor der Signatur", _112_vorab, M112_BAU)
+gegenprobe("112", "Der ausgelieferte Befehl gibt das Banner vor install.py aus, und bauen.py "
+                  "baut ohne Befund", None, M112)
+
+
+# --- Der Waechter der Gegenproben (D-522) ------------------------------------------------
+#
+# Eine Gegenprobe bestand bis 1.21.0, sobald "0 Fehler" irgendwo in der Ausgabe stand - also
+# auch bei "10 Fehler". Gefunden an der Gegenprobe zu 112, die an einem Baum mit zehn offenen
+# Fehlern bestand. Die Sonde haelt die Unterscheidung an der Ergebniszeile fest.
+def sonden_ergebniszeile() -> None:
+    """Der Apparat unterscheidet 0 Fehler von 10 Fehlern."""
+    melde("SONDE", "112f", not fehlerfrei("Ergebnis: 10 Fehler, 0 Warnungen")
+          and not fehlerfrei("Ergebnis: 20 Fehler, 3 Warnungen"),
+          "Eine Gegenprobe besteht nicht mehr an einem Lauf mit zehn oder zwanzig Fehlern")
+    melde("GEGENPROBE", "112f", fehlerfrei("Ergebnis: 0 Fehler, 2 Warnungen"),
+          "Ein Lauf ohne Fehler, mit Warnungen, gilt weiter als fehlerfrei")
+
+
+buendel(sonden_ergebniszeile,
+        "Der Waechter der Gegenproben liest die Ergebniszeile: eine Sonde, eine Gegenprobe")

package/.koolie/core/tests/scripts/sonden/teil18_modusbindung_m3_m5.py

@@ -0,0 +1,113 @@
+"""Sonden zur Modusbindung M3 bis M5 (1.23.0, CR-2026-169, K-201): mandat.py kopiert die
+Pfadliste des Modus aus dem Overlay in die Bindung, und der Schutz-Hook wertet sie als
+Globs aus - mit Nur-Lese-Pfaden, Umfang, Namensvettern, Punktsegmenten und dem Glob mitten
+im Pfad. Dazu die Gegenprobe zu Pruefung 99: ein abweichender Rumpf von glob_muster.
+
+Teil des Sondenskripts probe-pruefungen.py, seit 1.19.1 in Module geteilt (K-174). Die
+Einheiten melden sich beim Laden dieses Moduls an; der Einstieg laedt die Module in der
+Reihenfolge ihrer Nummer, und das ist die Reihenfolge der Ausgabe (D-49). Ein Modul liest
+nur aus dem Apparat und aus frueheren Teilen."""
+from __future__ import annotations
+
+import json
+import os
+import sys
+
+from .apparat import (
+    aufraeumen, buendel, installation, lies, melde, schreib, strict_ausgabe, unterprozess)
+from .teil14_modi_ausnahmen_skills import _hook, _modus_setzen, _schreiben
+
+MODUS = os.path.join(".git", "koolie-modus.json")
+
+# Die Werte haben die Gestalten, die in den drei gemessenen Overlays vorkommen: Praefix,
+# Einzeldatei, Glob mitten im Pfad (Uebung) und "nicht vorhanden" (otp-generator).
+OVERLAY_ABSCHNITT_4 = """
+## 4. Pfade
+
+| Zweck | Platzhalter | Wert | Hinweis |
+|---|---|---|---|
+| Erlaubte Pfade (Lesen und Ändern in M3) | `<ALLOWED_PATHS>` | `src/**`, `test/**`, `README.md` | Sonde |
+| Testpfade (Ändern in M4) | `<TEST_PATHS>` | `test/**`, `src/**/*.test.ts` | Sonde |
+| Dokumentationspfade (Ändern in M5) | `<DOC_PATHS>` | `nicht vorhanden` | Sonde |
+| Nur-Lese-Pfade (Lesen erlaubt, Ändern nie) | `<READ_ONLY_PATHS>` | `src/api/**` | Sonde |
+"""
+
+
+def _binden(root: str, *argv: str):
+    mandat = os.path.join(root, ".koolie", "core", "mandat.py")
+    return unterprozess([sys.executable, mandat, "modus", *argv])
+
+
+def _frei(root: str, rel: str) -> bool:
+    return _hook(root, _schreiben(rel)) == 0
+
+
+def sonden_modusbindung_m3_m5() -> None:
+    """M3 bis M5 an einer echten Installation: Bindung aus dem Overlay, Auswertung im Hook."""
+    root = installation("claude-code")
+    try:
+        os.makedirs(os.path.join(root, ".git"), exist_ok=True)
+        overlay = os.path.join(root, ".koolie", "project-overlay", "OVERLAY.md")
+        # Ersetzt, nicht angehaengt: Die Vorlage traegt dieselben Zeilen mit <TBD>, und
+        # gelesen wird die erste.
+        schreib(overlay, "# Overlay\n" + OVERLAY_ABSCHNITT_4)
+
+        p = _binden(root, "M3", "--minuten", "5")
+        daten = json.loads(lies(os.path.join(root, MODUS))) if p.returncode == 0 else {}
+        melde("SONDE", "K201a", daten.get("pfade") == ["src/**", "test/**", "README.md"]
+              and daten.get("nur_lesen") == ["src/api/**"],
+              "mandat.py modus M3 kopiert <ALLOWED_PATHS> und <READ_ONLY_PATHS> in die Bindung")
+        melde("SONDE", "K201b", _frei(root, "src/a/B.java") and _frei(root, "README.md")
+              and not _frei(root, "docs/x.md") and not _frei(root, "README.md.bak"),
+              "M3: Praefix und Einzeldatei frei, alles Uebrige gesperrt")
+        melde("SONDE", "K201c", not _frei(root, "src/api/v1.yaml"),
+              "M3: ein Nur-Lese-Pfad innerhalb der erlaubten Pfade bleibt gesperrt")
+        melde("SONDE", "K201d", not _frei(root, "src2/x.java")
+              and not _frei(root, "src/../docs/x.md") and not _frei(root, "../draussen/x"),
+              "M3: Namensvetter, Punktsegment und ein Ziel ausserhalb fuehren nicht hinein")
+        melde("SONDE", "K201e", _frei(root, "SRC/a.java"),
+              "M3: ohne Gross- und Kleinschreibung wie jeder Pfadvergleich des Hooks (D-492)")
+
+        p = _binden(root, "M3", "--umfang", "src/billing/**", "--minuten", "5")
+        melde("SONDE", "K201f", p.returncode == 0 and _frei(root, "src/billing/R.java")
+              and not _frei(root, "src/other/R.java") and not _frei(root, "test/T.java"),
+              "M3 mit --umfang: nur die Schnittmenge aus Umfang und <ALLOWED_PATHS>")
+        p = _binden(root, "M3", "--umfang", "docs/**", "--minuten", "5")
+        melde("SONDE", "K201g", p.returncode == 0 and not _frei(root, "docs/a.md"),
+              "M3: ein Umfang ausserhalb von <ALLOWED_PATHS> oeffnet nichts")
+
+        p = _binden(root, "M4", "--minuten", "5")
+        melde("SONDE", "K201h", p.returncode == 0 and _frei(root, "test/T.java")
+              and _frei(root, "src/ui/knopf.test.ts") and not _frei(root, "src/ui/knopf.ts"),
+              "M4: Testpfade frei, auch der Glob mitten im Pfad; Produktivcode gesperrt")
+
+        os.remove(os.path.join(root, MODUS))
+        p = _binden(root, "M5", "--minuten", "5")
+        melde("SONDE", "K201i", p.returncode == 2
+              and not os.path.exists(os.path.join(root, MODUS)),
+              "M5 ohne <DOC_PATHS> bindet nicht - eine Bindung, die nichts erlaubt, ist M1")
+        p = _binden(root, "M3", "--umfang", "../x/**", "--minuten", "5")
+        melde("SONDE", "K201j", p.returncode == 2
+              and not os.path.exists(os.path.join(root, MODUS)),
+              "Ein Umfang mit '..' wird abgelehnt, und nichts wird geschrieben")
+
+        _modus_setzen(root, "M3")  # gueltig in Zeit und Projekt, aber ohne "pfade"
+        melde("GEGENPROBE", "K201k", _frei(root, "docs/x.md"),
+              "Eine Bindung ohne Pfade ist kaputt und sperrt nichts (wie bei M2, D-501)")
+        _binden(root, "aus")
+        melde("GEGENPROBE", "K201l", _frei(root, "docs/x.md"),
+              "mandat.py modus aus hebt auch M3 bis M5 auf")
+
+        mandat = os.path.join(root, ".koolie", "core", "mandat.py")
+        melde("GEGENPROBE", "K201n", "glob_muster" not in strict_ausgabe(root),
+              "Pruefung 99: gleichlautende Funktionen glob_muster melden nichts")
+        schreib(mandat, lies(mandat).replace('raus + "[^/]*", i + 1', 'raus + ".*", i + 1', 1))
+        melde("SONDE", "K201m", "glob_muster" in strict_ausgabe(root),
+              "Pruefung 99: ein '*', das in mandat.py ueber '/' hinweg trifft, wird gemeldet")
+    finally:
+        aufraeumen(os.path.dirname(root))
+
+
+buendel(sonden_modusbindung_m3_m5,
+        "Die Modusbindung fuer M3 bis M5 an einer claude-code-Installation: Kopie aus dem "
+        "Overlay, Globs, Nur-Lese-Pfade, Umfang, Ausbruch, leere Liste, Aufheben")