@renoxar/koolie 1.25.0

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

@@ -0,0 +1,149 @@
+"""Sonden zu den Pruefungen 104 (Verdrahtung der Pruefwerkzeuge) und 105 (gepruefte
+Clientversion in der Zielspanne).
+
+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 (
+    ersetze, gegenprobe, lies, P, Praeparationsfehler, schreib, sonde, VALIDATOR)
+
+
+# --- Pruefung 104: die Verdrahtung der Pruefwerkzeuge (CR-2026-161, D-481) -------------
+#
+# Fuenf Sonden, je eine auf einen eigenen Gegenstand: eine Pruefung, die niemand ruft;
+# eine, die main() zweimal ruft; ein Sondenteil, den niemand laedt; Teile in falscher
+# Reihenfolge; und der verlorene Gegenstand. Die Gegenprobe haelt die Grenze des
+# Praefixes: Eine Hilfsfunktion _check_* ist keine Pruefung.
+P104_SONDENLAUF = ".koolie/core/tests/scripts/probe-pruefungen.py"
+P104_SONDENTEILE = ".koolie/core/tests/scripts/sonden"
+P104_WERKZEUGE = ".koolie/core/tests/scripts/pruefungen/werkzeuge.py"
+P104_AUFRUF = "    check_lizenz(root)\r\n"
+M104_UNGERUFEN = "check_lizenz() wird von niemandem gerufen"
+M104_ZWEIMAL = "main() ruft check_lizenz() 2mal"
+M104_UNGELADEN = "teil99_sondenteil.py: wird von tests/scripts/probe-pruefungen.py nicht geladen"
+M104_REIHENFOLGE = "nicht in der Reihenfolge ihrer Nummer"
+M104_ANKER = "kein Sondenteil teil<Nummer>_*.py"
+M104_MARKE = "(D-481)"
+
+
+def _p(root: str, rel: str) -> str:
+    return P(root, rel.replace("/", os.sep))
+
+
+def _104_ungerufen(root: str) -> None:
+    ersetze(_p(root, VALIDATOR), (P104_AUFRUF, ""))
+
+
+def _104_zweimal(root: str) -> None:
+    ersetze(_p(root, VALIDATOR), (P104_AUFRUF, P104_AUFRUF + P104_AUFRUF))
+
+
+def _104_ungeladen(root: str) -> None:
+    schreib(os.path.join(_p(root, P104_SONDENTEILE), "teil99_sondenteil.py"),
+            '"""Ein Sondenteil, den der Einstieg nicht laedt."""\r\n')
+
+
+def _104_reihenfolge(root: str) -> None:
+    ersetze(_p(root, P104_SONDENLAUF),
+            ("    teil01_grundbestand_und_installation,\r\n    teil02_packs_mandat_mcp,\r\n",
+             "    teil02_packs_mandat_mcp,\r\n    teil01_grundbestand_und_installation,\r\n"))
+
+
+def _104_anker_verlieren(root: str) -> None:
+    ordner = _p(root, P104_SONDENTEILE)
+    teile = [n for n in os.listdir(ordner) if n.startswith("teil")]
+    if not teile:
+        raise Praeparationsfehler("Sonde 104e: kein Sondenteil unter sonden/")
+    for name in teile:
+        os.rename(os.path.join(ordner, name), os.path.join(ordner, "abschnitt" + name[4:]))
+
+
+def _104_hilfsfunktion(root: str) -> None:
+    pfad = _p(root, P104_WERKZEUGE)
+    schreib(pfad, lies(pfad) + "\r\n\r\ndef _check_hilfe(root: str) -> None:\r\n"
+                               "    return None\r\n")
+
+
+sonde("104a", "Eine Pruefung, die weder main noch eine andere Funktion des Pakets ruft, wird "
+              "gemeldet - sie liefe nie", _104_ungerufen, M104_UNGERUFEN)
+
+sonde("104b", "Eine Pruefung, die main zweimal ruft, wird gemeldet - sie meldete jeden "
+              "Befund doppelt", _104_zweimal, M104_ZWEIMAL)
+
+sonde("104c", "Ein Sondenteil, den der Einstieg nicht laedt, wird gemeldet - seine "
+              "Einheiten meldeten sich nie an", _104_ungeladen, M104_UNGELADEN)
+
+sonde("104d", "Sondenteile, die der Einstieg nicht in der Reihenfolge ihrer Nummer laedt, "
+              "werden gemeldet - die Reihenfolge ist die Abnahmeform", _104_reihenfolge,
+      M104_REIHENFOLGE)
+
+sonde("104e", "Ohne einen einzigen Sondenteil hat Pruefung 104 ihren Gegenstand verloren und "
+              "sagt es, statt leise zu bestehen", _104_anker_verlieren, M104_ANKER)
+
+gegenprobe("104a", "Eine Hilfsfunktion mit dem Praefix _check ist keine Pruefung und muss "
+                   "nicht gerufen werden", _104_hilfsfunktion, M104_MARKE)
+
+
+# --- Pruefung 105: die gepruefte Clientversion in der Zielspanne (D-482, K-40) ---------
+#
+# Die Sonden verstellen je eine Seite des Vergleichs: eine gehobene Spanne ohne Messung,
+# eine gemessene Version ausserhalb jeder Spanne, eine fehlende Zeile. Die Gegenproben
+# halten die zwei Grenzen, die der erste Entwurf nicht kannte: eine Nebenversion in der
+# Zelle der geprueften Version (kiro nennt seinen Agentenserver) und eine Spanne, die im
+# Fliesstext nur erwaehnt wird (devin-desktop: "ohne Messung gegen 3.10.x").
+P105_CLAUDE = ".koolie/core/clients/claude-code/CLIENT_PACK.md"
+P105_CODEX = ".koolie/core/clients/openai-codex/CLIENT_PACK.md"
+P105_CURSOR = ".koolie/core/clients/cursor/CLIENT_PACK.md"
+P105_KIRO = ".koolie/core/clients/kiro/CLIENT_PACK.md"
+M105_UNBELEGT = "die Zielspanne 2.2.x ist durch keine gepruefte Version belegt"
+M105_AUSSERHALB = "die gepruefte Clientversion 0.157.0 liegt in keiner Zielspanne"
+M105_ZEILE = "findet die Steckbriefzeile 'Geprüfte Clientversion' nicht"
+M105_MARKE = "(K-40, D-482)"
+
+
+def _105_spanne_gehoben(root: str) -> None:
+    ersetze(_p(root, P105_CLAUDE), ("| Verbindliche Zielversion | `2.1.x` (D-112).",
+                                    "| Verbindliche Zielversion | `2.2.x` (D-112)."))
+
+
+def _105_version_ausserhalb(root: str) -> None:
+    ersetze(_p(root, P105_CODEX), ("| Geprüfte Clientversion | `0.156.1` ",
+                                   "| Geprüfte Clientversion | `0.157.0` "))
+
+
+def _105_zeile_weg(root: str) -> None:
+    pfad = _p(root, P105_CURSOR)
+    zeilen = lies(pfad).split("\r\n")
+    behalten = [z for z in zeilen if not z.startswith("| Geprüfte Clientversion |")]
+    if len(behalten) != len(zeilen) - 1:
+        raise Praeparationsfehler("Sonde 105c: die Zeile der geprueften Version steht "
+                                  "%dmal im Pack" % (len(zeilen) - len(behalten)))
+    schreib(pfad, "\r\n".join(behalten))
+
+
+def _105_nebenversion(root: str) -> None:
+    ersetze(_p(root, P105_KIRO), ("installiert, **an keiner Sitzung gemessen**. Konto: Free |",
+                                  "installiert, **an keiner Sitzung gemessen**. Konto: Free; "
+                                  "Hilfsdienst `9.9.9` |"))
+
+
+sonde("105a", "Eine gehobene Zielspanne ohne gepruefte Version darin wird gemeldet - die "
+              "Spanne sagt mehr, als gemessen ist", _105_spanne_gehoben, M105_UNBELEGT)
+
+sonde("105b", "Eine gepruefte Version ausserhalb jeder Zielspanne wird gemeldet",
+      _105_version_ausserhalb, M105_AUSSERHALB)
+
+sonde("105c", "Ohne die Zeile der geprueften Version sagt Pruefung 105, dass sie das Pack "
+              "nicht haelt, statt leise zu bestehen", _105_zeile_weg, M105_ZEILE)
+
+gegenprobe("105a", "Eine weitere Version in der Zelle der geprueften Version, etwa ein "
+                   "Hilfsdienst, bleibt unbeanstandet", _105_nebenversion, M105_MARKE)
+
+gegenprobe("105b", "Eine Spanne, die im Fliesstext ohne Backticks erwaehnt wird, ist keine "
+                   "Zielspanne - das unveraenderte Pack devin-desktop bleibt unbeanstandet",
+           None, M105_MARKE)

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

@@ -0,0 +1,136 @@
+"""Sonden zu den Pruefungen 106 (Entscheidungsprotokoll des Schutz-Hooks) und 107
+(Gegenfaelle der Wirksamkeitsprobe), dazu die Erweiterung von Pruefung 26 um den Zustand
+'unerhoben' und das Verb mcp (1.20.0).
+
+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 ersetze, gegenprobe, P, sonde
+from .teil03_pruefungen_26_bis_36 import _manifest_aendern
+
+HOOK = ".koolie/core/tests/scripts/hook-check-secrets.py"
+WIRKSAMKEIT = ".koolie/core/wirksamkeit.py"
+
+
+def _p(root: str, rel: str) -> str:
+    return P(root, rel.replace("/", os.sep))
+
+
+# --- Pruefung 106: das Entscheidungsprotokoll (CR-2026-162, D-487, K-192) -----------
+#
+# Drei Sonden auf drei Zusagen: Es wird protokolliert, es wird kein Inhalt protokolliert,
+# und der Schalter im Overlay wirkt. Jede setzt am Hook selbst an, nicht an der Pruefung.
+M106_ZEILEN = "Zeile(n) statt 2"
+M106_INHALT = "traegt den Inhalt oder einen Pfadwert"
+M106_SCHALTER = "schaltet das Entscheidungsprotokoll des Schutz-Hooks nicht ab"
+M106_MARKE = "Pruefung 106"
+
+
+def _106_schweigt(root: str) -> None:
+    ersetze(_p(root, HOOK), ('    """Eine Zeile - nie der Inhalt, nie ein Pfadwert. Ein Fehler aendert nichts."""\r\n',
+                             '    """Eine Zeile - nie der Inhalt, nie ein Pfadwert. Ein Fehler aendert nichts."""\r\n'
+                             '    return\r\n'))
+
+
+def _106_inhalt(root: str) -> None:
+    ersetze(_p(root, HOOK), ('"ergebnis": ergebnis, "grund": erste[:200]}',
+                             '"ergebnis": ergebnis, "grund": erste[:200] + " " + '
+                             'json.dumps(_ENTSCHEIDUNG.get("eingabe"))}'),
+            ('    _ENTSCHEIDUNG["werkzeug"] = tool_name.strip().lower()[:120]\r\n',
+             '    _ENTSCHEIDUNG["werkzeug"] = tool_name.strip().lower()[:120]\r\n'
+             '    _ENTSCHEIDUNG["eingabe"] = tool_input\r\n'))
+
+
+def _106_schalter(root: str) -> None:
+    ersetze(_p(root, HOOK), ('    return not (m and m.group(1).lower() == "aus")\r\n',
+                             '    return True\r\n'))
+
+
+sonde("106a", "Ein Hook, der keine Entscheidung festhaelt, wird gemeldet - das Protokoll "
+              "bliebe leer", _106_schweigt, M106_ZEILEN)
+sonde("106b", "Ein Protokoll, das die Werkzeugeingabe mitschreibt, wird gemeldet - es "
+              "truege das Secret", _106_inhalt, M106_INHALT)
+sonde("106c", "Ein Hook, der den Schalter im Overlay-Manifest uebergeht, wird gemeldet",
+      _106_schalter, M106_SCHALTER)
+gegenprobe("106a", "Der ausgelieferte Hook haelt Entscheidungen fest, ohne Inhalt, und "
+                   "laesst sich abschalten", None, M106_MARKE)
+
+
+# --- Pruefung 107: die Gegenfaelle der Wirksamkeitsprobe (D-488, D-490, K-195) -------
+#
+# Die Sonde 107a baut genau den Fehler des Messapparats nach (D-490): Sie wertet Exit 2
+# als Sperre. Dann besteht ein Baum ohne Hook-Skript - und das muss auffallen.
+M107_EXIT = "besteht einen Baum ohne Hook-Skript"
+M107_MATCHER = "erkennt einen Matcher ohne die Werkzeugklasse mcp nicht"
+M107_LADEN = "Die Wirksamkeitsprobe laesst sich nicht laden"
+M107_MARKE = "Pruefung 107"
+
+
+def _107_exitcode(root: str) -> None:
+    ersetze(_p(root, WIRKSAMKEIT), ("        if SPERRHINWEIS not in aus:\r\n",
+                                    "        if code != 2:\r\n"),
+            ("    if code != 0 or SPERRHINWEIS in aus:\r\n",
+             "    if code not in (0, 2):\r\n"))
+
+
+def _107_matcher(root: str) -> None:
+    ersetze(_p(root, WIRKSAMKEIT), ("        if not treffer:\r\n", "        if False:\r\n"))
+
+
+def _107_kaputt(root: str) -> None:
+    ersetze(_p(root, WIRKSAMKEIT), ("MUSS, WARNUNG, UNERHOBEN, OK = ",
+                                    "MUSS, WARNUNG, UNERHOBEN, OK = = "))
+
+
+sonde("107a", "Eine Probe, die Exit 2 als Sperre wertet, besteht einen Baum ohne Hook und "
+              "wird gemeldet", _107_exitcode, M107_EXIT)
+sonde("107b", "Eine Probe, die den Matcher nicht gegen die Werkzeugklassen haelt, wird "
+              "gemeldet", _107_matcher, M107_MATCHER)
+sonde("107c", "Eine Probe, die sich nicht laden laesst, wird gemeldet - install.py --probe "
+              "liefe nicht", _107_kaputt, M107_LADEN)
+gegenprobe("107a", "Die ausgelieferte Probe besteht den intakten Baum und faellt an beiden "
+                   "Gegenfaellen", None, M107_MARKE)
+
+
+# --- Pruefung 26, seit 1.20.0: 'unerhoben' und das Verb mcp (D-486, K-184) -----------
+M26_NOTIZ = "_hook_tools_unerhoben_note fehlt oder ist leer"
+M26_BEIDES = "gemessen oder nicht, beides geht nicht"
+M26_PAAR = "stehen nur zusammen"
+M26_PRAEFIX = "Kein Matcher in hook_tools.mcp trifft"
+
+
+def _26_ohne_notiz(root: str) -> None:
+    _manifest_aendern(root, "kiro", lambda m: m.pop("_hook_tools_unerhoben_note"))
+
+
+def _26_beides(root: str) -> None:
+    def f(m):
+        m["hook_tools"]["mcp"] = ["mcp_.*"]
+        m["hook_mcp_prefixes"] = ["mcp_"]
+    _manifest_aendern(root, "kiro", f)
+
+
+def _26_ohne_praefix(root: str) -> None:
+    _manifest_aendern(root, "claude-code", lambda m: m.pop("hook_mcp_prefixes"))
+
+
+def _26_praefix_verfehlt(root: str) -> None:
+    _manifest_aendern(root, "claude-code", lambda m: m.__setitem__("hook_mcp_prefixes",
+                                                                   ["werkzeug:"]))
+
+
+sonde("26", "Ein ungemessenes Verb ohne Begruendung wird gemeldet - wie eine erklaerte "
+            "Abwesenheit", _26_ohne_notiz, M26_NOTIZ)
+sonde("26", "Ein Verb, das zugleich unerhoben und abgebildet ist, wird gemeldet",
+      _26_beides, M26_BEIDES)
+sonde("26", "Ein MCP-Matcher ohne Praefix fuer den Hook wird gemeldet - der Hook erkennte "
+            "das Werkzeug nicht", _26_ohne_praefix, M26_PAAR)
+sonde("26", "Ein Praefix, das kein MCP-Matcher trifft, wird gemeldet - der Hook liefe nie "
+            "an", _26_praefix_verfehlt, M26_PRAEFIX)
+gegenprobe("26", "Die ausgelieferten Manifeste fuehren unerhoben und mcp folgerichtig",
+           None, "hook_mcp_prefixes")

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

@@ -0,0 +1,150 @@
+"""Sonden zur Pfad- und Mustersemantik (1.20.1): die zweite Lesart der POSIX-Schreibweise
+im Schutz-Hook (Pruefung 32, K-96), die Schreibsperren der CI- und Quality-Gate-Pfade
+(Pruefung 89, K-35) und ein allow-Befehl, der ein deny-Praefix umschliesst (Pruefung 108,
+K-47).
+
+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
+
+from .apparat import (
+    aufraeumen, buendel, ersetze, gegenprobe, installation, lies, melde, notiz, P,
+    Praeparationsfehler, schreib, sonde, strict_ausgabe, validator_ausgabe)
+from .teil07_overlay_und_lieferung import _89_fuellen, _89_pfade, _89_voll
+
+HOOK = ".koolie/core/tests/scripts/hook-check-secrets.py"
+KERNQUELLE = ".koolie/core/framework/runtime/permissions.json"
+
+
+def _p(root: str, rel: str) -> str:
+    return P(root, rel.replace("/", os.sep))
+
+
+# --- Pruefung 32, seit 1.20.1: die zweite Lesart von /c/... (CR-2026-163, D-491, K-96) --
+#
+# Die Sonde nimmt dem Hook die zweite Lesart und laesst ihm nur die, die Python waehlt:
+# /c/ als C:\c\. Dann geht die POSIX-Schreibweise mit Punktsegment in den Kern durch -
+# genau der Stand bis 1.20.0. Nur unter Windows messbar; der Sondenlauf laeuft dort.
+M32_LESART = "der Hook muss beide Lesarten aufloesen"
+
+
+def _32_eine_lesart(root: str) -> None:
+    ersetze(_p(root, HOOK), ("    if not m:\r\n        return [echt]\r\n",
+                             "    if True:\r\n        return [echt]\r\n"))
+
+
+sonde("32", "Ein Hook, der /c/... nur als C:\\c\\... liest, laesst die POSIX-Schreibweise "
+            "in den Kern schreiben und wird gemeldet", _32_eine_lesart, M32_LESART)
+gegenprobe("32", "Der ausgelieferte Hook loest beide Lesarten auf", None, M32_LESART)
+
+
+# --- Pruefung 108: allow umschliesst ein deny-Praefix (CR-2026-163, D-494, K-47) -----
+#
+# An der Kernquelle: ein allow-Befehl 'git' neben den deny-Befehlen 'git push' und
+# 'git merge' - der gemessene Zuschnitt aus D-123.
+M108 = "umschließt"
+
+
+def _108_kernquelle(root: str) -> None:
+    ersetze(_p(root, KERNQUELLE), ('    { "tool": "exec",   "command": "git status" },\r\n',
+                                   '    { "tool": "exec",   "command": "git status" },\r\n'
+                                   '    { "tool": "exec",   "command": "git" },\r\n'))
+
+
+sonde("108", "Ein allow-Befehl git in der Kernquelle umschliesst das deny-Praefix git push "
+             "und wird gemeldet", _108_kernquelle, M108)
+gegenprobe("108", "Die ausgelieferte Kernquelle fuehrt keinen allow-Befehl, der ein "
+                  "deny-Praefix umschliesst", None, M108)
+
+
+def _108_korb(root: str, zusatz: list) -> None:
+    pfad = os.path.join(root, ".claude", "settings.json")
+    cfg = json.loads(lies(pfad))
+    if "Bash(git push:*)" not in cfg["permissions"]["deny"]:
+        raise Praeparationsfehler("settings.json: Bash(git push:*) steht nicht im deny-Korb")
+    cfg["permissions"]["allow"] = cfg["permissions"]["allow"] + zusatz
+    schreib(pfad, json.dumps(cfg, ensure_ascii=False, indent=2))
+
+
+def sonden_allow_umschliesst_deny() -> None:
+    """Pruefung 108 an einer claude-code-Installation: der installierte Korb."""
+    root = installation("claude-code")
+    try:
+        melde("GEGENPROBE", "108a", M108 not in validator_ausgabe(root),
+              "Eine frische Installation fuehrt keinen allow-Eintrag, der ein deny-Praefix "
+              "umschliesst")
+        urstand = lies(os.path.join(root, ".claude", "settings.json"))
+        _108_korb(root, ["Bash(git:*)"])
+        aus = validator_ausgabe(root)
+        melde("SONDE", "108b", "Bash(git:*) im allow-Korb umschließt" in aus,
+              "Bash(git:*) im allow-Korb umschliesst Bash(git push:*) - der gemessene "
+              "Zuschnitt aus D-123")
+        schreib(os.path.join(root, ".claude", "settings.json"), urstand)
+        _108_korb(root, ["Bash(git pus:*)"])
+        melde("GEGENPROBE", "108c", M108 not in validator_ausgabe(root),
+              "Ein Praefix, das an keiner Wortgrenze endet (git pus), umschliesst git push "
+              "nicht")
+    finally:
+        aufraeumen(os.path.dirname(root))
+
+
+buendel(sonden_allow_umschliesst_deny,
+        "Pruefung 108 am installierten Korb von claude-code: eine Sonde, zwei Gegenproben")
+
+
+# --- Pruefung 89, seit 1.20.1: CI- und Quality-Gate-Pfade (CR-2026-163, D-493, K-35) --
+#
+# Die Quelle fuellt beide Schlitze mit je zwei Globs; der deny-Korb traegt sie entfaltet
+# (so schreibt es install.py). Die Sonde laesst einen Glob weg - der zu eng gefuellte
+# Schlitz, die stille Lockerung.
+P89_CI = [".gitlab-ci.yml", ".github/workflows/**"]
+P89_QG = [".eslintrc.json", "sonar-project.properties"]
+M89_CI = "Ein zu eng gefüllter Schlitz ist eine stille Lockerung"
+
+
+def _89_sperrschlitze(root: str, ci: list, qg: list) -> None:
+    quelle, laufzeit, korb = _89_voll()
+    quelle["<CI_CONFIG_PATHS>"] = ", ".join("`%s`" % g for g in P89_CI)
+    quelle["<QUALITY_GATE_CONFIG_PATHS>"] = ", ".join("`%s`" % g for g in P89_QG)
+    _89_fuellen(root, quelle, laufzeit, korb)
+    _, _, k_pfad = _89_pfade(root)
+    cfg = json.loads(lies(k_pfad))
+    deny = cfg["permissions"]["deny"]
+    for schlitz in ("<CI_CONFIG_PATHS>", "<QUALITY_GATE_CONFIG_PATHS>"):
+        if sum(schlitz in r for r in deny) < 1:
+            raise Praeparationsfehler("settings.json: der Schlitz %s steht nicht im "
+                                      "deny-Korb" % schlitz)
+    deny = [r for r in deny if "<CI_CONFIG_PATHS>" not in r
+            and "<QUALITY_GATE_CONFIG_PATHS>" not in r]
+    cfg["permissions"]["deny"] = deny + ["Edit(%s)" % g for g in ci + qg]
+    schreib(k_pfad, json.dumps(cfg, ensure_ascii=False, indent=2))
+
+
+def sonden_sperrschlitze() -> None:
+    """Pruefung 89 (c) fuer <CI_CONFIG_PATHS> und <QUALITY_GATE_CONFIG_PATHS>."""
+    root = installation("claude-code")
+    try:
+        _89_sperrschlitze(root, P89_CI, P89_QG)
+        aus = strict_ausgabe(root)
+        melde("GEGENPROBE", "89e", M89_CI not in aus,
+              "Beide Schlitze gefuellt, jeder Glob mit eigener Schreibsperre - "
+              "unbeanstandet")
+        if M89_CI in aus:
+            notiz("        gemeldet: %s" % [z for z in aus.splitlines() if M89_CI in z][:2])
+        _89_sperrschlitze(root, P89_CI[:1], P89_QG)
+        aus = strict_ausgabe(root)
+        melde("SONDE", "89f", M89_CI in aus and ".github/workflows/**" in aus,
+              "Ein CI-Glob der Quelle ohne Schreibsperre im deny-Korb wird gemeldet - der "
+              "zu eng gefuellte Schlitz")
+    finally:
+        aufraeumen(os.path.dirname(root))
+
+
+buendel(sonden_sperrschlitze,
+        "Pruefung 89 (c) fuer die CI- und Quality-Gate-Pfade an einer claude-code-"
+        "Installation: eine Gegenprobe, eine Sonde")

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

@@ -0,0 +1,204 @@
+"""Sonden zu Modi, Ausnahmen und eingebauten Skills (1.20.2): die Modusbindung am
+Schutz-Hook und ihr Schutz (Pruefung 99, K-179), die Sperre fuer das Hochladen von
+Secrets in der Wirksamkeitsprobe (Pruefung 107, K-94), die beiden Werkzeugfelder eines
+Skills (Pruefung 109, K-93) und die aktivierten Packs gegen die Regelablage (Pruefung 110,
+K-44).
+
+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 datetime
+import json
+import os
+import shutil
+import subprocess
+import sys
+
+from .apparat import (
+    aufraeumen, buendel, ersetze, gegenprobe, installation, lies, melde, P,
+    Praeparationsfehler, schreib, sonde, strict_ausgabe, unterprozess)
+
+HOOK = ".koolie/core/tests/scripts/hook-check-secrets.py"
+SKILL_109 = ".koolie/core/framework/skills/fw-code-explain/SKILL.md"
+
+
+def _p(root: str, rel: str) -> str:
+    return P(root, rel.replace("/", os.sep))
+
+
+# --- Pruefung 99, seit 1.20.2: die Modusdatei ist fuer den Client gesperrt (D-501) ----
+M99_MODUS = "Schreiben der Modusdatei endet mit Exit 0"
+
+
+def _99_modus_offen(root: str) -> None:
+    ersetze(_p(root, HOOK), ('    re.compile(r"koolie-modus", re.I),\r\n', ""))
+
+
+sonde("99e", "Ein Hook, der die Modusdatei nicht sperrt, liesse den Client seine "
+            "Modusbindung selbst aufheben und wird gemeldet", _99_modus_offen, M99_MODUS)
+
+
+# --- Pruefung 107, seit 1.20.2: die Probe sperrt das Hochladen von Secrets (D-503) ----
+M107_INTAKT = "meldet an einem intakten Baum fehlende"
+
+
+def _107_ohne_uebertragung(root: str) -> None:
+    ersetze(_p(root, HOOK), ('    re.compile(r"\\bcloud\\s+drs\\s+secret-create\\b", re.I),\r\n',
+                             ""))
+
+
+sonde("107d", "Ein Hook ohne die Sperre fuer 'cloud drs secret-create' faellt in der "
+             "Wirksamkeitsprobe durch (H3) und wird gemeldet", _107_ohne_uebertragung,
+      M107_INTAKT)
+
+
+# --- Pruefung 109: die beiden Werkzeugfelder eines Skills (CR-2026-164, D-505, K-93) --
+M109 = "Die Werkzeugbeschränkung eines Skills wirkt nur mit beiden Feldern"
+
+
+def _109_nur_allowed(root: str) -> None:
+    ersetze(_p(root, SKILL_109), ("permissions:\r\n  deny:\r\n    - edit\r\n    - exec\r\n", ""))
+
+
+sonde("109", "Ein Kern-Skill mit allowed-tools, aber ohne permissions wird gemeldet",
+      _109_nur_allowed, M109)
+gegenprobe("109", "Alle ausgelieferten Skills fuehren beide Werkzeugfelder", None, M109)
+
+
+# --- Pruefung 110: die aktivierten Packs gegen die Regelablage (CR-2026-164, D-504, K-44)
+M110_FEHLT = "die Ebene dieses Packs lädt in keiner Sitzung"
+M110_OHNE = "aktiviert wird ein Pack im Overlay"
+ROLLE = "software-development"
+
+
+def _110_zeile(root: str, wert: str) -> None:
+    ov = os.path.join(root, ".koolie", "project-overlay", "OVERLAY.md")
+    text = lies(ov)
+    alt = "`<TBD: Liste, z. B. software-development Version, oder keine>`"
+    if text.count(alt) != 1:
+        raise Praeparationsfehler("OVERLAY.md: die Zeile 'Aktivierte Role Packs' traegt "
+                                  "nicht genau einmal den Ausfuellschlitz der Vorlage")
+    schreib(ov, text.replace(alt, wert))
+
+
+def sonden_aktivierte_packs() -> None:
+    """Pruefung 110 an einer claude-code-Installation: Zeile gegen Laufzeitfassung."""
+    root = installation("claude-code")
+    try:
+        aus = strict_ausgabe(root)
+        melde("GEGENPROBE", "110a", M110_FEHLT not in aus and M110_OHNE not in aus,
+              "Eine frische Installation (Zeile noch mit <TBD>, keine Laufzeitfassung) - "
+              "unbeanstandet")
+        urstand = lies(os.path.join(root, ".koolie", "project-overlay", "OVERLAY.md"))
+        _110_zeile(root, "`%s` 0.1.1" % ROLLE)
+        aus = strict_ausgabe(root)
+        melde("SONDE", "110b", M110_FEHLT in aus and ROLLE in aus,
+              "Das Overlay fuehrt ein Role Pack als aktiviert, die Laufzeitfassung fehlt - "
+              "die Ebene 6 ginge still verloren")
+        quelle = os.path.join(root, ".koolie", "core", "framework", "role-packs", ROLLE,
+                              "runtime", "30-role-%s.md" % ROLLE)
+        ziel = os.path.join(root, ".claude", "rules", "30-role-%s.md" % ROLLE)
+        if not os.path.isfile(quelle):
+            raise Praeparationsfehler("Die Laufzeitfassung des Role Packs %s fehlt im Kern"
+                                      % ROLLE)
+        shutil.copyfile(quelle, ziel)
+        aus = strict_ausgabe(root)
+        melde("GEGENPROBE", "110c", M110_FEHLT not in aus and M110_OHNE not in aus,
+              "Genannt und vorhanden - unbeanstandet")
+        schreib(os.path.join(root, ".koolie", "project-overlay", "OVERLAY.md"), urstand)
+        _110_zeile(root, "`keine`")
+        aus = strict_ausgabe(root)
+        melde("SONDE", "110d", M110_OHNE in aus,
+              "Eine Laufzeitfassung, die das Overlay nicht als aktiviert fuehrt, wird "
+              "gemeldet")
+    finally:
+        aufraeumen(os.path.dirname(root))
+
+
+buendel(sonden_aktivierte_packs,
+        "Pruefung 110 an einer claude-code-Installation: zwei Gegenproben, zwei Sonden")
+
+
+# --- Die Modusbindung am Schutz-Hook (CR-2026-164, D-501, K-179) --------------------
+def _hook(root: str, ereignis: dict) -> int:
+    skript = os.path.join(root, ".koolie", "core", "tests", "scripts", "hook-check-secrets.py")
+    p = subprocess.run([sys.executable, skript, "--fail-closed"],
+                       input=json.dumps(ereignis).encode("utf-8"), capture_output=True,
+                       timeout=60, cwd=root)
+    return p.returncode
+
+
+def _modus_setzen(root: str, modus: str, ablage: str = "", minuten: int = 30,
+                  projekt: str = "") -> None:
+    ende = (datetime.datetime.now(datetime.timezone.utc).replace(tzinfo=None)
+            + datetime.timedelta(minutes=minuten))
+    daten = {"modus": modus, "bis": ende.strftime("%Y-%m-%dT%H:%M:%SZ"),
+             "projekt": projekt or os.path.realpath(root)}
+    if ablage:
+        daten["ablage"] = ablage
+    schreib(os.path.join(root, ".git", "koolie-modus.json"), json.dumps(daten))
+
+
+def _schreiben(pfad: str) -> dict:
+    return {"tool_name": "write", "tool_input": {"file_path": pfad, "content": "x"}}
+
+
+def sonden_modusbindung() -> None:
+    """Die Modusbindung an einer echten Installation: sie sperrt, was sie soll, und nichts
+    sonst; die Sperre fuer das Hochladen von Secrets gilt unabhaengig davon."""
+    root = installation("devin-desktop")
+    try:
+        os.makedirs(os.path.join(root, ".git"))
+        quelle, plan = _schreiben("src/Neu.java"), _schreiben("docs/plaene/plan.md")
+        melde("GEGENPROBE", "D501", _hook(root, quelle) == 0,
+              "Ohne Bindung schreibt der Client wie bisher")
+        _modus_setzen(root, "M1")
+        melde("SONDE", "D501a", _hook(root, quelle) == 2 and _hook(root, plan) == 2,
+              "M1 gebunden: jedes Schreibwerkzeug wird gesperrt")
+        _modus_setzen(root, "M2", "docs/plaene")
+        melde("SONDE", "D501b", _hook(root, quelle) == 2 and _hook(root, plan) == 0,
+              "M2 gebunden: nur die Plan-Ablage ist offen")
+        melde("SONDE", "D501c", _hook(root, _schreiben("docs/plaene/../../src/X.java")) == 2
+              and _hook(root, _schreiben("docs/plaene2/x.md")) == 2,
+              "Ein Punktsegment und ein Namensvetter der Ablage fuehren nicht hinein")
+        melde("GEGENPROBE", "D501d", _hook(root, {"tool_name": "exec", "tool_input": {
+            "command": "git status"}}) == 0,
+              "Ein lesender Befehl bleibt in M2 erlaubt")
+        _modus_setzen(root, "M1", minuten=-5)
+        melde("GEGENPROBE", "D501e", _hook(root, quelle) == 0,
+              "Eine abgelaufene Bindung sperrt nichts mehr")
+        _modus_setzen(root, "M1", projekt=os.path.dirname(root))
+        melde("GEGENPROBE", "D501f", _hook(root, quelle) == 0,
+              "Die Bindung eines anderen Projekts gilt hier nicht")
+        _modus_setzen(root, "M2", ".koolie/project-overlay")
+        melde("GEGENPROBE", "D501g", _hook(root, quelle) == 0,
+              "Eine Plan-Ablage in .koolie/ macht die Bindung ungueltig - der Hook liest "
+              "sie nicht")
+        os.remove(os.path.join(root, ".git", "koolie-modus.json"))
+        mandat = os.path.join(root, ".koolie", "core", "mandat.py")
+        p = unterprozess([sys.executable, mandat, "modus", "M2", "--ablage", ".koolie/x"])
+        melde("SONDE", "D501h", p.returncode == 2 and not os.path.exists(
+            os.path.join(root, ".git", "koolie-modus.json")),
+              "mandat.py lehnt eine Plan-Ablage in .koolie/ ab und schreibt nichts")
+        p = unterprozess([sys.executable, mandat, "modus", "M2", "--ablage", "docs/plaene",
+                          "--minuten", "5"])
+        melde("GEGENPROBE", "D501i", p.returncode == 0 and _hook(root, plan) == 0
+              and _hook(root, quelle) == 2,
+              "mandat.py modus M2 bindet, und der Hook liest die Bindung")
+        p = unterprozess([sys.executable, mandat, "modus", "aus"])
+        melde("GEGENPROBE", "D501j", _hook(root, quelle) == 0,
+              "mandat.py modus aus hebt die Bindung auf")
+        melde("SONDE", "D503", _hook(root, {"tool_name": "exec", "tool_input": {
+            "command": "devin cloud drs secret-create --from-env X --dry-run"}}) == 2,
+              "Das Hochladen von Secrets ueber die CLI wird gesperrt, auch als Probelauf")
+    finally:
+        aufraeumen(os.path.dirname(root))
+
+
+buendel(sonden_modusbindung,
+        "Die Modusbindung fuer M1 und M2 an einer devin-desktop-Installation: Sperre, "
+        "Ablage, Ausbruch, Ablauf, fremdes Projekt, mandat.py, und die Sperre fuer das "
+        "Hochladen von Secrets")