@renoxar/koolie 1.25.0

package/.koolie/core/clientmap.py

@@ -0,0 +1,1358 @@
+#!/usr/bin/env python3
+"""
+clientmap.py - Semantikabbildung der Berechtigungs- und Hook-Konfiguration.
+
+Alle uebrigen Laufzeitartefakte unterscheiden sich zwischen zwei Client Packs nur in
+der Form: ein Frontmatter-Feld heisst anders, eine Werkzeugliste ist kommagetrennt
+statt eingerueckt. Berechtigungen und Hooks sind der Fall darueber hinaus. Hier
+unterscheiden sich die Werkzeugnamen selbst, ein Client trennt Aendern und Anlegen in
+zwei Werkzeuge, und Befehlsverbote greifen bei dem einen woertlich, bei dem anderen
+ueber ein Praefix. Eine reine Formtransformation wuerde das nicht tragen.
+
+Die Regelmenge ist Framework-Gut (Ebene 3) und liegt deshalb einmal unter
+framework/runtime/permissions.json und framework/runtime/hooks.json. Wie sie beim
+jeweiligen Client aussieht, steht in clients/<pack>/manifest.json.
+
+Weil an dieser Abbildung die Kernzusagen B1 bis B6 haengen, erzwingt dieses Modul drei
+Zusicherungen, statt sie nur zu behaupten:
+
+  1. Eine deny- oder ask-Regel, fuer die ein Client kein Werkzeug kennt, ist ein
+     Fehler. Sie stillschweigend wegzulassen waere eine Lockerung. Bei allow ist das
+     Weglassen zulaessig - es faellt dann auf den strengeren Standard zurueck.
+  2. Die Praefixform eines Befehlsverbots muss ein Praefix seiner woertlichen Form
+     sein. Damit ist die Praefixform nachweislich mindestens so breit; die Abweichung
+     ist eine Verschaerfung und keine Luecke.
+  3. Bei allow ist jede Verbreiterung unzulaessig: dort muessen beide Formen
+     uebereinstimmen.
+  4. Ein Werkzeugverb des Frontmatters, das ein Pack weder abbildet noch ausdruecklich
+     als nicht abgebildet deklariert, ist ein Fehler. Bis 0.39.0 wurde es woertlich
+     durchgereicht und fiel in permissions.deny lautlos aus (D-78).
+
+_core_rules_integrity.deny_must_contain wird aus denselben Quellregeln erzeugt
+(Kennzeichnung "core": true). Der Validator vergleicht die installierte Datei damit -
+eine geloeschte Kernregel faellt dadurch auf, auch wenn das Projekt zugleich die
+Integritaetsliste gekuerzt hat.
+
+Seit 0.26.0 traegt die Berechtigungsdatei zusaetzlich die Importsteuerung des Clients
+(D-37): Das Framework importiert keine Regel- und Skillquellen fremder Werkzeugformate.
+Das Manifest fuehrt sie unter "import_control" als Schluessel und Wert; kennt ein Client
+keinen solchen Mechanismus, fehlt das Feld und es bleibt bei der Auskunft im Client Pack.
+Die Masznahme ist ein Standard, keine Schranke - die Benutzerkonfiguration hat Vorrang
+(K-27 gemessen 2026-09-11). Pruefung 22 haelt die Abbildung fest, nicht ihre Wirkung.
+"""
+from __future__ import annotations
+
+import json
+import os
+import subprocess
+
+
+class AbbildungsFehler(ValueError):
+    """Die Quellregeln lassen sich nicht verlustfrei auf diesen Client abbilden."""
+
+
+# ---------------------------------------------------------------------------
+# Platzhalter
+# ---------------------------------------------------------------------------
+
+def resolve_placeholders(text: str, man: dict) -> str:
+    """Loest die Laufzeit-Platzhalter des Kerns in die Pfade dieses Client Packs auf.
+
+    Projektplatzhalter (<EXCLUDED_PATHS>, <TEST_COMMAND>, ...) bleiben unberuehrt - die
+    fuellt der Overlay Owner. Hier werden nur die Platzhalter aufgeloest, deren Wert
+    vom Client abhaengt und die deshalb im Manifest stehen.
+    """
+    for platzhalter, pfad in man.get("runtime_placeholders", {}).items():
+        text = text.replace(platzhalter, pfad)
+    return text
+
+
+# ---------------------------------------------------------------------------
+# DIE LAGE DES KERNS UNTER DER PROJEKTWURZEL - ZWEI SEGMENTE SEIT 0.88.0
+# ---------------------------------------------------------------------------
+# Bis 0.87.0 hiess der Kern `leitwerk-core` und war EIN Verzeichnissegment. Vier
+# Werkzeuge haben <CORE_DIR> deshalb mit os.path.basename() aus dem eigenen Ort
+# gebunden - und genau dort steht in install.py der Satz, das stehe dort, "damit
+# eine spaetere Umbenennung nur eine Stelle beruehrt".
+#
+# Mit `.koolie/core` liefert os.path.basename() den Wert "core". Jede gerendete
+# Regeldatei truege dann einen Pfad, den es nicht gibt - und der Validator saehe
+# es nicht, weil er denselben falschen Wert bindet (D-299).
+#
+# Deshalb steht die Lage hier als ZEICHENKETTE und wird nicht abgeleitet. Wer den
+# Kern woanders hinlegt, bricht ohnehin die Hook-Kommandos und die Pruefungen 45,
+# 59 und 75; ein Wert, der sich still anpasst, verdeckt das nur.
+CORE_REL = ".koolie/core"
+#: Wieviele Verzeichnisebenen zwischen Kern und Projektwurzel liegen.
+CORE_TIEFE = CORE_REL.count("/") + 1
+
+
+def projektwurzel(kern: str) -> str:
+    """Die Projektwurzel aus dem Pfad des Kerns - ueber CORE_TIEFE, nicht ueber
+    eine im Quelltext gezaehlte Zahl von dirname-Aufrufen."""
+    pfad = os.path.abspath(kern)
+    for _ in range(CORE_TIEFE):
+        pfad = os.path.dirname(pfad)
+    return pfad
+
+
+def core_dir_name(man: dict) -> str:
+    return man.get("runtime_placeholders", {}).get("<CORE_DIR>", CORE_REL)
+
+
+# ---------------------------------------------------------------------------
+# DER LIEFERUMFANG EINER INSTALLATION (D-367, CR-2026-141)
+# ---------------------------------------------------------------------------
+# Ein Projekt waehlt beim Installieren den ganzen Kern ("voll") oder nur das zur
+# Nutzung Noetige ("nutzung"). Die Liste des Noetigen wird NICHT aufgezaehlt - sie
+# fehlte nach dem ersten neuen Traeger (D-366). Aufgezaehlt ist das Gegenteil, und es
+# ist nach seinem ABLAGEORT geschlossen: die Nachweisschicht aus Aenderungsantraegen,
+# Abnahmeprotokollen, Erhebungen und dem Bau des Hauptdokuments. Ein neuer Traeger zur
+# Nutzung ist damit von selbst dabei, ein neuer Nachweis von selbst draussen.
+#
+# ZWEI ABLEITUNGEN SIND GEMESSEN GESCHEITERT (2026-09-25, sechs frische
+# Installationen): Die Lesespur taugt nicht - der Validator liest im Projekt alle 549
+# Kerndateien. Die transitive Verweishuelle taugt nicht - mit Verzeichnisverweisen
+# umfasst sie alles, ohne sie behaelt sie 39 Protokolle und verliert die Skillquellen,
+# die --update braucht. OB die Nutzung ohne die Nachweisschicht auskommt, entscheidet
+# deshalb der Validator an einer reduzierten Installation (Sonde L367).
+#
+# Die Wahl steht im Projekt in LIEFERUMFANG neben VERSION; install.py schreibt sie bei
+# jedem --target. Fehlt die Datei, gilt "voll" - so liegt jede Installation vor 1.8.0.
+LIEFERUMFANG_DATEI = "LIEFERUMFANG"
+LIEFERUMFAENGE = ("voll", "nutzung")
+NACHWEIS_ABLAGEN = (
+    "governance/change-requests",
+    "tests/protocols",
+    "tests/erhebungen",
+    "build",
+)
+
+
+def ist_nachweis(rel: str) -> bool:
+    """Liegt der Pfad (relativ zum Kern, mit Schraegstrichen) in der Nachweisschicht?"""
+    return any(rel == a or rel.startswith(a + "/") for a in NACHWEIS_ABLAGEN)
+
+
+def lieferumfang(kern: str) -> str:
+    """Der Lieferumfang, den der Kern unter diesem Pfad fuehrt - roh gelesen.
+
+    Ohne Datei "voll". Einen unbekannten Wert gibt die Funktion unveraendert zurueck;
+    ihn zu melden ist Sache des Aufrufers (Pruefung 90, install.py).
+    """
+    try:
+        with open(os.path.join(kern, LIEFERUMFANG_DATEI), encoding="utf-8") as fh:
+            return fh.read().strip()
+    except OSError:
+        return "voll"
+
+# ---------------------------------------------------------------------------
+# Werkzeugverben des Frontmatters
+# ---------------------------------------------------------------------------
+
+# Das Vokabular, das ein Skill oder ein Agentenprofil des Kerns in seinem Frontmatter
+# schreiben darf - in allowed-tools wie in permissions.deny. Es steht hier und nicht in
+# install.py, weil drei Stellen es brauchen: die Abbildung beim Installieren, die
+# Abbildung von permissions.deny auf die Werkzeugsperre je Skill (D-65) und Pruefung 38.
+#
+# WARUM ES UEBERHAUPT EINES BRAUCHT. Bis 0.39.0 hatte die Quelle kein deklariertes
+# Vokabular, und der unbekannte Fall war an beiden Stellen STILL - gemessen am
+# 2026-09-13 (tests/protocols/2026-09-13-gegenpruefung-werkzeugabbildung.md):
+#   * allowed-tools: ein Verb ohne Abbildung wurde WOERTLICH durchgereicht. Aus
+#     'allowed-tools: banane' wurde in der installierten Fassung der Werkzeugname
+#     'banane'; aus einer geleerten Abbildung wurde 'tools: read, grep, glob' im
+#     Agentenprofil fw-reviewer - drei Namen, die dieser Client nicht kennt (M16).
+#   * permissions.deny: dasselbe Verb fiel lautlos ganz aus. 'deny: glob' erzeugte
+#     keine Werkzeugsperre, und der Validator meldete 0 Fehler (M6).
+# Die drei uebrigen Werkzeugabbildungen desselben Manifests - hook_tools,
+# permission_tools und der Hook-Matcher - brechen im selben Fall ab (M17 bis M19).
+# Diese eine war die unbewachte, und sie kommt zweimal vor.
+FRONTMATTER_VERBEN = ("read", "grep", "glob", "edit", "exec")
+
+# Die Bruecke zwischen dem Vokabular der Quelle und dem der Durchsetzungsschichten
+# (hook_tools, permission_tools, framework/runtime/*.json). Die beiden Vokabulare sind
+# getrennt gewachsen und nicht deckungsgleich: Die Quelle trennt das Suchen in 'grep'
+# und 'glob', die Durchsetzung fasst beides als 'search'; die Quelle sagt 'edit', die
+# Durchsetzung 'write'.
+#
+# DIE BRUECKE WIRD BEWACHT, NICHT AUFGELOEST (D-78). Die beiden Listen gleichzuziehen
+# hiesse, eine der Seiten zu aendern - und die Vorabfreigabe auf die Sperrliste zu heben
+# waere eine AUSWEITUNG: Aus 'allowed-tools: Edit, Write' wuerde 'Edit, Write,
+# NotebookEdit'. Verlangt wird deshalb allein die RICHTUNG: Die Sperrliste darf fuer
+# kein Verbpaar enger sein als die Vorabfreigabe. Heute ist sie es bei keinem
+# (gemessen, M4); Pruefung 38 haelt es fest.
+VERB_BRUECKE = {"read": "read", "grep": "search", "glob": "search",
+                "edit": "write", "exec": "exec"}
+
+
+def frontmatter_werkzeuge(man: dict, block: str, verb: str) -> list[str]:
+    """Die Werkzeugnamen dieses Clients fuer ein Verb aus dem Frontmatter der Quelle.
+
+    `block` ist "skill_frontmatter" oder "agent_frontmatter" - die beiden Stellen, an
+    denen dasselbe Vokabular abgebildet wird.
+
+    Drei Ausgaenge, und keiner davon ist still:
+
+      * in tool_names abgebildet -> die Werkzeugnamen dieses Clients;
+      * in tool_names_unmapped deklariert -> das Verb unveraendert. Ein Client, dessen
+        Frontmatter die Verben selbst als Werkzeugnamen fuehrt - oder fuer den das
+        unerhoben ist -, sagt das ausdruecklich. Bauform wie hook_tools_absent nach
+        D-47: Eine Abwesenheit wird erklaert, nie aus einer Luecke erraten;
+      * weder noch -> AbbildungsFehler.
+
+    Der dritte Ausgang ist die Aenderung gegenueber 0.39.0. Dort reichte derselbe Fall
+    das Verb woertlich durch, und niemand erfuhr davon.
+    """
+    if verb not in FRONTMATTER_VERBEN:
+        raise AbbildungsFehler(
+            f"{man.get('client', '?')}: Das Werkzeugverb '{verb}' gehoert nicht zum "
+            f"Vokabular des Frontmatters {list(FRONTMATTER_VERBEN)}. Ein Skill oder "
+            f"Agentenprofil des Kerns nennt nur diese Verben - alles andere ist ein "
+            f"Schreibfehler oder ein Verb der Durchsetzungsschicht, das hier nicht "
+            f"hingehoert (D-78)")
+    fmt = man.get(block) or {}
+    abbildung = fmt.get("tool_names") or {}
+    if verb in abbildung:
+        return list(abbildung[verb])
+    if verb in (fmt.get("tool_names_unmapped") or []):
+        return [verb]
+    raise AbbildungsFehler(
+        f"{man.get('client', '?')}/manifest.json: {block}.tool_names kennt das "
+        f"Werkzeugverb '{verb}' nicht. Fuehrt dieser Client die Werkzeugnamen des "
+        f"Frontmatters unveraendert - oder sind sie unerhoben -, gehoert das Verb in "
+        f"{block}.tool_names_unmapped samt _tool_names_unmapped_note; eine Luecke "
+        f"allein ist keine Aussage (D-78, Bauform wie hook_tools_absent nach D-47)")
+
+
+# ---------------------------------------------------------------------------
+# Berechtigungen
+# ---------------------------------------------------------------------------
+
+def _werkzeuge(man: dict, verb: str) -> list[str]:
+    abbildung = man.get("permission_tools")
+    if abbildung is None:
+        raise AbbildungsFehler(
+            f"{man.get('client', '?')}/manifest.json: Feld permission_tools fehlt")
+    if verb not in abbildung:
+        raise AbbildungsFehler(
+            f"{man.get('client', '?')}/manifest.json: permission_tools kennt das "
+            f"Werkzeugverb '{verb}' nicht")
+    return list(abbildung[verb])
+
+
+def _muster(rohmuster: str, man: dict) -> str:
+    """Pfadmuster in der Schreibweise dieses Clients.
+
+    Manche Clients verlangen fuer einen Namen ohne Verzeichnisanteil eine ausdrueckliche
+    Wurzelangabe, weil ein blosser Name sonst mehrdeutig ist. Aufgeloeste Muster mit
+    Verzeichnisanteil, Globs und offene Projektplatzhalter bleiben unberuehrt.
+    """
+    muster = resolve_placeholders(rohmuster, man)
+    vorsatz = man.get("permission_path_prefix", "")
+    if not vorsatz or "/" in muster or muster.startswith(("<", "*")):
+        return muster
+    return vorsatz + muster
+
+
+def _befehl(regel: dict, man: dict, korb: str) -> str:
+    """Befehlsverbot in der Schreibweise dieses Clients (woertlich oder praefixbasiert)."""
+    woertlich = regel["command"]
+    praefix = regel.get("prefix", woertlich.strip())
+    if not woertlich.strip().startswith(praefix):
+        raise AbbildungsFehler(
+            f"permissions.json: prefix '{praefix}' ist kein Praefix von command "
+            f"'{woertlich.strip()}' - die Praefixform waere nicht nachweislich breiter "
+            f"als die woertliche")
+    if man.get("permission_exec_match", "literal") != "prefix":
+        return resolve_placeholders(woertlich, man)
+    if korb == "allow" and praefix != woertlich.strip():
+        raise AbbildungsFehler(
+            f"permissions.json: allow-Regel '{woertlich.strip()}' hat eine kuerzere "
+            f"prefix-Form - bei allow waere das eine Lockerung")
+    praefix = resolve_placeholders(praefix, man)
+    if praefix.startswith("<"):
+        # Offener Projektplatzhalter: Der Overlay Owner traegt den vollstaendigen Befehl
+        # ein; ein angehaengtes Praefixzeichen wuerde ihn verfaelschen.
+        return praefix
+    return praefix + man.get("permission_exec_suffix", ":*")
+
+
+def _regel_rendern(regel: dict, man: dict, korb: str) -> list[str]:
+    verb = regel["tool"]
+    ziele = _werkzeuge(man, verb)
+    if not ziele:
+        if korb in ("deny", "ask"):
+            raise AbbildungsFehler(
+                f"{man.get('client', '?')}: kein Werkzeug fuer '{verb}', die "
+                f"{korb}-Regel {regel} liesse sich nur durch Weglassen abbilden - das "
+                f"waere eine Lockerung")
+        return []
+    ohne_muster = set(man.get("permission_tools_bare", []))
+    if verb == "exec":
+        argument = _befehl(regel, man, korb)
+    elif verb == "skill":
+        # Ein Aufrufname, kein Pfad: weder Wurzelpraefix noch Praefixzeichen, und
+        # keine Musterausweitung. Gemessen am 2026-09-14 (D-82): Das Argument wird
+        # woertlich verglichen - Skill(fw-*) laesst den Aufruf von fw-code-explain
+        # NICHT durch. Wer hier ein Muster erzeugte, erzeugte eine Freigabe, die
+        # lautlos nichts freigibt - der Befundtyp von D-66, mit umgekehrtem
+        # Vorzeichen.
+        argument = regel["pattern"]
+    else:
+        argument = _muster(regel["pattern"], man)
+    return [name if name in ohne_muster else f"{name}({argument})" for name in ziele]
+
+
+def _korb_rendern(quelle: dict, man: dict, korb: str) -> list[str]:
+    raus: list[str] = []
+    for regel in quelle.get(korb, []):
+        for gerendert in _regel_rendern(regel, man, korb):
+            if gerendert not in raus:
+                raus.append(gerendert)
+    return raus
+
+
+def basket_rules(quelle: dict, man: dict, korb: str) -> list[str]:
+    """Die Regeln eines Korbes in der Schreibweise dieses Clients.
+
+    Dieselbe Bauart wie core_rules, nur ohne die Einschraenkung auf 'core': true. Der
+    Validator haelt die installierte Datei damit gegen die Kernquelle (Pruefung 37,
+    CR-2026-061, D-77): Was hier erzeugt wird, muss dort stehen; was dort zusaetzlich
+    steht, ist nur im deny-Korb zulaessig - dort ist es eine Verschaerfung, in ask und
+    allow eine Ausweitung.
+
+    Oeffentlich und nicht _korb_rendern, weil eine Pruefung, die auf eine private
+    Funktion greift, beim naechsten Umbau still ausfaellt.
+    """
+    return _korb_rendern(quelle, man, korb)
+
+
+def core_rules(quelle: dict, man: dict) -> list[str]:
+    """Die Kernzusagen B1 bis B6 in der Schreibweise dieses Clients."""
+    raus: list[str] = []
+    for regel in quelle.get("deny", []):
+        if not regel.get("core"):
+            continue
+        for gerendert in _regel_rendern(regel, man, "deny"):
+            if gerendert not in raus:
+                raus.append(gerendert)
+    return raus
+
+
+def import_control(man: dict) -> tuple[str, object] | None:
+    """Importsteuerung dieses Clients als (Schluessel, Wert) - oder None.
+
+    Ein Client ohne solchen Mechanismus traegt das Feld nicht; dann bleibt es bei der
+    Auskunft im Abschnitt "Anweisungs- und Konfigurationsquellen ausserhalb des
+    Projekts" seines Client Packs (D-37). Dasselbe Feld liest Pruefung 22.
+    """
+    steuerung = man.get("import_control")
+    if not steuerung:
+        return None
+    schluessel = steuerung.get("key")
+    if not schluessel or "value" not in steuerung:
+        raise AbbildungsFehler(
+            f"{man.get('client', '?')}/manifest.json: import_control braucht 'key' "
+            f"und 'value'")
+    return schluessel, steuerung["value"]
+
+
+def _kommentar(man: dict, mit_hooks: bool) -> str:
+    kern = core_dir_name(man)
+    pack = man.get("client", "?")
+    teile = [
+        f"Berechtigungsvorlage des Frameworks (Ebene 3), erzeugt fuer das Client "
+        f"Pack {pack}.",
+        f"Regelmenge: {kern}/framework/runtime/permissions.json. Abbildung auf die "
+        f"Werkzeuge dieses Clients: {kern}/clients/{pack}/manifest.json. Inhaltliche "
+        f"Aenderungen gehoeren dorthin und laufen als Aenderungsantrag.",
+        "Mechanismus: deny vor ask vor allow.",
+    ]
+    if mit_hooks:
+        teile.append("Dieser Client kennt keine eigene Hook-Datei; die Hooks stehen "
+                     "deshalb hier unter 'hooks'.")
+    teile.append(
+        "Platzhalter in spitzen Klammern traegt der Overlay Owner hier ein - das ist der "
+        "einzige Teil dieser Datei, der dem Projekt gehoert.")
+    teile.append(
+        "Die unter _core_rules_integrity aufgefuehrten Regeln duerfen vom Projekt nicht "
+        f"entfernt werden; {kern}/tests/scripts/validate-framework.py prueft sie gegen "
+        "die Kernquelle.")
+    teile.append(
+        "Derselbe Lauf haelt alle drei Koerbe gegen die Kernquelle: Was dort erzeugt "
+        "wird, muss hier stehen. Eine zusaetzliche Regel ist nur unter 'deny' zulaessig "
+        "- dort ist sie eine Verschaerfung; unter 'ask' und 'allow' waere sie eine "
+        "Ausweitung und ist ein Fehler. Ein zusaetzlicher freigegebener Befehl gehoert "
+        "deshalb nicht hierher, sondern in Abschnitt 6 des Overlays und damit in die "
+        "Regelschicht.")
+    teile.append(
+        "Ein Befehlsschlitz traegt den Befehl, den Abschnitt 5 oder 6 des Overlays fuer "
+        "seinen Platzhalter erklaert - ein anderer Befehl an dieser Stelle ist ein "
+        "Fehler, auch wenn die Zahl der Zeilen stimmt. Bis 0.43.0 stand der Satz "
+        "darueber hier ohne diese Bedingung und versprach zu viel: Ein offener Schlitz "
+        "deckte eine hinzugefuegte Zeile (CR-2026-066, D-90). Die Pfadlisten haelt "
+        "der Validator unter --strict-overlay gegen das Overlay, in einer Richtung: "
+        "Jeder ausgeschlossene Pfad braucht hier eine Lese- und eine Schreibsperre, "
+        "jeder nur lesbare eine Schreibsperre (Pruefungen 59 und 89; K-151, D-399).")
+    if import_control(man) is not None:
+        teile.append(
+            "Die Importsteuerung schaltet Regel- und Skillquellen fremder "
+            "Werkzeugformate ab (D-37). Das eigene Format der Wurzel-Anweisungsdatei "
+            "bleibt eingeschaltet. Sie ist ein Standard, keine Schranke: Die "
+            "Benutzerkonfiguration dieser Arbeitsstation hat Vorrang.")
+    hinweis = man.get("permissions_note")
+    if hinweis:
+        teile.append(hinweis)
+    teile.append("Exakte Mustersemantik: siehe Zeile B3 der Faehigkeitsmatrix "
+                 "dieses Client Packs.")
+    return " ".join(teile)
+
+
+def render_permissions(quelltext: str, man: dict, hooks_quelltext: str | None = None) -> str:
+    """Berechtigungsdatei dieses Client Packs aus der neutralen Regelmenge.
+
+    hooks_quelltext wird nur uebergeben, wenn der Client keine eigene Hook-Datei kennt;
+    die Hooks werden dann in dieselbe Datei eingebettet.
+    """
+    quelle = json.loads(quelltext)
+    rechte: dict = {}
+    rechte.update(man.get("permissions_extra", {}))
+    for korb in ("deny", "ask", "allow"):
+        rechte[korb] = _korb_rendern(quelle, man, korb)
+
+    ergebnis: dict = {"_comment": _kommentar(man, hooks_quelltext is not None),
+                      "permissions": rechte}
+    # Zusatzschluessel auf der OBERSTEN Ebene der Einstellungsdatei - nicht innerhalb
+    # von permissions. Der Unterschied ist keine Kosmetik: Ein Schluessel auf der
+    # falschen Ebene wird von diesem Client stillschweigend nicht gelesen, und nichts
+    # meldet es. permissions_extra deckt die eine Ebene, settings_extra die andere
+    # (CR-2026-087, D-155). Pruefung 54 haelt beide gegen die erzeugte Datei.
+    for schluessel, wert in man.get("settings_extra", {}).items():
+        ergebnis[schluessel] = wert
+    steuerung = import_control(man)
+    if steuerung is not None:
+        ergebnis[steuerung[0]] = steuerung[1]
+    if hooks_quelltext is not None:
+        ergebnis["hooks"] = _hooks_objekt(hooks_quelltext, man)
+    ergebnis["_core_rules_integrity"] = {"deny_must_contain": core_rules(quelle, man)}
+    return json.dumps(ergebnis, indent=2, ensure_ascii=False) + "\n"
+
+
+# ---------------------------------------------------------------------------
+# Hooks
+# ---------------------------------------------------------------------------
+
+def _hook_matcher(verben: list[str], man: dict) -> str:
+    abbildung = man.get("hook_tools")
+    if abbildung is None:
+        raise AbbildungsFehler(
+            f"{man.get('client', '?')}/manifest.json: Feld hook_tools fehlt")
+    # Ein Pack darf eine Werkzeugklasse nicht dadurch aus der Durchsetzung nehmen, dass
+    # es sie leer laesst - deshalb ist eine leere Liste ein Fehler. Fuehrt der Client
+    # aber tatsaechlich kein Werkzeug dieser Art, muss es einen Weg geben, das zu sagen:
+    # hook_tools_absent erklaert die Abwesenheit ausdruecklich. Der Unterschied ist der
+    # zwischen "nicht abgebildet" und "gibt es nicht", und er muss deklariert werden,
+    # nicht aus einer leeren Liste erraten (CR-2026-047 E3, D-47). Pruefung 26 prueft,
+    # dass eine so erklaerte Abwesenheit auch in permission_tools steht.
+    erklaert_abwesend = set(man.get("hook_tools_absent") or [])
+    # SEIT 1.20.0 EIN DRITTER ZUSTAND (K-184, D-486): "unerhoben". Ein Verb, das die
+    # Kernquelle neu fuehrt, ist nicht fuer jeden Client gemessen - und ein Matcher auf
+    # eine ungemessene Werkzeugform waere eine Zusage ohne Mechanismus (D-78). Das Pack
+    # erklaert es ausdruecklich; Pruefung 26 verlangt die Begruendung und haelt die drei
+    # Zustaende auseinander.
+    erklaert_unerhoben = set(man.get("hook_tools_unerhoben") or [])
+    namen: list[str] = []
+    for verb in verben:
+        if verb in erklaert_unerhoben and not abbildung.get(verb):
+            continue
+        if verb not in abbildung:
+            raise AbbildungsFehler(
+                f"{man.get('client', '?')}/manifest.json: hook_tools kennt das "
+                f"Werkzeugverb '{verb}' nicht")
+        if not abbildung[verb]:
+            if verb in erklaert_abwesend:
+                continue
+            raise AbbildungsFehler(
+                f"{man.get('client', '?')}: kein Hook-Werkzeug fuer '{verb}' - der Hook "
+                f"wuerde fuer diese Werkzeugklasse nicht ausloesen. Fuehrt der Client "
+                f"kein solches Werkzeug, gehoert das Verb in hook_tools_absent")
+        for name in abbildung[verb]:
+            if name not in namen:
+                namen.append(name)
+    return man.get("hook_matcher_separator", "|").join(namen)
+
+
+# Kandidaten in der Reihenfolge, in der sie geprueft werden. "python3" steht vorn,
+# weil es auf POSIX-Systemen der verlaessliche Name ist; "py" ist der Windows-Launcher.
+INTERPRETER_KANDIDATEN = ("python3", "python", "py")
+_SONDE = "KOOLIE-INTERPRETER-OK"
+_interpreter_gemerkt: list[str] = []
+
+
+def python_interpreter() -> str:
+    """Ermittelt einen Interpreternamen, der auf dieser Maschine wirklich Python startet.
+
+    Nicht "python3" fest verdrahten: Unter Windows ist das haeufig der
+    Microsoft-Store-Alias, der nur eine Fehlermeldung ausgibt und mit Exit-Code 49
+    endet, ohne dass ein Interpreter startet. Ein Hook, der so aufgerufen wird, laeuft
+    nie - und ein Schutz-Hook, der nicht laeuft, blockiert nichts (AP2-CC-13).
+
+    Geprueft wird deshalb nicht die Anwesenheit des Namens, sondern seine Wirkung:
+    Der Kandidat muss eine Sonde ausgeben. Das ist dieselbe Unterscheidung, die D-23
+    fuer Pruefungen verlangt - Anwesenheit ist kein Nachweis.
+    """
+    if _interpreter_gemerkt:
+        return _interpreter_gemerkt[0]
+    versucht = []
+    for kandidat in INTERPRETER_KANDIDATEN:
+        try:
+            lauf = subprocess.run(
+                [kandidat, "-c", "import sys; sys.stdout.write('%s')" % _SONDE],
+                capture_output=True, text=True, timeout=15)
+        except (OSError, subprocess.SubprocessError) as fehler:
+            versucht.append("%s (%s)" % (kandidat, type(fehler).__name__))
+            continue
+        if lauf.returncode == 0 and _SONDE in (lauf.stdout or ""):
+            _interpreter_gemerkt.append(kandidat)
+            return kandidat
+        versucht.append("%s (Exit %s)" % (kandidat, lauf.returncode))
+    raise AbbildungsFehler(
+        "Kein funktionsfaehiger Python-Interpreter fuer die Hook-Aufrufe gefunden. "
+        "Geprueft: " + ", ".join(versucht) + ". Die Hooks des Frameworks setzen die "
+        "Zusagen H2 und die Overlay-Statusmeldung durch; ohne Interpreter liefen sie "
+        "nicht, und ein Schutz-Hook, der nicht laeuft, blockiert nichts (AP2-CC-13). "
+        "Installation abgebrochen, statt eine Zusage zu erzeugen, die nicht traegt (D-26)")
+
+
+def _hook_befehl(script: str, man: dict, enforcing: bool = False,
+                 needs_project_paths: bool = False) -> str:
+    """Aufrufkommando eines Hooks fuer diesen Client.
+
+    Bei einem durchsetzenden Hook (enforcing in der Kernquelle) haengt die Abbildung
+    --fail-closed an, sobald das Pack das Eingabeschema seines Clients als bestaetigt
+    fuehrt. Der Schalter steht damit im Kommando, das der Client ohnehin ausfuehrt, und
+    nicht in einer Umgebungsvariablen: Ob ein Client env an den Hook-Prozess weiterreicht,
+    ist fuer keines der Packs belegt, und eine Sperre, die auf einer unbelegten
+    Clientzusage steht, ist genau die Lage, aus der AP2-CC-13 kam (D-31).
+
+    Dieselbe Begruendung traegt needs_project_paths: Ein Hook, der Projektverzeichnis und
+    Regelablage braucht, bekommt sie als Argumente aus dieser Abbildung - nicht aus der
+    Umgebung und schon gar nicht geraten. Ein Skript des Kerns kennt die Laufzeitschicht
+    eines Packs nicht (D-30, fortgeschrieben mit CR-2026-037).
+    """
+    variable = man.get("hook_project_dir_var")
+    ausdruck = man.get("hook_project_dir_expr")
+    if not variable and not ausdruck:
+        raise AbbildungsFehler(
+            f"{man.get('client', '?')}/manifest.json: Feld hook_project_dir_var fehlt")
+    # WARUM ES DANEBEN EINEN AUSDRUCK GIBT (CR-2026-133, D-347). Eine Variable ist
+    # nur eine der Formen, in denen ein Client dem Hook sein Projektverzeichnis sagt -
+    # und bei openai-codex ist es keine: Am 2026-09-23 ist der Hook-Prozess
+    # aufgezeichnet worden, und seine Umgebung fuehrt AUSSER CODEX_HOME nichts; sein
+    # ARBEITSVERZEICHNIS ist das Projektverzeichnis. Eine Variable, die es nicht gibt,
+    # haette das Kommando auf einen Pfad unterhalb der Wurzel zeigen lassen - der Hook
+    # waere gestartet worden und haette nichts gefunden.
+    wurzel = ausdruck if ausdruck else "$" + variable
+    befehl = (python_interpreter() + ' "' + wurzel + '/'
+              + core_dir_name(man) + '/' + script + '"')
+    if enforcing and man.get("hook_fail_closed") is True:
+        befehl += " --fail-closed"
+    if enforcing:
+        # DIE SPERRFORM GEHOERT IN DAS KOMMANDO, UND DER GRUND IST GEMESSEN
+        # (CR-2026-133, D-347). Ein durchsetzender Hook sagt seinem Client, dass er
+        # sperrt - und die Form dieser Aussage ist clientgebunden. Am 2026-09-23 an
+        # einer realen Installation von openai-codex gemessen: Die bisherige Form
+        # ({"decision": "block"} und Exit 2) meldet der Client als FEHLGESCHLAGENEN
+        # Hook und FUEHRT DIE OPERATION AUS - im Gegenlauf kam der Koederinhalt
+        # woertlich heraus. Dieselbe Sperre in der Form, die dieser Client liest,
+        # blockiert - auch im Modus, der Rueckfragen und Sandkasten abschaltet.
+        # ➡️ Ein Hook, der laeuft und dessen Sperrform der Client nicht liest, ist
+        #    eine Zusage ohne Mechanismus, und nichts meldet es.
+        # Der Standard bleibt die bisherige Form; ein Pack, das eine andere braucht,
+        # SAGT sie. Pruefung 86 verlangt von jedem Pack mit durchsetzendem Hook, dass
+        # das Skript die genannte Form kennt.
+        form = man.get("hook_block_form")
+        if form:
+            befehl += " --sperrform " + form
+    if needs_project_paths:
+        regelablage = man.get("runtime_placeholders", {}).get("<RULES_DIR>")
+        if not regelablage:
+            raise AbbildungsFehler(
+                f"{man.get('client', '?')}/manifest.json: <RULES_DIR> fehlt in "
+                f"runtime_placeholders; der meldende Hook braucht die Regelablage")
+        befehl += ' "' + wurzel + '" "' + regelablage + '"'
+    return befehl
+
+
+def _hooks_objekt(quelltext: str, man: dict) -> dict:
+    quelle = json.loads(quelltext)
+    ergebnis: dict = {}
+    for ereignis, eintraege in quelle.items():
+        if ereignis.startswith("_"):
+            continue
+        gerendert = []
+        for eintrag in eintraege:
+            neu: dict = {}
+            if "on" in eintrag:
+                neu["matcher"] = _hook_matcher(eintrag["on"], man)
+            # Zusatzfelder, die dieser Client je Hook-Eintrag verlangt. Bei
+            # openai-codex ist das "enabled": true - gemessen am 2026-09-23: ohne
+            # dieses Feld laeuft der Eintrag nicht, und der Client meldet es nicht.
+            # Ein Pack, das kein solches Feld braucht, fuehrt das Manifestfeld nicht.
+            neu.update(man.get("hook_handler_extra") or {})
+            # "enforcing" und "needs_project_paths" sind Steuerinformation der
+            # Kernquelle und keine Felder des Clients; sie steuern nur, ob das Kommando
+            # --fail-closed traegt und ob ihm Projektverzeichnis und Regelablage folgen.
+            neu["hooks"] = [
+                {"type": h["type"],
+                 "command": _hook_befehl(h["script"], man,
+                                         h.get("enforcing") is True,
+                                         h.get("needs_project_paths") is True),
+                 "timeout": h["timeout"]}
+                for h in eintrag["hooks"]
+            ]
+            gerendert.append(neu)
+        ergebnis[ereignis] = gerendert
+    return ergebnis
+
+
+def render_hooks(quelltext: str, man: dict) -> str:
+    """Eigenstaendige Hook-Datei fuer Clients, die eine kennen.
+
+    Manche Clients erwarten die Ereignisse unter einem Schluessel der obersten Ebene
+    statt unmittelbar in der Datei. Welcher das ist, sagt das Pack in
+    hooks_file_wrapper - gemessen, nicht geraten: Bei openai-codex meldet der Client
+    eine Datei ohne diesen Schluessel mit *unknown field `PreToolUse`* und LAEDT SIE
+    NICHT; er startet trotzdem, und ohne die Meldung im Blick haette man einen
+    ausgelieferten Schutz-Hook gehabt, der nie laeuft (D-347).
+
+    Seit 1.13.0 gibt es eine zweite Gestalt (hooks_format "kiro-v1", D-414): eine
+    LISTE von Hooks mit Ausloeser je Eintrag statt eines Objekts je Ereignis.
+    """
+    if man.get("hooks_format") == "kiro-v1":
+        return render_hooks_kiro(quelltext, man)
+    if man.get("hooks_format") == "cursor-v1":
+        return render_hooks_cursor(quelltext, man)
+    objekt = _hooks_objekt(quelltext, man)
+    schluessel = man.get("hooks_file_wrapper")
+    if schluessel:
+        objekt = {schluessel: objekt}
+    return json.dumps(objekt, indent=2, ensure_ascii=False) + "\n"
+
+
+# ---------------------------------------------------------------------------
+# Hilfsfunktionen fuer die Aufrufer
+# ---------------------------------------------------------------------------
+
+def hooks_in_permissions(man: dict) -> bool:
+    """Wahr, wenn dieser Client keine eigene Hook-Datei kennt.
+
+    Erkennbar daran, dass Hook- und Berechtigungsdatei auf denselben Pfad zeigen; eine
+    zusaetzliche Angabe im Manifest waere eine zweite Wahrheit ueber dieselbe Tatsache.
+    """
+    p = man.get("runtime_placeholders", {})
+    hooks, rechte = p.get("<HOOKS_FILE>"), p.get("<PERMISSIONS_FILE>")
+    return hooks is not None and hooks == rechte
+
+
+def load_source(core_dir: str, name: str) -> str:
+    with open(os.path.join(core_dir, "framework", "runtime", name), encoding="utf-8") as fh:
+        return fh.read()
+
+
+# ---------------------------------------------------------------------------
+# Zweite Ausgabeform: Rechteprofil (TOML) und Befehlsregeln (eigene Regelsprache)
+# ---------------------------------------------------------------------------
+#
+# WARUM ES SIE GIBT, UND DER GRUND IST GEMESSEN (CR-2026-133, D-346). Die erste
+# Ausgabeform rendert Koerbe aus Regeln der Gestalt Werkzeug(Muster) in EINE Datei.
+# Der Client openai-codex kennt diese Gestalt nicht. Er bindet Pfade an eine
+# Zugriffsart (read / write / deny) in einem Rechteprofil seiner Konfigurationsdatei,
+# und Befehle an eigene Regeldateien in einer eigenen Sprache. Die Regelmenge des
+# Kerns zerfaellt damit in ZWEI Erzeugnisse, und keines davon ist eine Liste von
+# Werkzeug(Muster)-Zeilen.
+#
+# WAS DABEI AUSFAELLT, FAELLT NICHT LAUTLOS AUS. Gemessen am 2026-09-23
+# (tests/protocols/2026-09-23-bau-openai-codex.md):
+#   * Ein Musterausdruck ist als Schluessel nur mit ABSOLUTEM oder ~/-Vorsatz
+#     zulaessig - und dann nur fuer die Zugriffsart deny. Ein projektrelativer
+#     Schluessel (":workspace/<pfad>") nimmt KEIN Muster. Musterform und
+#     Versionierbarkeit schliessen einander damit aus, und B3 faellt an beiden Enden.
+#     (Gemessen mit 0.156.1. Die Herstellerdokumentation nennt seit 0.157 Globs
+#     unter ":workspace_roots" als deny-Leseregeln - nicht nachgemessen, K-160.)
+#   * Seit 0.157 heisst das Sonderziel ":workspace_roots" und traegt seine
+#     Unterpfade als eigene Tabelle ("." = der Arbeitsbereich selbst). Die alte
+#     Form ":workspace/<pfad>" meldet 0.157 als unbekannt und IGNORIERT sie - mit
+#     ihr war der ganze Arbeitsbereich schreibgeschuetzt, gemessen mit
+#     `codex sandbox` am 2026-09-26 (K-157, D-412).
+#   * Ein deny-Leserecht verlangt ausserdem den erhoehten Windows-Sandkasten; auf
+#     einem unerhoehten Arbeitsplatz LAEUFT DER CLIENT DANN NICHT (fail-closed).
+# Diese Ausgabeform rendert den Lesekorb deshalb NICHT und fuehrt seine Regeln in
+# nicht_abgebildete_pfadregeln() auf. Pruefung 87 haelt die Zahl gegen das Pack; das
+# Pack traegt B3 als [NICHT ABBILDBAR] mit Begruendung, Ersatz und Freigabe nach
+# clients/README.md Abschnitt 4. Eine Regel, die den Client am Starten hindert, waere
+# keine Schranke, sondern ein Ausfall.
+
+
+def _toml_zeichenkette(text: str) -> str:
+    return '"' + text.replace("\\", "\\\\").replace('"', '\\"') + '"'
+
+
+def _toml_wert(wert: object) -> str:
+    if wert is True:
+        return "true"
+    if wert is False:
+        return "false"
+    if isinstance(wert, int):
+        return str(wert)
+    return _toml_zeichenkette(str(wert))
+
+
+def _profil_schluessel(rohmuster: str, man: dict) -> str | None:
+    """Projektrelativer Schluessel des Rechteprofils - oder None, wenn nicht abbildbar.
+
+    Abbildbar ist genau, was nach dem Aufloesen der Platzhalter KEIN Muster mehr
+    enthaelt: Die Schluesselsyntax dieses Clients nimmt Muster nur mit absolutem oder
+    ~/-Vorsatz an, und ein absoluter Pfad in einem versionierten Traeger waere ein Wert
+    dieser Arbeitsstation. Ein offener Projektplatzhalter bleibt ebenfalls aus - er
+    traegt eine Liste, die der Overlay Owner fuellt, und die Schluesselseite einer
+    TOML-Tabelle kennt keinen Schlitz.
+    """
+    muster = resolve_placeholders(rohmuster, man)
+    if muster.startswith("<"):
+        return None
+    # Ein Teilbaummuster ist die eine Musterform, die dieser Client projektrelativ
+    # nimmt - gemessen am 2026-09-23: ":workspace/.koolie/**" wird angenommen und
+    # steht danach als Teilbaum ":workspace/.koolie" im wirksamen Profil. Alles
+    # andere - ein Namensmuster wie **/*.lock - bleibt aus.
+    if muster.endswith("/**"):
+        muster = muster[:-3]
+    if any(z in muster for z in ("*", "?", "[")):
+        return None
+    vorsatz = man.get("permission_path_special", ":workspace_roots")
+    if muster.startswith("./"):
+        muster = muster[2:]
+    return vorsatz + "/" + muster
+
+
+def _profil_eintraege(quelle: dict, man: dict) -> tuple[dict, list[str]]:
+    """Die Pfadregeln des Kerns als Eintraege des Rechteprofils.
+
+    Rueckgabe: (Eintraege, nicht abgebildete Rohregeln). Die zweite Haelfte ist der
+    Grund, warum dieser Ausgabeform eine Zeile im Pack gehoert.
+    """
+    eintraege: dict[str, str] = {}
+    offen: list[str] = []
+    for schluessel, wert in (man.get("permission_path_base") or {}).items():
+        eintraege[schluessel] = wert
+    for regel in quelle.get("deny", []):
+        verb = regel.get("tool")
+        if verb == "write":
+            schluessel = _profil_schluessel(regel["pattern"], man)
+            if schluessel is None:
+                offen.append("write " + regel["pattern"])
+                continue
+            # Schreibverbot auf einem Teilbaum heisst hier: lesbar, nicht schreibbar.
+            eintraege[schluessel] = "read"
+        elif verb == "read":
+            offen.append("read " + regel["pattern"])
+    return eintraege, offen
+
+
+def nicht_abgebildete_pfadregeln(quelltext: str, man: dict) -> list[str]:
+    """Die Pfadregeln, die diese Ausgabeform nicht traegt - oeffentlich fuer Pruefung 87."""
+    return _profil_eintraege(json.loads(quelltext), man)[1]
+
+
+def _toml_kommentar(man: dict) -> list[str]:
+    kern = core_dir_name(man)
+    pack = man.get("client", "?")
+    return [
+        "Berechtigungsvorlage des Frameworks (Ebene 3), erzeugt fuer das Client Pack "
+        + pack + ".",
+        "Regelmenge: " + kern + "/framework/runtime/permissions.json. Abbildung auf die",
+        "Form dieses Clients: " + kern + "/clients/" + pack + "/manifest.json.",
+        "Inhaltliche Aenderungen gehoeren dorthin und laufen als Aenderungsantrag.",
+        "Diese Datei traegt die PFADSEITE. Die Befehlsseite steht in der Regeldatei, die",
+        "dasselbe Werkzeug erzeugt; beide zusammen sind die Berechtigungsschicht dieses",
+        "Packs.",
+        "Was diese Datei NICHT traegt, steht in Zeile B3 der Faehigkeitsmatrix des Packs:",
+        "Der Lesekorb des Kerns ist hier nicht abbildbar - ein Muster verlangt einen",
+        "absoluten Vorsatz und waere damit ein Wert dieser Arbeitsstation, und ein",
+        "deny-Leserecht verlangt den erhoehten Windows-Sandkasten.",
+        "Die projektlokale Schicht laedt NUR, wenn dieses Projekt in der Benutzer-",
+        "konfiguration des Clients als vertraut eingetragen ist. Ohne diesen Eintrag",
+        "traegt diese Datei nichts.",
+        "Diese Datei traegt ausschliesslich Schluessel, die der Client kennt: Ein",
+        "unbekannter Schluessel wird gemeldet und mit --strict-config zum Fehler. Die",
+        "Kernregeln haelt deshalb der Validator gegen die Kernquelle und nicht eine",
+        "zweite Liste in dieser Datei.",
+    ]
+
+
+def render_permissions_toml(quelltext: str, man: dict) -> str:
+    """Rechteprofil dieses Client Packs aus der neutralen Regelmenge."""
+    quelle = json.loads(quelltext)
+    profil = man.get("permission_profile_name")
+    if not profil:
+        raise AbbildungsFehler(
+            man.get("client", "?") + "/manifest.json: Feld permission_profile_name "
+            "fehlt - ohne Profilnamen gibt es keine Tabelle, in die die Pfadregeln "
+            "gehoeren")
+    eintraege, _ = _profil_eintraege(quelle, man)
+
+    zeilen = ["# " + teil for teil in _toml_kommentar(man)]
+    zeilen.append("")
+    zeilen.append("default_permissions = " + _toml_zeichenkette(profil))
+    zeilen.append("")
+    zeilen.append("[permissions." + profil + "]")
+    beschreibung = man.get("permission_profile_description")
+    if beschreibung:
+        zeilen.append("description = " + _toml_zeichenkette(beschreibung))
+    zeilen.append("")
+    zeilen.append("[permissions." + profil + ".filesystem]")
+    # Das Sonderziel des Arbeitsbereichs traegt seine Unterpfade als eigene Tabelle:
+    # der Arbeitsbereich selbst als ".", jeder Teilbaum relativ dazu (K-157, D-412).
+    vorsatz = man.get("permission_path_special", ":workspace_roots")
+    unter: dict[str, str] = {}
+    for schluessel in sorted(eintraege):
+        if schluessel == vorsatz:
+            unter["."] = eintraege[schluessel]
+        elif schluessel.startswith(vorsatz + "/"):
+            unter[schluessel[len(vorsatz) + 1:]] = eintraege[schluessel]
+        else:
+            zeilen.append(_toml_zeichenkette(schluessel) + " = "
+                          + _toml_zeichenkette(eintraege[schluessel]))
+    if unter:
+        zeilen.append("")
+        zeilen.append("[permissions." + profil + ".filesystem."
+                      + _toml_zeichenkette(vorsatz) + "]")
+        for schluessel in sorted(unter):
+            zeilen.append(_toml_zeichenkette(schluessel) + " = "
+                          + _toml_zeichenkette(unter[schluessel]))
+    netz = man.get("permission_profile_network")
+    if netz:
+        zeilen.append("")
+        zeilen.append("[permissions." + profil + ".network]")
+        for schluessel in sorted(netz):
+            zeilen.append(schluessel + " = " + _toml_wert(netz[schluessel]))
+    for tabelle in sorted(man.get("permissions_toml_extra") or {}):
+        inhalt = man["permissions_toml_extra"][tabelle]
+        zeilen.append("")
+        zeilen.append("[" + tabelle + "]")
+        for schluessel in sorted(inhalt):
+            zeilen.append(schluessel + " = " + _toml_wert(inhalt[schluessel]))
+    return "\n".join(zeilen) + "\n"
+
+
+def _policy_zeile(regel: dict, man: dict, decision: str) -> str | None:
+    """Eine Befehlsregel in der Regelsprache dieses Clients - oder None bei Schlitz."""
+    woertlich = regel["command"].strip()
+    praefix = regel.get("prefix", woertlich).strip()
+    if not woertlich.startswith(praefix):
+        raise AbbildungsFehler(
+            "permissions.json: prefix '" + praefix + "' ist kein Praefix von command '"
+            + woertlich + "' - die Praefixform waere nicht nachweislich breiter als "
+            "die woertliche")
+    if decision == "allow" and praefix != woertlich:
+        raise AbbildungsFehler(
+            "permissions.json: allow-Regel '" + woertlich + "' hat eine kuerzere "
+            "prefix-Form - bei allow waere das eine Lockerung")
+    aufgeloest = resolve_placeholders(praefix, man)
+    if aufgeloest.startswith("<"):
+        # Offener Projektplatzhalter: Sein Wert gehoert dem Projekt, und diese
+        # Regelsprache kennt keinen Schlitz. Der Befehl bleibt aus - das ist bei
+        # 'prompt' eine Verschaerfung (er laeuft in die Rueckfrage) und bei 'allow'
+        # ebenfalls (er ist nicht vorab freigegeben).
+        return None
+    tokens = ", ".join(_toml_zeichenkette(t) for t in aufgeloest.split())
+    grund = regel.get("justification") or ("Framework-Regel (" + decision + ")")
+    return ("prefix_rule(pattern = [" + tokens + "], decision = "
+            + _toml_zeichenkette(decision) + ", justification = "
+            + _toml_zeichenkette(grund) + ")")
+
+
+#: Korb der Kernquelle -> Entscheidung der Regelsprache dieses Clients.
+POLICY_ENTSCHEIDUNG = {"deny": "forbidden", "ask": "prompt", "allow": "allow"}
+
+
+def _policy_kommentar(man: dict) -> list[str]:
+    kern = core_dir_name(man)
+    pack = man.get("client", "?")
+    return [
+        "Befehlsregeln des Frameworks (Ebene 3), erzeugt fuer das Client Pack " + pack + ".",
+        "Regelmenge: " + kern + "/framework/runtime/permissions.json, Regeln mit tool=exec.",
+        "Reihenfolge der Koerbe: deny vor ask vor allow - forbidden vor prompt vor allow.",
+        "Die Praefixform ist nachweislich mindestens so breit wie die woertliche Form;",
+        "ihre benannte Grenze ist eine andere Schreibweise desselben Befehls.",
+        "Ein Befehlsschlitz des Overlays steht NICHT hier: Sein Wert gehoert dem Projekt,",
+        "und diese Regelsprache kennt keinen Platzhalter. Sein Ausbleiben ist in beiden",
+        "Koerben eine Verschaerfung.",
+    ]
+
+
+def render_exec_policy(quelltext: str, man: dict) -> str:
+    """Befehlsregeln dieses Client Packs aus der neutralen Regelmenge.
+
+    Die Regeldatei liegt projektlokal und ist damit versioniert - das ist die Haelfte
+    von B1, die dieser Client traegt. Gemessen am 2026-09-23 an einer realen
+    Installation: Ein Befehl, den diese Datei verbietet, wird abgewiesen, und der
+    Client nennt dabei die Begruendung dieser Datei woertlich.
+    """
+    quelle = json.loads(quelltext)
+    zeilen = ["# " + teil for teil in _policy_kommentar(man)]
+    zeilen.append("")
+    for korb in ("deny", "ask", "allow"):
+        entscheidung = POLICY_ENTSCHEIDUNG[korb]
+        raus: list[str] = []
+        for regel in quelle.get(korb, []):
+            if regel.get("tool") != "exec":
+                continue
+            gerendert = _policy_zeile(regel, man, entscheidung)
+            if gerendert and gerendert not in raus:
+                raus.append(gerendert)
+        if not raus:
+            continue
+        zeilen.append("# --- " + korb + " -> " + entscheidung + " ---")
+        zeilen.extend(raus)
+        zeilen.append("")
+    return "\n".join(zeilen).rstrip("\n") + "\n"
+
+
+def permissions_format(man: dict) -> str:
+    """Ausgabeform der Berechtigungsdatei dieses Packs ('json', 'toml', 'kiro-agent',
+    'cursor-json').
+
+    Der Standard ist 'json': Zwei der fuenf Packs fuehren ihn, und ein fehlendes Feld
+    darf nicht die neue Form bedeuten - ein Pack soll seine Form SAGEN und sie nicht
+    durch Schweigen erben.
+    """
+    return man.get("permissions_format", "json")
+
+
+# ---------------------------------------------------------------------------
+# Dritte Ausgabeform: das Agentenprofil mit Faehigkeitsregeln (kiro)
+# ---------------------------------------------------------------------------
+#
+# WARUM ES SIE GIBT, UND DER GRUND IST GEMESSEN (CR-2026-150, D-414). Der Client kiro
+# fuehrt seine Berechtigungen als Regeln der Gestalt {capability, match, effect} - und
+# die Datei, die ein Projekt dafuer im Arbeitsbereich halten koennte, liegt NICHT im
+# Repositorium, sondern je Arbeitsplatz unter ~/.kiro/workspace-roots/<hash>/. Der
+# einzige versionierbare Traeger ist das Feld `permissions` eines Agentenprofils unter
+# .kiro/agents/. Gemessen am 2026-09-26 mit kiro-cli 2.24.1, Engine V3:
+#   * Ein deny im Agentenprofil weist ab und nennt sich ("Source: agent-profile").
+#   * Das Profil wirkt nur, wenn es der AKTIVE Agent ist. Die Arbeitsbereichsdatei
+#     .kiro/settings/cli.json waehlt ihn (chat.defaultAgent) und schlaegt eine globale
+#     Einstellung; render_client_settings() erzeugt sie.
+#   * Fehlt das Profil oder ist es kein gueltiges JSON, faellt der Client STILL auf
+#     seinen eingebauten Agenten zurueck - nur eine Warnung auf stderr, und .env war
+#     lesbar. Pruefung 96 haelt deshalb Einstellung und Profil gegeneinander.
+#   * Eine Regel mit unbekannter Faehigkeit wird uebersprungen, gemeldet nur im
+#     Protokoll des Clients. Diese Abbildung erzeugt deshalb nur Faehigkeiten aus
+#     KIRO_FAEHIGKEITEN, und Pruefung 96 liest dieselbe Menge.
+#   * Befehlsmuster: ohne '*' vergleicht der Client WOERTLICH ("echo" sperrte
+#     "echo hallo" nicht). Die Praefixform braucht deshalb das Suffix '*'.
+#   * Ein Pfadmuster ohne Wildcard trifft auch Unterverzeichnisse (".env" sperrte
+#     "sub/.env") - breiter als woertlich, also keine Lockerung.
+
+#: Die Faehigkeiten, die der Client kennt (Herstellerdokumentation, Seite
+#: "Permissions", abgerufen 2026-09-26). Eine Regel ausserhalb dieser Menge wuerde
+#: der Client ueberspringen - gemessen (K23 im Protokoll des Baus).
+KIRO_FAEHIGKEITEN = ("fs_read", "fs_write", "shell", "web_fetch", "web_search", "mcp",
+                     "subagent", "skill", "power", "context", "diagnostics",
+                     "sandbox_network", "all", "builtin", "filesystem")
+
+
+def _kiro_argument(regel: dict, man: dict, korb: str) -> str:
+    verb = regel["tool"]
+    if verb == "exec":
+        return _befehl(regel, man, korb)
+    if verb == "skill":
+        # Ein Aufrufname, kein Pfad, und woertlich: gemessen am 2026-09-26 - die
+        # Freigabe auf einen Namen laesst genau diesen Skill laden, einen anderen nicht.
+        return regel["pattern"]
+    return _muster(regel["pattern"], man)
+
+
+def kiro_regeln(quelle: dict, man: dict) -> list[dict]:
+    """Die Regelmenge des Kerns als Faehigkeitsregeln dieses Clients.
+
+    Je Korb und Faehigkeit EINE Regel mit der Liste ihrer Muster, in der Reihenfolge
+    der Quelle. Dieselben drei Zusicherungen wie bei den anderen Ausgabeformen: deny
+    und ask ohne Zielfaehigkeit brechen ab, die Praefixform ist nachweislich breiter,
+    allow wird nie verbreitert (_befehl).
+    """
+    # AUSNAHMEN INNERHALB EINER REGEL (D-415). Die Kernregel "write <RUNTIME_DIR>/**"
+    # sperrt bei diesem Client auch .kiro/specs/ - und dort legt der Client sein
+    # Planartefakt ab, das nach D-415 der Traeger des Plans ist. Kein Framework-Artefakt,
+    # aber im Schutzbereich einer Kernregel. Ein allow koennte es nicht freigeben
+    # (deny gewinnt); das Feld exclude der Regel nimmt den Teilbaum aus, und nur ihn.
+    # Das Manifest nennt die Ausnahme je Quellregel ("verb muster"), und nur fuer deny.
+    ausnahmen = man.get("permission_rule_exclude") or {}
+    regeln: list[dict] = []
+    for korb in ("deny", "ask", "allow"):
+        gruppen: dict[str, list[str]] = {}
+        einzeln: list[dict] = []
+        for regel in quelle.get(korb, []):
+            schluessel = f"{regel['tool']} {regel.get('pattern', regel.get('command', ''))}"
+            if schluessel in ausnahmen and korb != "deny":
+                raise AbbildungsFehler(
+                    f"{man.get('client', '?')}/manifest.json: permission_rule_exclude nennt "
+                    f"die {korb}-Regel '{schluessel}' - eine Ausnahme ist nur an einem "
+                    f"Verbot zulaessig; an ask oder allow veraenderte sie die Breite einer "
+                    f"Freigabe")
+            ziele = _werkzeuge(man, regel["tool"])
+            if not ziele:
+                if korb in ("deny", "ask"):
+                    raise AbbildungsFehler(
+                        f"{man.get('client', '?')}: keine Faehigkeit fuer "
+                        f"'{regel['tool']}', die {korb}-Regel {regel} liesse sich nur "
+                        f"durch Weglassen abbilden - das waere eine Lockerung")
+                continue
+            argument = _kiro_argument(regel, man, korb)
+            for faehigkeit in ziele:
+                if faehigkeit not in KIRO_FAEHIGKEITEN:
+                    raise AbbildungsFehler(
+                        f"{man.get('client', '?')}/manifest.json: permission_tools nennt "
+                        f"die Faehigkeit '{faehigkeit}', die der Client nicht kennt - er "
+                        f"uebersprange die Regel und meldete es nur im Protokoll (D-414)")
+                if schluessel in ausnahmen:
+                    einzeln.append({"capability": faehigkeit, "match": [argument],
+                                    "exclude": list(ausnahmen[schluessel]),
+                                    "effect": korb})
+                    continue
+                liste = gruppen.setdefault(faehigkeit, [])
+                if argument not in liste:
+                    liste.append(argument)
+        for faehigkeit, muster in gruppen.items():
+            regeln.append({"capability": faehigkeit, "match": muster, "effect": korb})
+        regeln.extend(einzeln)
+    return regeln
+
+
+def kiro_kernregeln(quelle: dict, man: dict) -> list[str]:
+    """Die Kernzusagen als 'faehigkeit muster' - fuer _core_rules_integrity."""
+    raus: list[str] = []
+    for regel in quelle.get("deny", []):
+        if not regel.get("core"):
+            continue
+        argument = _kiro_argument(regel, man, "deny")
+        for faehigkeit in _werkzeuge(man, regel["tool"]):
+            eintrag = faehigkeit + " " + argument
+            if eintrag not in raus:
+                raus.append(eintrag)
+    return raus
+
+
+def render_permissions_kiro(quelltext: str, man: dict) -> str:
+    """Agentenprofil dieses Client Packs aus der neutralen Regelmenge.
+
+    Unbekannte Schluessel (_comment, _core_rules_integrity) nimmt der Client an -
+    gemessen am 2026-09-26: Mit beiden im Profil blieb es der aktive Agent, und sein
+    deny wies ab (K21 im Protokoll des Baus).
+    """
+    quelle = json.loads(quelltext)
+    name = man.get("permission_profile_name")
+    if not name:
+        raise AbbildungsFehler(
+            man.get("client", "?") + "/manifest.json: Feld permission_profile_name "
+            "fehlt - ohne Namen gibt es kein Agentenprofil, das die Einstellungsdatei "
+            "waehlen koennte")
+    kern = core_dir_name(man)
+    pack = man.get("client", "?")
+    kommentar = " ".join([
+        f"Agentenprofil des Frameworks (Ebene 3), erzeugt fuer das Client Pack {pack}.",
+        f"Regelmenge: {kern}/framework/runtime/permissions.json. Abbildung: "
+        f"{kern}/clients/{pack}/manifest.json. Inhaltliche Aenderungen gehoeren dorthin "
+        f"und laufen als Aenderungsantrag.",
+        "Mechanismus: deny vor ask vor allow, ueber alle Ebenen des Clients - ein deny "
+        "an irgendeiner Stelle gewinnt.",
+        "Dieses Profil wirkt NUR als aktiver Agent. Die Datei "
+        + (man.get("client_settings_file") or "?") + " waehlt es als Standard; wer mit "
+        "--agent einen anderen Agenten waehlt, arbeitet ohne diese Regeln. Fehlt diese "
+        "Datei oder ist sie kein gueltiges JSON, faellt der Client still auf seinen "
+        "eingebauten Agenten zurueck (Pruefung 96).",
+        "Platzhalter in spitzen Klammern traegt der Overlay Owner in die match-Listen "
+        "ein. Zusaetzliche Regeln sind nur als deny zulaessig.",
+        "Exakte Mustersemantik: Zeilen B3 und B6 der Faehigkeitsmatrix dieses Client "
+        "Packs.",
+    ])
+    profil: dict = {
+        "_comment": kommentar,
+        "name": name,
+        "description": man.get("permission_profile_description", ""),
+        "tools": list(man.get("permission_profile_tools") or ["*"]),
+        "permissions": {"rules": kiro_regeln(quelle, man)},
+        "_core_rules_integrity": {"deny_must_contain": kiro_kernregeln(quelle, man)},
+    }
+    return json.dumps(profil, indent=2, ensure_ascii=False) + "\n"
+
+
+def render_client_settings(man: dict) -> str:
+    """Die Einstellungsdatei des Arbeitsbereichs, die das Agentenprofil waehlt.
+
+    Ohne Kommentarschluessel: Die Datei ist die Einstellungsablage des Clients und
+    wird von seinem Werkzeug `settings --workspace` geschrieben; ein fremder
+    Schluessel darin ist nicht gemessen. Die Erklaerung steht in der Kernquelle
+    framework/runtime/client-settings.json und in der README der Laufzeitschicht.
+    """
+    werte = man.get("client_settings")
+    if not werte or not isinstance(werte, dict):
+        raise AbbildungsFehler(
+            man.get("client", "?") + "/manifest.json: client_settings fehlt oder ist "
+            "kein Objekt")
+    return json.dumps(werte, indent=2, ensure_ascii=False) + "\n"
+
+
+def render_hooks_kiro(quelltext: str, man: dict) -> str:
+    """Hook-Datei in der Gestalt {version: v1, hooks: [...]}.
+
+    Gemessen am 2026-09-26 in einer interaktiven Sitzung (die Hooks laufen NICHT im
+    Betrieb ohne Rueckfragen - der Client aktiviert sie dort gar nicht):
+      * Der Ausloeser steht je Eintrag; die Namen der Kernquelle (PreToolUse,
+        SessionStart) sind gueltig. "PromptSubmit" aus der Dokumentation ist es nicht.
+      * Der Matcher ist ein REGULAERER AUSDRUCK ueber den Werkzeugnamen - "*" allein
+        kompiliert nicht, und der Eintrag laedt dann ohne Filter nicht.
+      * Das Zeitlimit steht in SEKUNDEN (Schema des Clients).
+      * Exit 2 sperrt die Werkzeugausfuehrung; der Folgeaufruf lief.
+    Kein Kommentarschluessel auf oberster Ebene: Die Erklaerung steht in
+    `description` jedes Eintrags, einem Feld, das das Schema fuehrt.
+    """
+    quelle = json.loads(quelltext)
+    eintraege: list[dict] = []
+    for ereignis, gruppen in quelle.items():
+        if ereignis.startswith("_"):
+            continue
+        for gi, gruppe in enumerate(gruppen):
+            matcher = _hook_matcher(gruppe["on"], man) if "on" in gruppe else None
+            for hi, h in enumerate(gruppe["hooks"]):
+                skript = os.path.basename(h["script"]).rsplit(".", 1)[0]
+                eintrag: dict = {
+                    "name": f"koolie-{skript}",
+                    "description": (f"Hook des Frameworks ({ereignis}), erzeugt aus "
+                                    f"{core_dir_name(man)}/framework/runtime/hooks.json "
+                                    f"fuer das Client Pack {man.get('client', '?')}."),
+                    "trigger": ereignis,
+                }
+                if matcher:
+                    eintrag["matcher"] = matcher
+                eintrag["action"] = {
+                    "type": h["type"],
+                    "command": _hook_befehl(h["script"], man,
+                                            h.get("enforcing") is True,
+                                            h.get("needs_project_paths") is True),
+                }
+                eintrag["timeout"] = h["timeout"]
+                eintraege.append(eintrag)
+    return json.dumps({"version": "v1", "hooks": eintraege},
+                      indent=2, ensure_ascii=False) + "\n"
+
+
+def exec_policy_file(man: dict) -> str | None:
+    """Zielpfad der Befehlsregeldatei - oder None, wenn das Pack keine fuehrt."""
+    return man.get("exec_policy_file")
+
+
+# ---------------------------------------------------------------------------
+# Die Endung der Regeldateien je Pack (seit 1.16.0, CR-2026-155)
+# ---------------------------------------------------------------------------
+#
+# Der Client cursor laedt aus .cursor/rules/ NUR Dateien mit der Endung .mdc - eine
+# .md-Datei dort ignoriert er, gemessen am 2026-09-26 (Kennwort in r2.md stand in
+# keiner Sitzung im Kontext; Herstellerdokumentation QU-1 sagt dasselbe). Die Kernquellen
+# heissen weiter *.md; das Pack nennt die Endung, und jede Stelle, die eine Regeldatei
+# der Ablage beim Namen nennt, fragt hier.
+
+def regel_endung(man: dict) -> str:
+    return man.get("rule_file_ext", ".md")
+
+
+def regeldatei(man: dict, name: str) -> str:
+    """Der Dateiname einer Regel in der Ablage dieses Packs ('20-project-overlay.md'
+    wird bei cursor zu '20-project-overlay.mdc')."""
+    endung = regel_endung(man)
+    if endung != ".md" and name.endswith(".md"):
+        return name[:-3] + endung
+    return name
+
+
+def ist_regeldatei(man: dict, dateiname: str) -> bool:
+    return dateiname.endswith(regel_endung(man))
+
+
+# ---------------------------------------------------------------------------
+# Vierte Ausgabeform: die Berechtigungsdatei des Projekts bei cursor (cursor-json)
+# ---------------------------------------------------------------------------
+#
+# WARUM ES SIE GIBT, UND DER GRUND IST GEMESSEN (CR-2026-155, D-440). Der Client fuehrt
+# Regeln der Gestalt Werkzeug(Muster) wie die erste Ausgabeform - aber drei Dinge
+# schliessen die erste Form aus, alle am 2026-09-26 an cursor-agent 2026.09.26 gemessen:
+#   * Die Projektdatei .cursor/cli.json darf NUR den Schluessel permissions tragen. Mit
+#     _comment und _core_rules_integrity brach der Client mit Exit 1 ab ("unrecognized
+#     keys") - fail-closed, aber ein Pack, das den Client nicht starten laesst, ist ein
+#     Ausfall. Die Kernregeln haelt deshalb Pruefung 97 gegen die Kernquelle.
+#   * Es gibt nur allow und deny, KEINEN Rueckfragekorb. Was nicht erlaubt ist, faellt
+#     bei Befehlen und externen Werkzeugen in die Rueckfrage des Clients - bei Dateien
+#     IM Arbeitsbereich nicht: Geschrieben wird dort ohne Rueckfrage (gemessen, auch ohne
+#     --force). Die Rueckfrageregeln der Kernquelle werden deshalb nicht gerendert; jedes
+#     ihrer Verben muss das Manifest unter permission_ask_ohne_korb erklaeren.
+#   * Ein Pfadmuster wird VERANKERT gegen den ABSOLUTEN Pfad verglichen, und '*' steht
+#     fuer eine beliebige Zeichenfolge ueber Trenner hinweg. Unter Windows traf deshalb
+#     weder 'Read(.env)' noch 'Read(**/.env)' - beide Koeder kamen heraus -, wohl aber
+#     'Read(*\.env)'. Jedes Pfadmuster wird darum in ZWEI Schreibweisen erzeugt, mit
+#     '/' und mit '\', beide mit fuehrendem '*'. Das ist breiter als das Kernmuster
+#     (ein 'AGENTS.md' in einem Unterordner faellt mit darunter) - bei deny eine
+#     Verschaerfung, und allow fuehrt nur '**', das ohnehin alles trifft.
+
+def cursor_pfadmuster(rohmuster: str, man: dict) -> list[str]:
+    """Die Schreibweisen eines Pfadmusters, die der Client gegen den absoluten Pfad trifft."""
+    muster = resolve_placeholders(rohmuster, man)
+    if muster.startswith("<") or muster in ("*", "**"):
+        return [muster]
+    rest = muster[2:] if muster.startswith("./") else muster
+    while rest.startswith("**/"):
+        rest = rest[3:]
+    return ["*/" + rest, "*\\" + rest.replace("/", "\\")]
+
+
+def _cursor_argumente(regel: dict, man: dict, korb: str) -> list[str]:
+    verb = regel["tool"]
+    if verb == "exec":
+        return [_befehl(regel, man, korb)]
+    if verb in ("read", "write"):
+        return cursor_pfadmuster(regel["pattern"], man)
+    # fetch nennt eine Domain, kein Pfad; skill und mcp einen Namen.
+    return [resolve_placeholders(regel["pattern"], man)]
+
+
+def cursor_koerbe(quelle: dict, man: dict) -> dict:
+    """allow und deny in der Schreibweise dieses Clients - ask wird erklaert, nicht erzeugt."""
+    ohne_korb = man.get("permission_ask_ohne_korb") or {}
+    for regel in quelle.get("ask", []):
+        if regel["tool"] not in ohne_korb:
+            raise AbbildungsFehler(
+                f"{man.get('client', '?')}/manifest.json: permission_ask_ohne_korb erklaert "
+                f"das Verb '{regel['tool']}' nicht. Dieser Client kennt keinen Rueckfragekorb; "
+                f"eine Rueckfrageregel, deren Verbleib nicht erklaert ist, waere still "
+                f"entfallen (D-440)")
+    koerbe: dict = {"allow": [], "deny": []}
+    for korb in ("allow", "deny"):
+        for regel in quelle.get(korb, []):
+            ziele = _werkzeuge(man, regel["tool"])
+            if not ziele:
+                if korb == "deny":
+                    raise AbbildungsFehler(
+                        f"{man.get('client', '?')}: kein Werkzeug fuer '{regel['tool']}', die "
+                        f"deny-Regel {regel} liesse sich nur durch Weglassen abbilden - das "
+                        f"waere eine Lockerung")
+                continue
+            for argument in _cursor_argumente(regel, man, korb):
+                for typ in ziele:
+                    eintrag = f"{typ}({argument})"
+                    if eintrag not in koerbe[korb]:
+                        koerbe[korb].append(eintrag)
+    return koerbe
+
+
+def cursor_kernregeln(quelle: dict, man: dict) -> list[str]:
+    """Die Kernzusagen in der Schreibweise dieses Clients - fuer Pruefung 97."""
+    raus: list[str] = []
+    for regel in quelle.get("deny", []):
+        if not regel.get("core"):
+            continue
+        for argument in _cursor_argumente(regel, man, "deny"):
+            for typ in _werkzeuge(man, regel["tool"]):
+                eintrag = f"{typ}({argument})"
+                if eintrag not in raus:
+                    raus.append(eintrag)
+    return raus
+
+
+def render_permissions_cursor(quelltext: str, man: dict) -> str:
+    """Die Berechtigungsdatei des Projekts: {"permissions": {"allow": [...], "deny": [...]}}.
+
+    Kein weiterer Schluessel - der Client verweigert sonst den Start (D-440). Die
+    Erklaerung, die bei den uebrigen Formen in _comment steht, steht in der README der
+    Laufzeitschicht und im Pack.
+    """
+    koerbe = cursor_koerbe(json.loads(quelltext), man)
+    return json.dumps({"permissions": koerbe}, indent=2, ensure_ascii=False) + "\n"
+
+
+def cursor_ignore_muster(quelle: dict, man: dict) -> list[str]:
+    """Die Leseverbote der Kernquelle als Zeilen der Ausschlussdatei (ohne Projektschlitze)."""
+    raus: list[str] = []
+    for regel in quelle.get("deny", []):
+        if regel.get("tool") != "read":
+            continue
+        muster = resolve_placeholders(regel["pattern"], man)
+        if muster.startswith("<") or muster in raus:
+            continue
+        raus.append(muster)
+    return raus
+
+
+def render_ignore_cursor(quelltext: str, man: dict) -> str:
+    """Die Ausschlussdatei des Clients (.cursorignore) aus den Leseverboten der Kernquelle.
+
+    WARUM ES SIE NEBEN DER BERECHTIGUNGSDATEI GIBT (CR-2026-155, D-443). Gemessen am
+    2026-09-26: Das Suchwerkzeug des Clients wertet ein Read-Verbot der
+    Berechtigungsdatei NICHT aus - der Koeder aus secrets/ kam heraus. Mit derselben
+    Angabe in .cursorignore wies der Client das Lesen von .env und sub/.env ab, meldete
+    die Suche im Ordner als ausgefiltert und fand bei der Suche ueber das ganze Projekt
+    nichts. Die Datei spricht die Syntax von .gitignore - relativ zum Projekt und ohne
+    die Trennerfrage der Berechtigungsdatei. Die Shell erreicht sie nicht ('cat .env'
+    lief); das haelt der Schutz-Hook.
+    """
+    kern = core_dir_name(man)
+    kopf = [
+        "# Ausschlussdatei des Frameworks, erzeugt fuer das Client Pack "
+        + man.get("client", "?") + ".",
+        "# Quelle: die Leseverbote in " + kern + "/framework/runtime/permissions.json.",
+        "# Der Client verweigert dem Agenten Lesen und Suchen in diesen Pfaden.",
+        "# Die Datei gehoert dem Projekt: <EXCLUDED_PATHS> hier zusaetzlich eintragen.",
+        "# Eine Zeile des Kerns zu entfernen ist eine Lockerung (Pruefung 97).",
+        "",
+    ]
+    return "\n".join(kopf + cursor_ignore_muster(json.loads(quelltext), man)) + "\n"
+
+
+def render_hooks_cursor(quelltext: str, man: dict) -> str:
+    """Hook-Datei in der Gestalt {version: 1, hooks: {ereignis: [...]}}.
+
+    Gemessen am 2026-09-26 (CR-2026-155, D-441):
+      * Die Ereignisse heissen klein (preToolUse, sessionStart); hook_event_names bildet
+        die Namen der Kernquelle ab.
+      * Der Matcher ist ein regulaerer Ausdruck ueber den Werkzeugnamen.
+      * Ein Hook, der scheitert, laesst die Operation standardmaessig DURCH (fail-open).
+        Ein durchsetzender Hook traegt deshalb failClosed - und dann wertet der Client
+        auch einen Hook OHNE AUSGABE als gescheitert; die Sperrform permission-json
+        antwortet beim Durchlass mit '{}'.
+      * Der Hook-Prozess steht in der Projektwurzel (hook_project_dir_expr ".").
+    """
+    quelle = json.loads(quelltext)
+    namen = man.get("hook_event_names") or {}
+    ergebnis: dict = {}
+    for ereignis, gruppen in quelle.items():
+        if ereignis.startswith("_"):
+            continue
+        if ereignis not in namen:
+            raise AbbildungsFehler(
+                f"{man.get('client', '?')}/manifest.json: hook_event_names kennt das "
+                f"Ereignis '{ereignis}' nicht - der Hook liefe unter keinem Namen, den der "
+                f"Client ausloest")
+        eintraege: list[dict] = []
+        for gruppe in gruppen:
+            matcher = _hook_matcher(gruppe["on"], man) if "on" in gruppe else None
+            for h in gruppe["hooks"]:
+                durchsetzend = h.get("enforcing") is True
+                eintrag: dict = {"command": _hook_befehl(h["script"], man, durchsetzend,
+                                                         h.get("needs_project_paths") is True),
+                                 "timeout": h["timeout"]}
+                if matcher:
+                    eintrag["matcher"] = matcher
+                if durchsetzend and man.get("hook_fail_closed") is True:
+                    eintrag["failClosed"] = True
+                eintraege.append(eintrag)
+        ergebnis[namen[ereignis]] = eintraege
+    return json.dumps({"version": 1, "hooks": ergebnis}, indent=2, ensure_ascii=False) + "\n"