@renoxar/koolie 1.25.0

package/.koolie/core/clients/cursor/CLIENT_PACK.md

@@ -0,0 +1,229 @@
+# Client Pack `cursor`
+
+| Attribut | Wert |
+|---|---|
+| Modul-ID | `CP-CU` |
+| Ebene | keine – Abbildungsschicht |
+| Version | 0.3.0 |
+| Status | pilot |
+| Owner (Rolle) | `<FRAMEWORK_OWNER>` |
+| Client | Cursor – Kommandozeile (`cursor-agent`, auch `agent`) und IDE; die Agenten in der Cloud des Anbieters fallen unter D-10 und nicht unter dieses Pack |
+| Verbindliche Zielversion | Kommandozeile `2026.09.x`; IDE `3.22.x` (D-112) |
+| Geprüfte Clientversion | Kommandozeile `2026.09.26-dd393fe` – vor dem Messen festgeschrieben (D-117). IDE `3.22.7` installiert, **an keiner Sitzung gemessen** (`K-175`). Konto: Free, Modell `auto` |
+| Stand der Produktbeobachtung | Quellenliste in Anhang 31.4.5 (`QU-1` bis `QU-8`), abgerufen am 2026-09-26. `FW-AK-01` ist für dieses Pack nicht gefahren |
+| Datum der Prüfung | **2026-09-26** – der Bau (`CR-2026-155`, `tests/protocols/2026-09-26-bau-cursor.md`): 24 Läufe an realen Installationen im Betrieb ohne Rückfragen, davon fünf Abnahmeläufe am installierten Pack; Free-Tarif, 0 USD |
+
+> **Belegt, soweit gemessen (Stand 1.16.0).** Die Spalte „Einstufung" nennt die **vorgesehene** Durchsetzungstiefe, die Spalte „Beleg" ihren Nachweisstand: `gemessen` = an diesem Client beobachtet, `[DOK]` = aus der Herstellerdokumentation mit Quellenkennung, `[EMPF]` = Vorgabe des Frameworks, `BELEG OFFEN` = noch nicht belegt, mit Grund und Datum.
+>
+> **Alle sechs Kernzusagen sind `[TECHNISCH]`** – gemessen unter **Windows** an der Kommandozeile. 🔴 **Die Schreibweise der Pfadmuster ist die Bedingung:** Der Client vergleicht ein Muster mit dem **absoluten** Pfad, und die Muster der Herstellerdokumentation (`Read(.env)`, `Read(**/.env)`) ließen den Köder unter Windows durch (Abschnitt 1b).
+>
+> 🔴 **Drei Befunde stehen in keiner Dokumentation:** Ein weiterer Schlüssel in der Berechtigungsdatei lässt den Client nicht starten; ein durchsetzender Hook muss auch beim Durchlass antworten; die Hook-Eingabe beginnt unter Windows mit einem BOM (Abschnitt 1b, H2, H4).
+>
+> **Wer das Pack einsetzt,** liest zuerst Abschnitt 1b und Abschnitt 6.
+
+## 1. Pfadabbildung
+
+| Rolle des Artefakts | Pfad bei diesem Client | Belegstatus |
+|---|---|---|
+| Wurzel-Anweisungsdatei | `AGENTS.md` | **gemessen** (2026-09-26): steht in jeder Sitzung im Kontext, auch im Betrieb ohne Rückfragen |
+| Regeldateien | `.cursor/rules/*.mdc`; Lademodus im Frontmatter (`alwaysApply`, `globs`) | **gemessen:** eine `.mdc`-Datei mit `alwaysApply: true` lädt in jeder Sitzung; 🔴 **eine `.md`-Datei in derselben Ablage lädt nie** |
+| Skills | `.cursor/skills/<name>/SKILL.md` | **gemessen:** ein Skill mit den Frontmatter-Feldern des Frameworks wurde gefunden und gelesen |
+| Subagentenprofile | `.cursor/agents/<name>.md` (Frontmatter `name`, `description`, `readonly`) | `[DOK]` **`QU-5`**; die Wirkung ist Gegenstand von A1 |
+| Berechtigungskonfiguration | `.cursor/cli.json` – **nur** der Schlüssel `permissions` mit `allow` und `deny` (erzeugt aus `framework/runtime/permissions.json`) | **gemessen:** ein `deny` darin weist ab (*„Blocked by permissions configuration"*), auch mit `--force` |
+| Ausschlussdatei | `.cursorignore` – Syntax von `.gitignore`, erzeugt aus den Leseverboten der Kernquelle | **gemessen:** sperrt Lesen **und Suchen**; die Berechtigungsdatei sperrt nur das Lesen (D-443) |
+| Hook-Konfiguration | `.cursor/hooks.json`, Form `{version: 1, hooks: {ereignis: [...]}}` | **gemessen:** lädt auch im Betrieb ohne Rückfragen, in einem vertrauten Arbeitsbereich |
+| Planartefakt | **keines im Repositorium** – der Planmodus des Clients legt seinen Plan außerhalb ab | **gemessen:** `createPlan` mit leerer Ablageadresse; Träger des Plans ist die Planvorlage des Kerns (M4) |
+| MCP-Konfiguration | `.cursor/mcp.json` | `[DOK]` **`QU-2`**; das Framework liefert keinen Server aus. **Gemessen am 2026-09-28** (Stichprobe zu `1.18.0`, D-462): Ein Server mit `"url"` und `"headers"` lädt, die Kopfzeile `"Basic ${env:VARIABLE}"` wird aus der Umgebung gefüllt – die Datei trägt keinen Zugang. Ein Server der Projektdatei braucht eine Freigabe (`agent mcp list`: *needs approval*); `agent mcp enable` meldet sie, im Druckmodus stand der Server trotzdem nicht bereit – erst mit `--approve-mcps`, das **alle** Server freigibt |
+| Projektverzeichnis im Hook-Befehl | **keine Variable – das Arbeitsverzeichnis** | **gemessen:** der Hook-Prozess steht in der Projektwurzel. `CURSOR_PROJECT_DIR` steht in der Umgebung, aber unter Windows läuft das Kommando durch eine PowerShell-Hülle |
+| Nutzerlokale Überschreibung | **kein Mechanismus** | Der Hersteller dokumentiert keine nutzerlokale Wurzel-Anweisung; das Pack liefert keine Beispieldatei aus |
+
+## 1a. Semantikabbildung der Berechtigungen
+
+Die Regelmenge liegt werkzeugneutral im Kern und wird bei der Installation übersetzt (D-18). Dieser Client kennt Regeln der Gestalt `Typ(Muster)` wie die erste Ausgabeform – **aber nur `allow` und `deny`**, und die Datei darf **keinen weiteren Schlüssel** tragen. Die Abbildung ist deshalb eine eigene Ausgabeform (`cursor-json`, D-440).
+
+| Neutrales Werkzeugverb | Regeltyp bei diesem Client | Anmerkung |
+|---|---|---|
+| `read` | `Read(…)` | Jedes Muster in **zwei Schreibweisen** mit führendem `*`: `Read(*/.env)` und `Read(*\.env)` (Abschnitt 1b) |
+| `search` | – | Kein Regeltyp. 🔴 **Das Suchwerkzeug wertet ein `Read`-Verbot nicht aus** – gemessen. Die Lesesperre für die Suche trägt `.cursorignore` (D-443) |
+| `write` | `Write(…)` | Zwei Schreibweisen wie `read`. Deckt das Löschwerkzeug mit – gemessen |
+| `exec` | `Shell(…)` ohne Stern | Das Muster trifft den Befehl und jeden, der mit ihm und einem Leerzeichen beginnt (Programmcode); verkettete Befehle zerlegt der Client – gemessen |
+| `fetch` | `WebFetch(*)` | Das Argument ist eine Domain |
+| `mcp` | – (nur Rückfrage) | Ein MCP-Werkzeug braucht die Freigabe seines Servers (`QU-2`) |
+| `skill` | – | Ein Skill ist bei diesem Client eine Datei, kein Werkzeug mit Berechtigung |
+
+| Weitere Eigenschaft | Wert |
+|---|---|
+| Rückfragekorb | **keiner** – die Rückfrageregeln der Kernquelle erklärt das Manifest (`permission_ask_ohne_korb`) statt sie zu erzeugen |
+| Ebenen | Die Projektdatei wird in die globale Konfiguration gemischt; **Listen ersetzen** dabei die globalen (Programmcode) |
+| Hook-Werkzeugnamen | `Read`, `Grep`, `Shell`, `Write`, `Delete`; das Dateinamenwerkzeug `Glob` löst keinen Hook aus |
+| Pfadfelder der Hook-Eingabe | `file_path` (absolut); `Shell` führt `command` |
+| Sperrform des Schutz-Hooks | `permission-json`: `{"permission": "deny"}` und Exit 2, beim Durchlass `{}` (D-441) |
+
+## 1b. Die vier Bedingungen, unter denen das Pack trägt
+
+**1. Pfadmuster treffen nur mit führendem `*`.** Der Client vergleicht ein Muster **verankert mit dem absoluten Pfad**, und `*` steht dabei für eine beliebige Zeichenfolge über Trenner hinweg (Programmcode). Gemessen unter Windows: `Read(.env)` und `Read(**/.env)` ließen den Köder durch, `Read(*\.env)` und `Read(*.p12)` sperrten. Die Abbildung erzeugt deshalb jedes Pfadmuster zweimal, mit `/` für macOS und Linux und mit `\` für Windows. **Die Schreibweise mit `/` ist nicht gemessen** – sie folgt aus dem Programmcode (`K-176`). ⚠️ Der Preis: Das Muster ist **breiter** als das der Kernquelle – `Write(*/AGENTS.md)` sperrt auch ein `AGENTS.md` in einem Unterordner, und `Read(*/*secret*)` sperrt jede Datei, in deren Pfad `secret` vorkommt, **auch oberhalb des Projekts**. Bei einem Verbot ist das eine Verschärfung; ein Projekt unter einem solchen Pfad kann nichts mehr lesen und merkt es sofort.
+
+**2. Die Berechtigungsdatei trägt nur `permissions`.** Gemessen: Mit `_comment` und `_core_rules_integrity` brach der Client mit Exit 1 ab (*„Unrecognized key(s) in object"*), ebenso bei kaputtem JSON. Das ist **fail-closed** – der Client startet nicht, statt ohne Regeln zu laufen. **Prüfung 97** hält die Datei gegen die Kernquelle, weil sie ihre Kernregeln nicht selbst auflisten kann.
+
+**3. Die Hooks brauchen einen vertrauten Arbeitsbereich und unter Windows den richtigen Start.** Sie laufen in jeder Sitzung, **auch ohne Rückfragen** – anders als bei `kiro`. Unter Windows reicht der Client die Eingabe durch eine PowerShell-Hülle weiter. 🔴 **Mit gesetzter Variable `SHELL`** (Start aus Git Bash) führt er diese Hülle in `bash` aus; sie scheitert, und ein Hook mit `failClosed` sperrt dann **jede** Operation – gemessen. Aus PowerShell oder `cmd` gestartet, laufen die Hooks.
+
+**4. Fremde Konfigurationen laden mit.** Der Client lädt standardmäßig Hooks von Claude Code aus `.claude/settings.json` **und `~/.claude/settings.json`**, Skills aus `.claude/skills/`, `.codex/skills/` und `~/.claude/skills/` und die Datei `CLAUDE.md` der Projektwurzel – gemessen. Der Schalter ist eine Einstellung der IDE (*Third-Party Imports*), nicht des Projekts. `install.py` meldet, was davon auf dem Arbeitsplatz belegt ist (R6).
+
+**Die IDE** liest `.cursor/cli.json` nach der Herstellerdokumentation nicht – sie ist als Konfiguration der Kommandozeile beschrieben (`QU-2`). Hooks, Regeln, Skills und `.cursorignore` gelten laut Dokumentation für beide. **An einer IDE-Sitzung ist nichts davon gemessen** (`K-175`).
+
+## 2. Fähigkeitsmatrix
+
+Einstufung je Zusage: `[TECHNISCH]` erzwungen · `[TEXTUELL]` nur Anweisung · `[NICHT ABBILDBAR]` kein Mechanismus. Regeln in `../README.md` Abschnitt 4. Gemessen ist an der Kommandozeile unter Windows; eine Zeile, die die IDE betrifft, sagt es.
+
+### R – Regelladung
+
+| ID | Zusage des Frameworks | Mechanismus beim Client | Einstufung | Beleg |
+|---|---|---|---|---|
+| R1 | Wurzel-Anweisungsdatei wird ungefragt geladen | `AGENTS.md` steht in jeder Sitzung im Kontext | `[TECHNISCH]` | **gemessen** (2026-09-26): Kennwort aus `AGENTS.md` ohne Werkzeugaufruf genannt; im installierten Pack mit Pfad aufgezählt |
+| R2 | Regeldateien mit Ladebedingungen | `.cursor/rules/*.mdc`, Frontmatter `alwaysApply` und `globs` | `[TECHNISCH]` | **gemessen:** `alwaysApply: true` lädt immer; die vier Regeln des Frameworks standen im installierten Pack im Kontext. 🔴 **Eine `.md`-Datei in der Ablage lädt nie** – die Regeln heißen deshalb `.mdc` (`QU-1`). `model_decision` bildet auf unbedingtes Laden ab – eine Verschärfung |
+| R3 | Regeln an Dateimuster bindbar | `alwaysApply: false` mit `globs` als Liste | `[TECHNISCH]` | **gemessen mit Gegenprobe:** Eine Regel mit `**/*.xyz` stand nach dem Lesen von `probe.xyz` im Kontext, mit `**/*.abc` nicht |
+| R4 | Bekanntes Zeichenlimit | **Vorgabe des Frameworks** – höchstens 40.000 Zeichen für das stets Geladene (D-387) | `[TEXTUELL]` | `[EMPF]`. Der Hersteller empfiehlt Regeln unter 500 Zeilen (`QU-1`); ein Limit ist nicht dokumentiert. Gemessen ist die Last: 13.612 Eingabetoken einer Sitzung mit installiertem Pack gegenüber 10.190 im Minimalbaum |
+| R5 | Die geladenen Regelquellen sind vollständig aufzählbar | Keine Aufzählung des Clients in der Ausgabe; die Sitzung nennt ihre Quellen auf Nachfrage | `[TEXTUELL]` | **gemessen ist nur die Selbstauskunft** der Sitzung (Pfade aller fünf Träger). Eine Auskunft des Modells, keine des Clients |
+| R6 | Keine Importe fremder Werkzeugformate | **Kein Schalter im Projekt.** Der Import von Claude Code (Hooks, Skills, `CLAUDE.md`) ist eine Einstellung der IDE mit Standard „an" | `[NICHT ABBILDBAR]` | **gemessen:** `CLAUDE.md` lud in jeder Sitzung; die Hooks aus `~/.claude/settings.json` liefen an der Kommandozeile mit. **Ersatz, geliefert:** die Meldung von `install.py` über belegte Quellen, einschließlich der nur global abschaltbaren Commit-Attribution, und der Nachschritt zur Einstellung der IDE (Abschnitt 7) |
+
+### S – Skills
+
+| ID | Zusage des Frameworks | Mechanismus beim Client | Einstufung | Beleg |
+|---|---|---|---|---|
+| S1 | Versionierte Skills im Repository | `.cursor/skills/<name>/SKILL.md` | `[TECHNISCH]` | **gemessen:** ein Skill der Ablage wurde gefunden und gelesen, auch mit den Frontmatter-Feldern des Frameworks |
+| S2 | Gezielter Aufruf | `/<name>` in der Sitzung | `[TECHNISCH]` | `[DOK]` **`QU-4`**; gemessen ist nur der Aufruf beim Namen im Auftrag – die Sitzung las den Skill |
+| S3 | Werkzeugbeschränkung je Skill | **Kein Feld.** `allowed-tools`, `permissions` und `triggers` werden angenommen und nicht ausgewertet | `[TEXTUELL]` | **gemessen:** Ein Skill mit `permissions: deny: [edit]` war geladen, und das Schreiben blieb im selben Lauf erlaubt. Was trägt, ist die globale Schicht |
+| S4 | Schreibende Skills nur benutzergetriggert | `disable-model-invocation: true`, übersetzt aus `triggers` | `[TECHNISCH]` | `[DOK]` **`QU-4`**; `BELEG OFFEN` (2026-09-26): die Wirkung des Feldes ist nicht gemessen |
+| S5 | Die geladenen Skills sind aufzählbar | Selbstauskunft der Sitzung | `[TEXTUELL]` | `BELEG OFFEN` (2026-09-26): Die Ausgabe ohne Rückfragen führt keine Liste der Skills |
+
+### B – Berechtigungen
+
+> **`[TECHNISCH]` heißt in diesem Block:** Der Client setzt die Regel durch, **auch im Betrieb, der Rückfragen überspringt** – gemessen: Jedes `deny` hielt mit `--force`. Für dieses Pack kommen **zwei gemessene Bedingungen** hinzu: **die Schreibweise der Pfadmuster** (Abschnitt 1b, Punkt 1) und **eine Datei, mit der der Client startet** (Punkt 2). Die Berechtigungsdatei ist eine Konfiguration der **Kommandozeile**; für die IDE ist sie nicht dokumentiert (`K-175`). **Die zweite Linie ist der Schutz-Hook, die dritte für Lesen und Suchen `.cursorignore`.**
+
+Die mit **Kern** markierten Zeilen entsprechen den Kernzusagen der Kernquelle; Prüfung 97 hält die Datei gegen sie, weil die Datei sie nicht selbst auflisten darf.
+
+| ID | Zusage des Frameworks | Kern | Mechanismus beim Client | Einstufung | Beleg |
+|---|---|---|---|---|---|
+| B1 | Berechtigungen versioniert im Repository | ja | `.cursor/cli.json` und `.cursorignore` im Projekt | `[TECHNISCH]` | **gemessen:** beide Träger liegen im Projekt und wirken ohne Schalter. Mit einem fremden Schlüssel oder kaputtem JSON startet der Client nicht (fail-closed) |
+| B2 | Verweigern vor Rückfragen vor Erlauben | ja | `deny` vor `allow`; was kein `allow` deckt, fragt bei Befehlen zurück | `[TECHNISCH]` | **gemessen:** `deny` auf `.env` schlägt `allow` auf `Read(**)`. Einen Rückfragekorb gibt es nicht (B7) |
+| B3 | Secret-Dateien per Pfadmuster lesegeschützt | ja | `deny Read` in zwei Schreibweisen **und** `.cursorignore` | `[TECHNISCH]` | **gemessen an einer realen Installation:** `.env` und `secrets/pw.txt` abgewiesen, `probe.txt` gelesen – mit der Berechtigungsdatei allein, ohne Hook. 🔴 **Das Suchwerkzeug beachtet das `Read`-Verbot nicht** (Köder aus `secrets/` gefunden); mit `.cursorignore` war die Suche ausgefiltert, und der Schutz-Hook sperrte sie ebenfalls. Groß- und Kleinschreibung unterscheidet das Muster, der Hook nicht |
+| B4 | Framework- und Overlay-Artefakte schreibgeschützt | ja | `deny Write` auf `AGENTS.md`, `.cursor/**`, `.koolie/core/**`; `.cursorignore` schützt der Client selbst. **Das Overlay sperrt seit `1.17.0` allein der Schutz-Hook** (D-448); die Berechtigungsdatei führt es nicht mehr – nachgezählt an einer Installation am 2026-09-29 (D-468) | `[TECHNISCH]` | **gemessen:** Schreiben auf `AGENTS.md`, in `.koolie/core/` und `.cursor/rules/` abgewiesen, Löschen von `OVERLAY.md` abgewiesen (mit `1.16.0`, noch mit der statischen Sperre – über den Hook allein nicht nachgemessen), `neu.txt` angelegt. ⚠️ **Grenze, nicht gemessen:** ein freigegebener lesender `git`-Befehl mit schreibender Option (`git diff --output=<pfad>`) |
+| B5 | CI-, Quality-Gate- und Lockdateien schreibgeschützt | ja | `deny Write` mit den Lockmustern und den Schlitzen `<CI_CONFIG_PATHS>`, `<QUALITY_GATE_CONFIG_PATHS>` | `[TECHNISCH]` | **gemessen am Mechanismus** (Pfadmuster im `deny`, B4); die Schlitze füllt der Overlay Owner in beiden Schreibweisen, die Lockmuster sind nicht einzeln angefahren |
+| B6 | Befehle per Muster verweigerbar | ja | `deny Shell(git push)` und die übrigen Befehlsverbote | `[TECHNISCH]` | **gemessen:** `git push origin main` abgewiesen, auch in `git status && git push origin main`; `rm probe.txt` abgewiesen. ⚠️ **Grenze wie bei allen Packs:** `git -C . push origin main` trifft das Muster nicht – es fiel in die **Rückfrage** und wurde ohne Rückfragekanal abgewiesen |
+| B7 | Schreiboperationen fragen zurück | – | **Kein Rückfragekorb; Dateien im Arbeitsbereich schreibt der Client ohne Rückfrage** | `[NICHT ABBILDBAR]` | **gemessen:** `neu2.txt` angelegt, auch **ohne** `--force`; der Hersteller sagt es selbst (`QU-8`). **Ersatz:** die Schreibverbote (B4, B5), der Schutz-Hook und die Sichtprüfung im Merge Request – eine Rückfrage vor jedem Schreiben gibt es bei diesem Client nicht |
+| B8 | Netzwerkzugriff standardmäßig unterbunden | – | `deny WebFetch(*)` und `deny Shell` auf `curl`, `wget`, `ssh`, `scp` | `[TECHNISCH]` für das Web-Werkzeug und diese vier Programme; `[TEXTUELL]` darüber hinaus | **gemessen:** `curl` abgewiesen; der Webabruf abgewiesen – ob durch das Verbot oder die Rückfrage, sagt die Meldung nicht. ⚠️ Jedes andere netzfähige Programm fragt zurück, ist aber nicht verboten |
+| B9 | Nutzerlokale Konfiguration kann nur verschärfen | – | Die Projektdatei ersetzt die Listen der globalen Konfiguration; ein `deny` gilt in jedem Betriebsmodus | `[TECHNISCH]` | **gemessen:** das `deny` des Projekts hielt mit `--force`; die Ersetzung der Listen ist aus dem Programmcode. ⚠️ **Ein `deny` des Arbeitsplatzes gilt in diesem Projekt nicht mehr**, und die globale Einstellung `approvalMode: unrestricted` überspringt die Rückfragen (M2) |
+| B10 | Externer Abruf auf freigegebene Domains beschränkbar | – | `WebFetch(<domain>)` | `[TECHNISCH]` | `[DOK]` **`QU-2`**. Das Framework nutzt die strengste Form – alles verboten (B8, D-59) |
+
+### H – Hooks
+
+| ID | Zusage des Frameworks | Mechanismus beim Client | Einstufung | Beleg |
+|---|---|---|---|---|
+| H1 | Prüfung vor Werkzeugausführung | `preToolUse` in `.cursor/hooks.json`, Matcher als regulärer Ausdruck über die Werkzeugnamen, seit `1.20.0` mit `MCP:.*`. Bei einem MCP-Werkzeug prüft der Hook den Inhalt gegen die Secret-Muster und die Pfadfelder gegen die Secret-Pfade (D-486); jede Entscheidung steht in `.git/koolie-hook.jsonl`, ohne Inhalt und Pfad (D-487) | `[TECHNISCH]` | **gemessen:** Der Hook läuft bei jedem Lese-, Such-, Schreib-, Lösch- und Shell-Aufruf, **auch ohne Rückfragen**. Bedingungen: ein vertrauter Arbeitsbereich und unter Windows ein Start ohne `SHELL` (Abschnitt 1b). **MCP gemessen am 2026-09-29** (2026.09.28, `tests/protocols/2026-09-29-schutzschicht.md`): Ein MCP-Aufruf löst `preToolUse` aus, `tool_name` ist `MCP:<werkzeug>`; ohne den Matcher erreichte ein Köderwert den Server, mit ihm sperrte der Hook, und eine harmlose Notiz kam an. Daneben feuert `beforeMCPExecution`, das der Hook nicht braucht |
+| H2 | Prüfung kann **blockieren** | `{"permission": "deny"}` und Exit 2; beim Durchlass `{}`; `failClosed: true` | `[TECHNISCH]` | 🔴 **Gemessen, und der schwerste Befund des Hooks** (D-441): Exit 2 sperrt – aber ohne `failClosed` lässt ein Hook, der scheitert, die Operation **durch**, und mit `failClosed` wertet der Client einen Hook **ohne Ausgabe** als gescheitert: Er sperrte jede Operation, auch das Lesen von `probe.txt`. Mit der Form `permission-json` gesperrt: `.env` über Lese-, Such- und Shell-Werkzeug, `AGENTS.md`, `.koolie/core/`, `.cursor/rules/`, `OVERLAY.md`; durchgelassen: `probe.txt`. **Prüfung 86** misst beide Hälften |
+| H3 | Statusmeldung beim Sitzungsstart | `sessionStart` mit `hook-overlay-status.py` | `[TECHNISCH]` | **gemessen:** Framework-Version und Overlay-Status standen wörtlich im Kontext, und die Sitzung arbeitete danach im Modus M1. Die Ausgabe in der Form von Claude Code (`hookSpecificOutput`) übersetzt der Client |
+| H4 | Eingabeschema und Pfadidentität des Schutz-Hooks | Ereignisprüfung, Pfadfeld `file_path`, BOM-feste Eingabe, alle Muster ohne Rücksicht auf Groß-/Kleinschreibung; `hook_fail_closed` steht auf `true`. **Grenze:** Ein Hook prüft **vor** dem Zugriff (D-397) | `[TECHNISCH]` für die Musterprüfung, **mit der Zeitlücke** | **gemessen:** das Schema von `preToolUse` für fünf Werkzeuge. 🔴 **Die Eingabe beginnt unter Windows mit einem UTF-8-BOM** – der Hook scheiterte daran, bis er sie als UTF-8 mit BOM las (D-441). ⚠️ Das Dateinamenwerkzeug `Glob` löst keinen Hook aus; es liefert Namen, keine Inhalte |
+
+### A – Agentenprofile
+
+| ID | Zusage des Frameworks | Mechanismus beim Client | Einstufung | Beleg |
+|---|---|---|---|---|
+| A1 | Rein lesendes Reviewprofil | `.cursor/agents/fw-reviewer.md` mit `readonly: true` | `[TECHNISCH]` | `[DOK]` **`QU-5`** (*„no file edits, no state-changing shell commands"*); `BELEG OFFEN` (2026-09-26): Der Start eines Subagenten ist nicht gemessen |
+| A2 | Rein lesendes Analyseprofil für Modus M1 | Modus `ask` (`--mode ask`, *„read-only"*) | `[TEXTUELL]` | `[DOK]` **`QU-6`**; `BELEG OFFEN` (2026-09-26) für seine Wirkung |
+
+### M – Modi und Sitzungsfreigaben
+
+| ID | Zusage des Frameworks | Mechanismus beim Client | Einstufung | Beleg |
+|---|---|---|---|---|
+| M1 | Standardmodus fragt bei Schreiben und Befehlen zurück | Befehle außerhalb von `allow` fragen zurück; **Schreiben im Arbeitsbereich nicht** | `[NICHT ABBILDBAR]` für das Schreiben, `[TECHNISCH]` für Befehle | **gemessen:** ohne Rückfragekanal wurden `python --version` und `git log` abgewiesen, `neu2.txt` angelegt. **Ersatz:** wie B7 |
+| M2 | Modus ohne Rückfragen ausschließbar | **Kein Ausschluss.** `--force` (`--yolo`) und die globale Einstellung `approvalMode: unrestricted` überspringen Rückfragen; ein `deny` gilt weiter | `[TEXTUELL]` | **gemessen:** jedes `deny` hielt mit `--force`. Das ist mehr als bei den meisten Packs, aber keine Sperre des Modus |
+| M3 | Freigabe auf die Sitzung begrenzbar | Die Freigabe einer Rückfrage kann in die Freigabeliste übernommen werden | `[TEXTUELL]` | `BELEG OFFEN` (2026-09-26): Eine Rückfrage an einen Menschen ist ohne Rückfragekanal nicht messbar. ⚠️ Nach dem Programmcode schreibt die Übernahme in die Konfiguration – über die Sitzung hinaus |
+| M4 | Eigener Planungsmodus für Modus M2 | Modus `plan` (`--plan`); der Plan geht an ein eigenes Werkzeug und liegt **nicht im Repositorium** | `[TEXTUELL]` | **gemessen:** Die Sitzung las, schrieb nichts und legte einen Plan mit leerer Ablageadresse an. Der Träger des Plans ist deshalb die Planvorlage des Kerns (`fw-plan`); anders als bei `kiro` liefert das Pack keine Regel für ein clienteigenes Planartefakt |
+| M6 | Modus mit selbsttätiger Übernahme von Dateiänderungen begrenzbar | Änderungen im Arbeitsbereich übernimmt der Client **immer** selbsttätig | `[NICHT ABBILDBAR]` | **gemessen** (B7) und `[DOK]` **`QU-8`** (*„Changes save immediately to disk"*). **Ersatz:** wie B7 |
+| M7 | Modus, der selbst beurteilt, was sicher ist, begrenzbar | `--auto-review` und `approvalMode: auto-review` (ein Klassifikator des Anbieters) | `[TEXTUELL]` | `[DOK]` **`QU-2`**; `BELEG OFFEN` (2026-09-26) für seine Begrenzbarkeit. Der Hersteller nennt die Modi *„best-effort guardrails rather than a hard security boundary"* (`QU-8`) |
+
+### X – Externe Anbindung
+
+| ID | Zusage des Frameworks | Mechanismus beim Client | Einstufung | Beleg |
+|---|---|---|---|---|
+| X1 | Keine externe Anbindung ohne Einzelfreigabe | Jeder MCP-Server und jeder Werkzeugaufruf braucht eine Freigabe; das Framework liefert keinen Server aus | `[TECHNISCH]` | `[DOK]` **`QU-8`**; **gemessen am 2026-09-28** (D-459, D-462): `Mcp(<server>:<werkzeug>)` in `allow` lässt ein Lesewerkzeug durch; ein Schreibwerkzeug ohne `allow` wird im Druckmodus abgewiesen (*User rejected*) – die Regelschicht hatte es im ersten Versuch schon verweigert, der zweite mit Freigabe im Overlay erreichte die technische Schranke. ⚠️ `--approve-mcps` überspringt die Freigabe des **Servers**, nicht die des Werkzeugs |
+| X2 | Art und Ort der Codebasis-Indexierung bekannt | Kein Mechanismus zur Steuerung bekannt | `[NICHT ABBILDBAR]` | `BELEG OFFEN (dauerhaft)` – von außen nicht zu beobachten (`K-20`, D-292). **Kein Ersatz durch das Framework.** Dokumentiert ist der Privacy Mode (`QU-7`); auf dem Messkonto war er eingeschaltet |
+
+## 3. Zusammenfassung der Durchsetzungstiefe
+
+> **Zählregel (normativ für diese Tabelle):** Eine Zeile zählt bei ihrer **schwächsten** Einstufung (D-47). Prüfung 31 rechnet die Summen aus der Matrix nach.
+
+| Klasse | Anzahl | davon Kernzusagen |
+|---|---|---|
+| `[TECHNISCH]` | **20 von 35** | 6 von 6 (B1 bis B6) |
+| `[TEXTUELL]` | **10 von 35** | 0 von 6 |
+| `[NICHT ABBILDBAR]` | **5 von 35** | 0 von 6 |
+
+**Belegstand:** `BELEG OFFEN` sagen **S4**, **S5**, **A1**, **A2**, **M3**, **M7** und **X1**, dazu **X2** dauerhaft. Gemessen ist an der Kommandozeile unter Windows; die Zeilen der IDE stehen auf der Dokumentation (`K-175`), die Schreibweise der Pfadmuster für macOS und Linux auf dem Programmcode (`K-176`).
+
+## 4. Kernzusagen ohne technische Durchsetzung
+
+**Keine.** Alle sechs Kernzusagen sind `[TECHNISCH]` – unter den Bedingungen aus Abschnitt 1b, die in der Vorbemerkung des B-Blocks stehen, weil sie keine Zeile einzeln betreffen.
+
+## 5. Bekannte Abweichungen im Verhalten
+
+- **Die Berechtigungsdatei trägt nur `permissions`** (`permissions_format` `cursor-json`, D-440). Sie ist JSON mit Regeln der Gestalt `Typ(Muster)`, aber ohne `_core_rules_integrity`, ohne `ask` und mit einer eigenen Musterschreibweise. Deshalb erreichen dieses Pack nicht: **Prüfung 2**, **Prüfung 37**, **Prüfung 42**, **Prüfung 43**, **Prüfung 54** und **Prüfung 72**; nur zum Teil **Prüfung 59** und **Prüfung 89** (ihr Gegenstand (c), die Pfade des Overlays im `deny`, entfällt). An ihre Stelle tritt die Prüfung der Berechtigungsdatei gegen die Kernquelle (Abschnitt 1b, Punkt 2). Der Prüfapparat hält diese Liste gegen seine eigene Liste der formatgebundenen Prüfungen.
+- **Kein Rückfragekorb, und Schreiben im Arbeitsbereich fragt nicht zurück** (B7). Die Rückfrageregeln der Kernquelle erklärt das Manifest; die Befehlsschlitze des Overlays gehören nicht unter `allow`.
+- **Jedes Pfadmuster steht zweimal** und ist breiter als das der Kernquelle (Abschnitt 1b). Ein Projekt, das einen eigenen Pfad sperrt, schreibt ihn ebenso: `Read(*/<pfad>)` und `Read(*\<pfad>)`. Der Validator warnt bei einem Pfadverbot, das nie trifft.
+- **Die Lesesperre steht zweimal**, in der Berechtigungsdatei und in `.cursorignore` – die zweite, weil das Suchwerkzeug die erste nicht beachtet (D-443).
+- **Der Schutz-Hook antwortet auch beim Durchlass** und liest seine Eingabe BOM-fest (D-441).
+- **Regeldateien heißen `.mdc`**; eigene Regeln des Projekts ebenso (`rule_file_ext`).
+- **Die Commit-Attribution lässt sich nur global abschalten** (`attribution.attributeCommitsToAgent` in `~/.cursor/cli-config.json`). Gemessen: Mit dem Standard hängte die Sitzung jedem Commit `Co-authored-by: Cursor <…>` an – gegen Q5; mit `false` nicht.
+
+## 6. Installation und Prüfung
+
+```text
+python .koolie/core/install.py --target /pfad/zum/projekt --client cursor
+python .koolie/core/tests/scripts/validate-framework.py
+```
+
+🔴 **Danach:** Unter Windows die Kommandozeile aus PowerShell oder `cmd` starten, nicht aus Git Bash. Beim ersten Start dem Arbeitsbereich vertrauen. Die Commit-Attribution global auf `false` setzen. Den Import fremder Konfigurationen in der IDE prüfen. `install.py` nennt diese Schritte nach der Installation und meldet belegte fremde Quellen; nach jeder Hebung nennt es, dass `.cursor/cli.json` und `.cursorignore` Saat sind und nicht angefasst werden.
+
+Vor der ersten produktiven Nutzung sind die Basistests des Testkatalogs gegen diesen Client zu fahren und zu protokollieren.
+
+## 7. Anweisungs- und Konfigurationsquellen außerhalb des Projekts
+
+**Pflichtabschnitt** (D-34). Solche Quellen haben nach Regel 2.6 der Prioritätshierarchie **keine Ebene**.
+
+**Erhebungsstand: 2026-09-26**, Kommandozeile `2026.09.26-dd393fe`, erhoben mit der Herstellerdokumentation (`QU-1` bis `QU-5`), dem Programmcode der Kommandozeile, Messläufen mit dem echten und einem leeren Benutzerprofil und `install.py` (`import_channels_report`).
+
+### 7.1 Anweisungsquellen
+
+| Quelle | Ladebedingung | Belegstatus | Maßnahme des Frameworks |
+|---|---|---|---|
+| `CLAUDE.md` der Projektwurzel | in jeder Sitzung neben `AGENTS.md` (Drittimport) | **gemessen** | Auskunft; `install.py` meldet die Datei |
+| Hooks in `.claude/settings.json` und `~/.claude/settings.json` | in jeder Sitzung, neben den Hooks des Projekts (Drittimport) | **gemessen** – sie liefen mit, und unter Git Bash sperrten sie jede Operation | Auskunft; `install.py` meldet sie, wenn die Datei Hooks führt |
+| `~/.claude/skills/`, `~/.codex/skills/`, `.claude/skills/`, `.codex/skills/` | in jeder Sitzung verfügbar (Drittimport) | `[DOK]` `QU-4` | Auskunft; `install.py` meldet sie |
+| `~/.cursor/skills/`, `~/.agents/skills/`, `~/.cursor/agents/` | in jeder Sitzung verfügbar | `[DOK]` `QU-4`, `QU-5` | Auskunft; `install.py` meldet sie |
+| Nutzerregeln und Teamregeln | in jeder Sitzung, in den Einstellungen gepflegt, keine Datei | `[DOK]` `QU-1` | **keine** – nicht aus dem Projekt erreichbar |
+| Eingebaute Skills des Clients (`/create-rule`, `/review` …) | in jeder Sitzung zur Wahl | `[DOK]` `QU-4` | **keine** – nicht abschaltbar |
+
+### 7.2 Konfigurationsquellen
+
+| Quelle | Wirkung | Belegstatus |
+|---|---|---|
+| `~/.cursor/cli-config.json` | globale Konfiguration der Kommandozeile; ihre Listen **ersetzt** die Projektdatei. Führt `approvalMode`, `sandbox` und die **Commit-Attribution** | Programmcode; Attribution **gemessen** |
+| `~/.cursor/hooks.json` | Hooks des Arbeitsplatzes; laufen neben denen des Projekts, ein `deny` gewinnt | `[DOK]` `QU-3` |
+| `~/.cursor/mcp.json` | MCP-Server des Arbeitsplatzes | `[DOK]` `QU-2` |
+| Hooks der Organisation (`C:\ProgramData\Cursor\hooks.json` und Entsprechungen) | höchste Priorität; ein `deny` gewinnt | `[DOK]` `QU-3` |
+| `.cursor/cli.json` in einem **Elternverzeichnis** des Projekts | wird ebenfalls gelesen und eingemischt | Programmcode |
+
+### 7.3 Was dieser Abschnitt nicht leistet
+
+**Eine Auskunft ist keine Schranke**, und ein **Abwesenheitsbeleg altert**. Prüfung 19 prüft die Anwesenheit dieser Auskunft, nicht ihre Richtigkeit.
+
+**Das Entscheidungsprotokoll des Schutz-Hooks ist kein Nachweis gegen den Agenten** (`K-200`, D-487): Es liegt unter `.git/`, der Agent kann es über die Shell ändern, und eine Eingabe, die der Hook nicht lesen kann, hinterlässt keine Zeile.
+
+## 8. Änderungsverlauf
+
+| Version | Datum | Änderung | Autor (Rolle) |
+|---|---|---|---|
+| 0.1.0 | 2026-09-26 | **Angelegt (`CR-2026-155`, D-440 bis D-443).** Das fünfte Client Pack, gebaut mit Zugang zum Client. **Die Berechtigungsdatei trägt nur `permissions`**, und **jedes Pfadmuster steht in zwei Schreibweisen**, weil der Client es mit dem absoluten Pfad vergleicht (D-440); **der Schutz-Hook antwortet auch beim Durchlass und liest BOM-fest** (D-441); **das Suchwerkzeug beachtet kein Leseverbot** – `.cursorignore` trägt es (D-443). **Prüfung 97** neu | `<FRAMEWORK_OWNER>` |
+| 0.2.0 | 2026-09-28 | **Die MCP-Anbindung ist als Stichprobe gemessen** (`CR-2026-157`, D-459, D-462, D-463). Zeile MCP-Konfiguration: `${env:VARIABLE}` in der Kopfzeile, im Druckmodus nur mit `--approve-mcps`. Zeile X1: Freigabe je Werkzeug trägt, ein Schreibwerkzeug ohne `allow` wird abgewiesen. 🔴 Dabei gefunden: Die Hook-Eingabe kam mit **zwei** BOM; der Schutz-Hook entfernte eines und sperrte fail-closed jede Operation – berichtigt für alle Packs (D-463). Das Manifest führt `mcp_permission_rule` (Prüfung 101) | `<FRAMEWORK_OWNER>` |
+| 0.2.1 | 2026-09-29 | Zeile B4 folgt dem Erzeugnis: Die Berechtigungsdatei sperrt das Overlay seit `1.17.0` nicht mehr, das tut allein der Schutz-Hook (D-448); die Zeile nannte die alte Sperre weiter (`CR-2026-158`, D-468) | `<FRAMEWORK_OWNER>` |
+| 0.3.0 | 2026-09-29 | **MCP-Aufrufe erreichen den Schutz-Hook** (`CR-2026-162`, D-486, D-487, `K-184`, `K-192`). Manifest: `hook_tools.mcp` mit `MCP:.*` und `hook_mcp_prefixes`. Zeile H1: MCP über `preToolUse`, gemessen mit einem Köderserver, und das Entscheidungsprotokoll; Abschnitt 7.3: seine Grenze (`K-200`) | `<FRAMEWORK_OWNER>` |

package/.koolie/core/clients/cursor/manifest.json

@@ -0,0 +1,330 @@
+{
+  "_comment": "Maschinenlesbare Pfad- und Semantikabbildung dieses Client Packs. Die menschenlesbare Fassung mit Faehigkeitsmatrix steht in CLIENT_PACK.md. Gemessen am 2026-09-26 mit cursor-agent 2026.09.26-dd393fe (Kommandozeile, Betrieb ohne Rueckfragen mit stream-json-Mitschrift) im Rahmen des Baus (CR-2026-155, tests/protocols/2026-09-26-bau-cursor.md); die IDE 3.22.7 ist installiert und an keiner Sitzung gemessen. VIER DINGE SIND HIER ANDERS ALS BEI DEN UEBRIGEN PACKS, und alle vier sind gemessen: (1) Die Berechtigungsdatei des Projekts traegt NUR den Schluessel permissions - jeder weitere laesst den Client nicht starten. (2) Ein Pfadmuster wird verankert gegen den ABSOLUTEN Pfad verglichen; jedes Muster steht deshalb in zwei Schreibweisen (/ und \\). (3) Es gibt keinen Rueckfragekorb, und Dateien im Arbeitsbereich schreibt der Client ohne Rueckfrage. (4) Die Hook-Eingabe beginnt unter Windows mit einem BOM, und ein durchsetzender Hook muss auch beim Durchlass antworten.",
+  "client": "cursor",
+  "runtime_dir": ".cursor",
+  "root_instruction_file": "AGENTS.md",
+  "permissions_file": ".cursor/cli.json",
+  "permissions_format": "cursor-json",
+  "_permissions_format_note": "Die vierte Ausgabeform (D-440): {\"permissions\": {\"allow\": [...], \"deny\": [...]}} mit Regeln der Gestalt Werkzeug(Muster). Warum nicht die erste Form: Mit den Schluesseln _comment und _core_rules_integrity brach der Client mit Exit 1 ab ('Unrecognized key(s) in object'), ebenso bei kaputtem JSON - fail-closed, gemessen am 2026-09-26. Die Kernregeln haelt Pruefung 97 gegen die Kernquelle. Die Projektdatei wird in die globale Konfiguration GEMISCHT, und Listen ERSETZEN dabei die globalen (Programmcode des Clients): Ein deny des Arbeitsplatzes gilt in diesem Projekt nicht mehr. Die Datei wird aus der Projektwurzel und jedem Elternverzeichnis bis zum Startverzeichnis gelesen.",
+  "ignore_file": ".cursorignore",
+  "_ignore_file_note": "Die zweite Lesesperre (D-443), gemessen am 2026-09-26 (tests/protocols/2026-09-26-bau-cursor.md, Lauf I1): Das Suchwerkzeug wertet ein Read-Verbot der Berechtigungsdatei nicht aus; .cursorignore sperrte Lesen und Suchen, auch in Unterordnern, in der Syntax von .gitignore und damit ohne die Trennerfrage. Erzeugt aus den Leseverboten der Kernquelle, als Saat: Das Projekt traegt <EXCLUDED_PATHS> hier ein. Der Client verbietet dem Agenten selbst, diese Datei zu schreiben (Programmcode). Die Shell erreicht sie nicht - dort sperrt der Schutz-Hook.",
+  "rule_file_ext": ".mdc",
+  "_rule_file_ext_note": "Der Client laedt aus .cursor/rules/ nur .mdc-Dateien - gemessen am 2026-09-26: das Kennwort einer .md-Datei dort stand in keiner Sitzung im Kontext, das einer .mdc-Datei mit alwaysApply: true in jeder (QU-1). clientmap.regeldatei() bildet die Namen der Kernquellen ab.",
+  "skills_dir": ".cursor/skills",
+  "agents_dir": ".cursor/agents",
+  "pack_runtime_dir": ".cursor/rules",
+  "has_rule_triggers": true,
+  "core_skill_prefix": "fw-",
+  "core_paths": [
+    ".cursor/README.md"
+  ],
+  "seed_paths": [],
+  "project_owned_hint": [
+    ".cursor/rules/2N-overlay-<name>.mdc    (Overlay-Regelerweiterungen - Endung .mdc)",
+    ".cursor/rules/40-tech-<name>.mdc       (Packs ohne Quelle im Kern - Endung .mdc)",
+    ".cursor/cli.json                       (Projektwerte, zusaetzliche deny-Regeln)",
+    ".cursorignore                          (Projektpfade zum Ausschluss, zusaetzlich)",
+    ".cursor/skills/prj-*/                  (projektspezifische Skills)",
+    ".koolie/project-overlay/tech-packs/**          (projekteigene Packs)",
+    ".koolie/project-overlay/**                     (das gesamte Overlay)"
+  ],
+  "_post_steps_note": "Schritte, die install.py nach einer Installation und nach einer Hebung zusaetzlich nennt, weil ohne sie ein Teil des Packs nicht traegt - und nichts es meldet.",
+  "post_install_steps": [
+    "Unter Windows die Cursor-Kommandozeile aus PowerShell oder cmd starten, nicht aus Git Bash: Mit gesetzter Variable SHELL fuehrt der Client die Hook-Kommandos in bash aus, sie scheitern, und der Schutz-Hook sperrt dann JEDE Operation (CLIENT_PACK.md Abschnitt 1b).",
+    "Die Hooks laufen nur in einem vertrauten Arbeitsbereich: beim ersten Start in diesem Verzeichnis dem Arbeitsbereich vertrauen (Kommandozeile ohne Rueckfragen: --trust).",
+    "Die Commit-Attribution steht nur in der globalen Konfiguration (~/.cursor/cli-config.json, attribution.attributeCommitsToAgent) - fuer Q5 auf false setzen. Das Projekt kann sie nicht abschalten (CLIENT_PACK.md Zeile R6).",
+    "Den Import fremder Konfigurationen (Hooks und Skills aus .claude/ und ~/.claude/) in der IDE unter Settings, Agents, Third-Party Imports pruefen; install.py meldet, was davon auf diesem Arbeitsplatz belegt ist."
+  ],
+  "post_update_steps": [
+    "install.py --update fasst .cursor/cli.json nicht an (Saat). Pruefung 97 meldet, wenn sie nicht mehr zur Kernquelle passt oder einen Schluessel traegt, mit dem der Client nicht startet."
+  ],
+  "runtime_placeholders": {
+    "<RUNTIME_DIR>": ".cursor",
+    "<ROOT_INSTRUCTION_FILE>": "AGENTS.md",
+    "<ROOT_INSTRUCTION_LOCAL>": "AGENTS.local.md",
+    "<PERMISSIONS_FILE>": ".cursor/cli.json",
+    "<SKILLS_DIR>": ".cursor/skills",
+    "<RULES_DIR>": ".cursor/rules",
+    "<AGENTS_DIR>": ".cursor/agents",
+    "<HOOKS_FILE>": ".cursor/hooks.json",
+    "<MCP_FILE>": ".cursor/mcp.json",
+    "<CLIENT_NAME>": "Cursor"
+  },
+  "_runtime_placeholders_note": "<ROOT_INSTRUCTION_LOCAL> ist bei diesem Client KEIN Mechanismus - der Hersteller dokumentiert keine nutzerlokale Wurzel-Anweisung, und das Pack liefert keine Beispieldatei aus. Der Name steht hier, weil die Kernquelle ein Schreibverbot auf ihn fuehrt. Gemessen ist dagegen, dass der Client CLAUDE.md der Projektwurzel mitlaedt (Drittimport, Zeile R6).",
+  "root_instruction_local_absent": true,
+  "_root_instruction_local_absent_note": "Das Hauptdokument erklaert an der Stelle der persoenlichen Ergaenzungsdatei, dass es sie bei diesem Pack nicht gibt (build/assemble.py, lokale_ergaenzung).",
+  "permission_tools": {
+    "read": [
+      "Read"
+    ],
+    "search": [],
+    "write": [
+      "Write"
+    ],
+    "exec": [
+      "Shell"
+    ],
+    "fetch": [
+      "WebFetch"
+    ],
+    "mcp": [
+      "Mcp"
+    ],
+    "skill": []
+  },
+  "_permission_tools_note": "Die Regeltypen des Clients (QU-2): Shell, Read, Write, WebFetch, Mcp. search ist leer: Der Client kennt keinen Suchtyp, und die Kernquelle gibt Suchen nur frei - gemessen am 2026-09-26: Das Suchwerkzeug wertet ein Read-Verbot NICHT aus (der Koeder aus secrets/ kam heraus); diesen Kanal haelt allein der Schutz-Hook (H2). skill ist leer: Ein Aufruf eines Skills ist bei diesem Client kein Werkzeug mit Berechtigung - ein Skill ist eine Datei, die gelesen wird. Beide Verben stehen in der Kernquelle nur unter allow; ihr Weglassen faellt auf den strengeren Standard zurueck. Write deckt das Loeschwerkzeug mit - gemessen: ein Write-Verbot auf keep.txt wies das Loeschen ab.",
+  "mcp_permission_rule": {"werkzeug": "Mcp({server}:{werkzeug})", "pauschal": null, "rueckfrage_schlaegt_freigabe": false},
+  "_mcp_permission_rule_note": "Die Regelform eines MCP-Werkzeugs in .cursor/cli.json (Pruefung 101, D-459). Gemessen am 2026-09-28 mit cursor-agent 2026.09.26 (Stichprobe zu 1.18.0): Mcp(<server>:<werkzeug>) in allow laesst ein Lesewerkzeug durch; ein Schreibwerkzeug ohne allow wird im Druckmodus abgewiesen (\"User rejected\"). Es gibt keine pauschale Rueckfrage in der Datei - der Client fragt von sich aus. Im Druckmodus laedt ein Server der Projektdatei nur mit --approve-mcps; agent mcp enable allein genuegte nicht.",
+  "permission_tools_bare": [],
+  "permission_path_prefix": "",
+  "permission_exec_match": "prefix",
+  "permission_exec_suffix": "",
+  "_permission_exec_note": "Die Befehlsseite vergleicht das Muster mit dem Befehl ODER seinem Anfang gefolgt von einem Leerzeichen (Programmcode, matchesShell): 'Shell(git push)' sperrt 'git push origin main' - gemessen, auch in 'git status && git push origin main', weil der Client verkettete Befehle zerlegt. Die Praefixform der Kernquelle braucht deshalb kein Suffix. Grenze wie bei allen Packs: 'git -C . push origin main' trifft das Muster nicht - es faellt in die Rueckfrage (gemessen: ohne Rueckfragekanal abgewiesen), weil kein allow es deckt.",
+  "permission_ask_ohne_korb": {
+    "write": "Kein Rueckfragekorb, und Dateien IM Arbeitsbereich schreibt der Client ohne Rueckfrage - gemessen am 2026-09-26, auch ohne --force. Die Rueckfrage vor dem Schreiben ist deshalb NICHT ABBILDBAR (Zeile B7); was bleibt, sind die Schreibverbote (B4, B5), der Schutz-Hook und die Sichtpruefung im Merge Request.",
+    "exec": "Ein Befehl, den kein allow deckt, faellt in die Rueckfrage des Clients (approvalMode allowlist) - gemessen: ohne Rueckfragekanal abgewiesen. Das ist die Wirkung der Rueckfrageregel, ohne dass sie in der Datei steht; die Befehlsschlitze des Overlays gehoeren deshalb NICHT unter allow.",
+    "mcp": "Ein MCP-Werkzeug braucht die Freigabe seines Servers (QU-2, --approve-mcps ueberspringt sie). Das Framework liefert keinen Server aus."
+  },
+  "permissions_extra": {},
+  "settings_extra": {},
+  "_settings_extra_note": "Ausdrueckliche Abwesenheit, keine Luecke (D-155): Die Projektdatei darf keinen Schluessel neben permissions tragen - der Client startet sonst nicht (D-440). Die Einstellung, die das Framework gern setzte (attribution.attributeCommitsToAgent: false, Q5), steht nur in der globalen Konfiguration; install.py meldet sie (import_channels_report).",
+  "hooks_format": "cursor-v1",
+  "_hooks_format_note": "Gemessen am 2026-09-26: .cursor/hooks.json mit {version: 1, hooks: {ereignis: [...]}}; die Ereignisse heissen klein (hook_event_names); der Matcher ist ein regulaerer Ausdruck ueber den Werkzeugnamen; Zeitlimit in Sekunden. Die Hooks laufen AUCH im Betrieb ohne Rueckfragen (anders als bei kiro), in einem vertrauten Arbeitsbereich. Unter Windows reicht der Client die Eingabe durch eine PowerShell-Huelle weiter - mit gesetzter Variable SHELL (Git Bash) laeuft diese Huelle in bash und scheitert.",
+  "hook_event_names": {
+    "PreToolUse": "preToolUse",
+    "SessionStart": "sessionStart"
+  },
+  "hook_block_form": "permission-json",
+  "_hook_block_form_note": "Die vierte Sperrform (D-441), gemessen am 2026-09-26: Exit 2 sperrt (die Standardform sperrte ebenfalls). ABER: Ein Hook, der scheitert, laesst die Operation standardmaessig DURCH; das Pack setzt deshalb failClosed - und dann wertet der Client einen Hook OHNE AUSGABE als gescheitert und sperrte jede Operation, auch das Lesen einer harmlosen Datei. Die Form permission-json antwortet beim Durchlass mit '{}' und sperrt mit permission deny und Exit 2. Gemessen: .env ueber Lese-, Such- und Shell-Werkzeug gesperrt, AGENTS.md und .cursor/ gegen Schreiben gesperrt, probe.txt gelesen, neu.txt angelegt.",
+  "hook_tools": {
+    "read": [
+      "Read"
+    ],
+    "search": [
+      "Grep"
+    ],
+    "exec": [
+      "Shell"
+    ],
+    "write": [
+      "Write",
+      "Delete"
+    ],
+    "mcp": [
+      "MCP:.*"
+    ]
+  },
+  "hook_mcp_prefixes": ["MCP:"],
+  "_hook_mcp_note": "Gemessen am 2026-09-29 an cursor-agent 2026.09.28 (Messreihe 1.20.0, K-184, D-486): Ein MCP-Aufruf loest preToolUse aus, tool_name ist MCP:<werkzeug> (ohne Servername), tool_input das Argumentobjekt - dasselbe Ereignis und dieselbe Form wie fuer die uebrigen Werkzeuge. Daneben feuert beforeMCPExecution mit mcp_server_name und dem Inhalt als Zeichenkette; der Schutz-Hook braucht es nicht. Die Berechtigungsschicht weist einen MCP-Aufruf ohne Freigabe ab, auch mit --force ('User rejected MCP').",
+  "_hook_tools_note": "Die Werkzeugnamen der Hook-Eingabe, aufgezeichnet am 2026-09-26: Read, Grep, Shell, Write, Delete. Das Suchwerkzeug fuer Dateinamen (Glob) loest KEIN preToolUse aus - gemessen, und fuer Claude-Hooks sagt der Hersteller dasselbe ('Glob' not supported, QU-3); es liefert Dateinamen, keine Inhalte. Das Aendern einer Datei erscheint als Write mit dem ganzen neuen Inhalt.",
+  "hook_path_fields": [
+    "file_path"
+  ],
+  "_hook_path_fields_note": "Aufgezeichnet am 2026-09-26: Read, Grep, Write und Delete fuehren file_path (absolut), Shell fuehrt command. cwd fehlt in der Eingabe oder ist leer; der Hook-Prozess steht in der Projektwurzel, und workspace_roots nennt sie.",
+  "hook_project_dir_expr": ".",
+  "_hook_project_dir_expr_note": "Der Hook-Prozess steht in der Projektwurzel - gemessen am 2026-09-26 (Arbeitsverzeichnis des Prozesses). CURSOR_PROJECT_DIR steht in der Umgebung, aber das Kommando laeuft unter Windows durch eine PowerShell-Huelle, in der $CURSOR_PROJECT_DIR eine Variable von PowerShell waere und leer bliebe.",
+  "hook_fail_closed": true,
+  "_hook_fail_closed_note": "Das Eingabeschema von preToolUse ist am 2026-09-26 aufgezeichnet: tool_name, tool_input, tool_use_id und der Umschlag des Clients (conversation_id, generation_id, model, cursor_version, workspace_roots, user_email, transcript_path, hook_event_name). failClosed steht in der Hook-Datei und --fail-closed im Kommando.",
+  "skill_frontmatter": {
+    "tools_format": "list",
+    "tool_names": {},
+    "_tool_names_note": "LEER, UND DAS IST DIE AUSSAGE: Kein Verb ist abgebildet, alle fuenf stehen in tool_names_unmapped. Der Hersteller dokumentiert fuer SKILL.md die Felder name, description, paths, disable-model-invocation, icon, color und metadata - kein Werkzeugfeld (QU-4).",
+    "tool_names_unmapped": [
+      "read",
+      "grep",
+      "glob",
+      "edit",
+      "exec"
+    ],
+    "_tool_names_unmapped_note": "Gemessen am 2026-09-26 (tests/protocols/2026-09-26-bau-cursor.md, Lauf S1): Ein Skill mit den Feldern allowed-tools, triggers und permissions (deny: edit) des Frameworks wurde gefunden und gelesen - und das Schreiben blieb im selben Lauf erlaubt. Die Felder bleiben wirkungslos stehen; was einen Skill begrenzt, ist die globale Schicht (Zeile S3).",
+    "model_invocation_field": "disable-model-invocation",
+    "drop_fields": [],
+    "_drop_fields_note": "LEER, UND DAS IST DIE ENTSCHEIDUNG (Bauform wie kiro): Die zusagentragenden Felder erreichen die installierte Fassung unveraendert; der Client nimmt sie an und wertet sie nicht aus. Die Aussage 'nur benutzergetriggert' wird zusaetzlich in disable-model-invocation uebersetzt (QU-4)."
+  },
+  "shared_core": [
+    {
+      "src": "framework/runtime/root-instruction.md",
+      "dst": "<ROOT_INSTRUCTION_FILE>"
+    },
+    {
+      "src": "framework/runtime/rules/00-framework-core.md",
+      "dst": "<RULES_DIR>/00-framework-core.mdc"
+    },
+    {
+      "src": "framework/runtime/rules/10-privacy-security.md",
+      "dst": "<RULES_DIR>/10-privacy-security.mdc"
+    },
+    {
+      "src": "framework/runtime/rules/15-development-rules.md",
+      "dst": "<RULES_DIR>/15-development-rules.mdc"
+    },
+    {
+      "src": "framework/runtime/agents/fw-reviewer.md",
+      "dst": "<AGENTS_DIR>/fw-reviewer.md"
+    },
+    {
+      "src": "templates/rules/21-overlay-TEMPLATE.md.template",
+      "dst": "<RULES_DIR>/21-overlay-TEMPLATE.mdc.template"
+    },
+    {
+      "src": "templates/rules/40-tech-TEMPLATE.md.template",
+      "dst": "<RULES_DIR>/40-tech-TEMPLATE.mdc.template"
+    },
+    {
+      "src": "framework/runtime/hooks.json",
+      "dst": "<HOOKS_FILE>"
+    }
+  ],
+  "_shared_core_note": "Keine Beispieldatei zur nutzerlokalen Wurzel-Anweisung (kein Mechanismus) und keine zur MCP-Konfiguration. 16-plan-spezifikation.md liefert dieses Pack NICHT aus: Der Planmodus des Clients legt seinen Plan nicht im Repositorium ab (gemessen: createPlan mit leerer planUri) - das Planartefakt ist das des Kerns.",
+  "shared_seed": [
+    {
+      "src": "framework/runtime/permissions.json",
+      "dst": "<PERMISSIONS_FILE>"
+    },
+    {
+      "src": "framework/runtime/permissions.json",
+      "dst": ".cursorignore"
+    },
+    {
+      "src": "framework/runtime/rules/20-project-overlay.md",
+      "dst": "<RULES_DIR>/20-project-overlay.mdc"
+    },
+    {
+      "src": "templates/project-overlay",
+      "dst": ".koolie/project-overlay"
+    }
+  ],
+  "rule_frontmatter": "yaml",
+  "rule_triggers": {
+    "condition_field": "globs",
+    "condition_format": "list",
+    "allowed_fields": [
+      "alwaysApply",
+      "globs"
+    ],
+    "map": {
+      "always_on": {
+        "condition": null,
+        "fixed": {
+          "alwaysApply": "true"
+        }
+      },
+      "model_decision": {
+        "condition": null,
+        "fixed": {
+          "alwaysApply": "true"
+        },
+        "hint": "Wird bei jedem Sitzungsstart geladen (`alwaysApply: true`). Dieser Client kennt einen Lademodus nach Beschreibung; das Pack nutzt ihn nicht, weil seine Wirkung nicht gemessen ist – gegenüber `model_decision` ist unbedingtes Laden eine Verschärfung, keine Lockerung."
+      },
+      "glob": {
+        "condition": "globs",
+        "from": "globs",
+        "fixed": {
+          "alwaysApply": "false"
+        }
+      }
+    }
+  },
+  "_rule_triggers_note": "Gemessen am 2026-09-26: Eine .mdc-Datei mit alwaysApply: true steht in jeder Sitzung im Kontext; eine mit alwaysApply: false und globs als YAML-Liste laedt, sobald eine passende Datei gelesen wird, und nicht bei einer unpassenden (Gegenprobe). Die Schreibweise als Zeichenkette wirkte ebenfalls; das Pack nutzt die Liste.",
+  "root_instruction_imports": [],
+  "agent_frontmatter": {
+    "tools_field": "tools",
+    "tools_format": "list",
+    "tool_names": {},
+    "tool_names_unmapped": [
+      "read",
+      "grep",
+      "glob",
+      "edit",
+      "exec"
+    ],
+    "readonly_field": "readonly",
+    "_tool_names_note": "Ein Subagentenprofil dieses Clients kennt kein Werkzeugfeld, sondern readonly (QU-5: 'no file edits, no state-changing shell commands'). Ein Profil, dessen Werkzeugliste weder edit noch exec nennt, bekommt readonly: true, und die Liste entfaellt. Die Wirkung ist Gegenstand von Zeile A1.",
+    "_tool_names_unmapped_note": "Der Hersteller dokumentiert fuer ein Subagentenprofil kein Werkzeugfeld, sondern readonly (QU-5); die Verben werden deshalb nicht in Namen uebersetzt, sondern entscheiden allein, ob readonly: true gesetzt wird (readonly_field). Die Wirkung von readonly ist unerhoben - Zeile A1 sagt BELEG OFFEN."
+  },
+  "agent_start_tools": [
+    "Task"
+  ],
+  "_agent_start_tools_note": "Der Hersteller nennt das Werkzeug, das einen Subagenten startet, Task (QU-5); das Ereignis subagentStart gilt ihm. Gemessen ist der Start nicht.",
+  "_import_control_note": "Kein Feld import_control, und das ist eine Aussage: Der Schalter fuer den Import fremder Konfigurationen ('Include Third-Party Plugins, Skills, and Other Configs', Standard an) ist eine Einstellung der IDE und nicht des Projekts; in der Konfiguration der Kommandozeile gibt es keinen (Programmcode). Gemessen am 2026-09-26: Die Hooks aus ~/.claude/settings.json des Arbeitsplatzes liefen in der Kommandozeile mit - und sperrten, weil sie unter diesem Client scheiterten, jede Shell- und Schreiboperation. CLAUDE.md der Projektwurzel lud in jeder Sitzung.",
+  "import_channels_intro": "Der Client laedt neben dem Projekt eigene Ablagen im Benutzerprofil und die Konfiguration von Claude Code (Drittimport, Standard an),",
+  "import_channels_report": [
+    {
+      "path": "~/.claude/settings.json",
+      "scope": "user",
+      "when": "json_key",
+      "key": "hooks",
+      "what": "Hooks von Claude Code - laufen in JEDER Cursor-Sitzung mit (gemessen); ein Hook, der dort scheitert, kann jede Operation sperren"
+    },
+    {
+      "path": "~/.claude/skills",
+      "scope": "user",
+      "when": "entries",
+      "what": "Skills von Claude Code - stehen in jeder Cursor-Sitzung zur Verfuegung"
+    },
+    {
+      "path": "~/.codex/skills",
+      "scope": "user",
+      "when": "entries",
+      "what": "Skills von Codex - stehen in jeder Cursor-Sitzung zur Verfuegung"
+    },
+    {
+      "path": "~/.agents/skills",
+      "scope": "user",
+      "when": "entries",
+      "what": "globale Skills im offenen Format - stehen in jeder Sitzung zur Verfuegung"
+    },
+    {
+      "path": "~/.cursor/skills",
+      "scope": "user",
+      "when": "entries",
+      "what": "globale Skills des Clients - stehen in jeder Sitzung zur Verfuegung"
+    },
+    {
+      "path": "~/.cursor/hooks.json",
+      "scope": "user",
+      "when": "exists",
+      "what": "Hooks des Arbeitsplatzes - laufen neben denen des Projekts; ein deny gewinnt"
+    },
+    {
+      "path": "~/.cursor/agents",
+      "scope": "user",
+      "when": "entries",
+      "what": "globale Subagenten - stehen in jeder Sitzung zur Verfuegung"
+    },
+    {
+      "path": "~/.cursor/mcp.json",
+      "scope": "user",
+      "when": "exists",
+      "what": "MCP-Server des Arbeitsplatzes"
+    },
+    {
+      "path": "~/.cursor/cli-config.json",
+      "scope": "user",
+      "when": "json_not",
+      "key": "attribution.attributeCommitsToAgent",
+      "value": false,
+      "what": "Die Commit-Attribution ist NICHT abgeschaltet: Die Sitzung haengt jedem Commit 'Co-authored-by: Cursor' an (gemessen) - gegen Q5. Abhilfe: attribution.attributeCommitsToAgent auf false"
+    },
+    {
+      "path": "CLAUDE.md",
+      "scope": "project",
+      "when": "exists",
+      "what": "Wurzel-Anweisung von Claude Code - laedt in jeder Cursor-Sitzung neben AGENTS.md (gemessen)"
+    },
+    {
+      "path": ".claude/settings.json",
+      "scope": "project",
+      "when": "json_key",
+      "key": "hooks",
+      "what": "Hooks von Claude Code im Projekt - laufen in jeder Cursor-Sitzung mit; bei installiertem Pack claude-code also der Schutz-Hook zweimal"
+    },
+    {
+      "path": ".claude/skills",
+      "scope": "project",
+      "when": "entries",
+      "what": "Skills von Claude Code im Projekt - stehen in jeder Cursor-Sitzung zur Verfuegung"
+    }
+  ],
+  "_import_channels_report_note": "Auskunft, keine Schranke (Bauform von D-411): install.py nennt nach Installation und Hebung, welche Quellen belegt sind. json_key meldet eine Datei, die den Schluessel fuehrt; json_not einen Wert, der nicht der genannte ist - auch einen fehlenden, weil dann der Standard des Clients gilt. Welche Wirkung jede Quelle hat, steht in Abschnitt 7 des Packs."
+}

package/.koolie/core/clients/cursor/root-template/.cursor/README.md

@@ -0,0 +1,36 @@
+# Laufzeitschicht `.cursor/` – was hier liegt und wem es gehört
+
+Diese Ablage ist die **Laufzeitform** des Frameworks für den Client `cursor`. Die kanonische, werkzeugneutrale Langform steht in `.koolie/core/framework/`; was hier liegt, ist daraus erzeugt (D-02). **Inhaltliche Änderungen gehören in den Kern und laufen als Änderungsantrag** (`.koolie/core/governance/CHANGE_REQUEST_TEMPLATE.md`).
+
+## Was hier liegt
+
+| Pfad | Inhalt | Wem es gehört |
+|---|---|---|
+| `../AGENTS.md` | Wurzel-Anweisung (Ebene 1); der Client lädt sie in jeder Sitzung | Framework |
+| `rules/00-*.mdc`, `rules/10-*.mdc`, `rules/15-*.mdc` | Regeltexte des Frameworks (Ebene 3) mit `alwaysApply: true` – sie laden immer | Framework |
+| `rules/20-project-overlay.mdc` | Laufzeitfassung des Project Overlays (Ebene 4) | Projekt |
+| `rules/40-tech-*.mdc`, `rules/30-*.mdc` | Technology und Role Packs (Ebenen 5 und 6); eine an Dateimuster gebundene Regel trägt `alwaysApply: false` und `globs` | Projekt |
+| `cli.json` | **Berechtigungen** des Frameworks, dazu die Projektwerte | Projekt (aus dem Kern erzeugt) |
+| `hooks.json` | Schutz-Hook und Statusmeldung | Framework |
+| `agents/fw-reviewer.md` | Nur lesender Review-Subagent (`readonly: true`) | Framework |
+| `skills/fw-*/` | Skills des Frameworks | Framework |
+
+## Vier Dinge, die bei diesem Client anders sind
+
+**1. Regeldateien brauchen die Endung `.mdc`.** Eine `.md`-Datei in `rules/` lädt der Client nicht. Eigene Regeln des Projekts heißen deshalb `2N-overlay-<name>.mdc` und `40-tech-<name>.mdc`.
+
+**2. `cli.json` trägt nur den Schlüssel `permissions`.** Jeder weitere Schlüssel – auch ein Kommentar – lässt den Client nicht starten; ebenso kaputtes JSON. Die Erklärung der Datei steht deshalb hier und nicht in ihr. Ein Pfadmuster steht **zweimal**, einmal mit `/` und einmal mit `\`: Der Client vergleicht es mit dem absoluten Pfad, und unter Windows trägt dieser Gegenschrägstriche. Wer einen Projektpfad sperrt (`<EXCLUDED_PATHS>`, `<READ_ONLY_PATHS>` …), trägt ihn ebenfalls in beiden Schreibweisen ein, mit führendem `*`: `Read(*/geheim/*)` und `Read(*\geheim\*)`.
+
+**3. Dateien im Arbeitsbereich schreibt der Client ohne Rückfrage.** Es gibt keinen Rückfragekorb. Befehle, die kein `allow` deckt, fragen zurück; Schreiben nicht. Die Schreibverbote dieser Datei und der Schutz-Hook bleiben die Schranke, der Merge Request die Sichtprüfung.
+
+**4. Die Hooks brauchen unter Windows den richtigen Start.** Aus PowerShell oder `cmd` gestartet, laufen sie; aus Git Bash gestartet (Variable `SHELL` gesetzt), scheitern sie – und der Schutz-Hook sperrt dann jede Operation. Sie laufen nur in einem Arbeitsbereich, dem der Client vertraut.
+
+## Was hier **nicht** liegt
+
+Keine Geheimnisse, keine Zugangsdaten, keine Kunden- oder Personennamen. Die Regeln dazu stehen in `rules/10-privacy-security.mdc`; der Validator prüft es, und der Schutz-Hook blockiert eine Werkzeugeingabe, die ein Muster dieser Kategorien trägt.
+
+## Prüfen
+
+```text
+python .koolie/core/tests/scripts/validate-framework.py --strict-overlay
+```