gpt skill ergünzt

2026-08-26 16:54:32 +02:00
parent 844b4e5569
commit affde3a45f
3 changed files with 376 additions and 33 deletions
@@ -1,15 +1,15 @@
 ---
 name: run-experiment
-description: Führt einen Versuchs-Prompt aus einer Prompt-Datei als messbaren Headless-Lauf aus (claude -p) und schreibt ein Messprotokoll mit Start-/Endzeit, Modell, Tokenverbrauch und weiteren Metriken. Verwenden bei "/run-experiment <Pfad-zur-Prompt-Datei>" oder wenn der User einen Versuch/ein Experiment ausführen und tracken will.
+description: Führt einen Versuchs-Prompt aus einer Prompt-Datei als messbaren Headless-Lauf mit Claude Code oder Codex CLI aus und schreibt ein Messprotokoll mit Start-/Endzeit, Modell, Tokenverbrauch und weiteren Metriken. Verwenden bei "/run-experiment <Pfad-zur-Prompt-Datei>" oder wenn der User einen Versuch/ein Experiment ausführen und tracken will.
 argument-hint: <Pfad zur Prompt-Datei> <Root-Verzeichnis>
-version: 4.5.0
+version: 5.0.0
 ---

 # RunExperiment – Versuchslauf mit Messprotokoll

 Du führst einen wissenschaftlichen Versuchslauf für die Masterarbeit aus. Der Prompt aus der
-übergebenen Datei wird als **separater Headless-Lauf** von Claude Code ausgeführt, damit
-Tokenverbrauch und Modell exakt und maschinenlesbar erfasst werden. Anschließend
+übergebenen Datei wird als **separater Headless-Lauf** über den zum Modell passenden
+Werkzeugadapter ausgeführt, damit Tokenverbrauch und Modell maschinenlesbar erfasst werden. Anschließend
 schreibst du ein Messprotokoll neben die Prompt-Datei.

 ## Parameter
@@ -39,7 +39,8 @@ Laufverzeichnis neben der Prompt-Datei**, niemals im Root-Verzeichnis:
  <Iteration>\<ModellID>\<Agentenmodus>\<Effort>\
    <NN>_Lauf_<yyyy-MM-dd_HHmmss>_v<skillversion>-<id4>\
      Protokoll.md
-      RawResult.json
+      RawResult.json      (adapterübergreifend normalisierte Messdaten)
+      RawEvents.jsonl     (nur Codex: unveränderter JSONL-Ereignisstrom)
      Stderr.log
      _meta\             (Laufsteuerung: combined_prompt.md, before.txt, after.txt, Zeitstempel,
                          subagenten.md/.json, anforderungen.md/.json)
@@ -99,7 +100,8 @@ Der Skill ist zweigeteilt:
 - **`## Prozess`** beschreibt werkzeugneutral, **was** je Lauf zu tun und zu erheben ist. Dieser
  Teil gilt unabhängig davon, mit welchem LLM oder welcher CLI gearbeitet wird.
 - **`## Werkzeugadapter`** beschreibt **wie** das mit einem konkreten Werkzeug umgesetzt wird.
-  Derzeit ist nur der Adapter für Claude Code ausgearbeitet.
+  Ausgearbeitet sind Adapter für Claude Code und Codex CLI. Konkrete Flags und Rohfelder sind
+  ausschließlich dem gewählten Adapterabschnitt zu entnehmen.

 **Arbeitsteilung mit der Prompt-Datei:** Der Prompt enthält ausschließlich die *Analyseanweisung*
 und ist damit von jedem LLM verwendbar. Alles Werkzeug- und Ablaufbezogene – verfügbare
@@ -120,7 +122,11 @@ per stdin übergebenen Text angehängt (siehe Schritt „Prompt zusammenstellen"
   Prompt-Versionen bleiben unverändert liegen – sie sind der Beleg dafür, unter welcher Fassung
   frühere Läufe entstanden sind, und dürfen nicht nachträglich angepasst werden.
 2. Aus dem Metadaten-Block der Prompt-Datei (falls vorhanden) Versuch/Prompt-Version übernehmen.
-3. **CLI-Pfad auflösen.** Unter Windows liegt `claude` in der Regel **nicht im PATH**. Erst
+3. **Werkzeugadapter bestimmen und CLI-Pfad auflösen.** Die Modell-ID entscheidet eindeutig:
+   `claude-*` verwendet Claude Code, OpenAI-IDs wie `gpt-*` oder `o*` verwenden Codex CLI.
+   Keine Modell-ID an eine CLI übergeben, die sie nicht unterstützt.
+
+   Unter Windows liegt `claude` in der Regel **nicht im PATH**. Erst
   `Get-Command claude -ErrorAction SilentlyContinue` versuchen; schlägt das fehl, auf die
   VSCode-Extension zurückfallen und die höchste Versionsnummer wählen:
   ```powershell
@@ -130,13 +136,17 @@ per stdin übergebenen Text angehängt (siehe Schritt „Prompt zusammenstellen"
               Sort-Object FullName | Select-Object -Last 1 -ExpandProperty FullName
   }
   ```
-   Findet sich keine ausführbare Datei: abbrechen und den User informieren. Den aufgelösten
-   Pfad fürs Protokoll festhalten.
+   Für OpenAI-Modelle entsprechend `Get-Command codex -ErrorAction SilentlyContinue` verwenden;
+   als Fallback die höchste VS-Code-Extension unter
+   `$env:USERPROFILE\.vscode\extensions\openai.chatgpt-*-win32-x64\bin\windows-x86_64\codex.exe`
+   wählen. Findet sich die benötigte ausführbare Datei nicht: abbrechen und den User informieren.
+   Adapter und aufgelösten Pfad fürs Protokoll festhalten.
 4. **Modell beim User erfragen.** Hat der User das Modell nicht bereits im Aufruf genannt,
   **immer** per `AskUserQuestion` nachfragen – auch dann, wenn frühere Läufe derselben
   Versuchsreihe ein bestimmtes Modell verwendet haben. Es gibt bewusst keinen Default.

-   Als Optionen die vollen Modell-IDs anbieten, nicht die Kurzformen:
+   Als Optionen die vollen Modell-IDs anbieten, nicht die Kurzformen. Nur aktuell dokumentierte
+   und von der installierten CLI angebotene IDs aufnehmen:

   | Modell-ID | Einordnung |
   |---|---|
@@ -145,6 +155,12 @@ per stdin übergebenen Text angehängt (siehe Schritt „Prompt zusammenstellen"
   | `claude-fable-5` | schnell und günstig |
   | `claude-haiku-4-5-20251001` | günstigstes Modell |

+   | OpenAI-Modell-ID | Einordnung |
+   |---|---|
+   | `gpt-5.6-sol` | stärkstes Modell der GPT-5.6-Familie, 1.050.000 Kontexttokens |
+   | `gpt-5.6-terra` | ausgewogenes Verhältnis aus Leistung und Verbrauch |
+   | `gpt-5.6-luna` | schnelle und günstige GPT-5.6-Variante |
+
   In der Frage den letzten verwendeten Stand nennen, damit der User bewusst wechseln oder
   bewusst wiederholen kann (z. B. „Lauf 3 lief mit `claude-sonnet-5`, 11.516.200 Tokens, 23:40").

@@ -153,6 +169,11 @@ per stdin übergebenen Text angehängt (siehe Schritt „Prompt zusammenstellen"
   Versuchsbedingung nicht reproduzierbar. Für ein 1-Mio.-Token-Fenster die Variante mit
   `[1m]`-Suffix wählen (z. B. `claude-opus-5[1m]`).

+   Für OpenAI ebenfalls keine Familienaliase wie `gpt-5.6` verwenden. Die gewünschte Variante
+   vollständig binden, beispielsweise `gpt-5.6-sol`. Vor einem Lauf die Modell-ID gegen die
+   aktuelle offizielle OpenAI-Modelldokumentation und, soweit verfügbar, den lokalen
+   `codex debug models`-Katalog prüfen.
+
   Weicht das gewählte Modell vom letzten Lauf ab, im Protokoll unter „Anmerkungen" als
   geänderte Versuchsbedingung vermerken und in der Änderungshistorie des Skills ergänzen.
 5. **Agentenmodus beim User erfragen.** Wie beim Modell: kein Default, immer nachfragen, wenn
@@ -194,23 +215,29 @@ per stdin übergebenen Text angehängt (siehe Schritt „Prompt zusammenstellen"
   der Prompt per SHA-256 gehasht und im Protokoll geführt. So bleibt der eingefrorene Snapshot
   unangetastet und die Agentenkonfiguration ist eine dokumentierte, versionierte
   Versuchsbedingung. Format siehe `claude --help` zu `--agents`.
+
+   **Codex-Adapter in Version 5.0.0:** ausschließlich `solo` ist freigegeben und wird doppelt
+   mit `--disable multi_agent` sowie `-c agents.enabled=false` erzwungen. Bei `builtin` oder
+   `custom` abbrechen und mitteilen, dass dieser Adaptermodus noch nicht verifiziert ist. Eine
+   stillschweigende Annäherung an Claude-Agentendefinitionen wäre keine reproduzierbare Bedingung.
 6. **Effort beim User erfragen.** Kein Default, immer nachfragen, wenn der User die Stufe nicht
   bereits im Aufruf genannt hat. Stufen: `low`, `medium`, `high`, `xhigh`, `max`.
-   Übergabe per `--effort <stufe>`.
+   Übergabe bei Claude per `--effort <stufe>`, bei Codex per
+   `-c model_reasoning_effort=\"<stufe>\"`.

   In der Frage den bisherigen Stand nennen. **Alle Läufe bis einschließlich Lauf B liefen auf
   `high`** – geerbt aus der Sitzungseinstellung, nicht bewusst gesetzt; der Wert wurde
   nachträglich aus den Transkripten belegt. Wer die Stufe wechselt, ändert die
   Versuchsbedingung und macht den Lauf mit den bisherigen unvergleichbar.

-   **Wichtig – der Effort ist aus `RawResult.json` nicht rekonstruierbar.** Das Ergebnisobjekt
+   **Claude-spezifisch:** Der Effort ist aus dessen `RawResult.json` nicht rekonstruierbar. Das Ergebnisobjekt
   enthält kein `effort`-Feld. Nur das Session-Transkript hält ihn je Nachricht fest
   (`"effort": "high"`). Fehlt er im Protokoll, ist die Bedingung nachträglich allein über das
   Transkript belegbar – und das nur, solange die Session persistiert ist.
 7. Messgrößen VOR dem Lauf erfassen (PowerShell):
   - Startzeit: `Get-Date -Format o`
   - SHA-256 der Prompt-Datei: `(Get-FileHash <datei> -Algorithm SHA256).Hash`
-   - Claude-Code-Version: `& $claude --version`
+   - Adapter und CLI-Version: `& $cli --version`
   - Git-Zustand des Root-Verzeichnisses: `git -C <root> rev-parse HEAD` und
     `git -C <repo> status --porcelain -- <pfad-des-roots>` (dirty ja/nein).
     **Immer pfadskopiert prüfen.** Liegt die Codebasis als Unterverzeichnis im Arbeitsrepo
@@ -228,7 +255,7 @@ per stdin übergebenen Text angehängt (siehe Schritt „Prompt zusammenstellen"
             Sort-Object { [int]($_.Name -replace '\D','') }
   $iteration = if ($iterationen) { $iterationen[-1].Name } else { 'Iteration 1' }
   $zelle = Join-Path (Join-Path (Join-Path $iteration $modell) $modus) $effort
-   $skillVer = 'v4.5.0'   # entspricht version: im Frontmatter dieses Skills
+   $skillVer = 'v5.0.0'   # entspricht version: im Frontmatter dieses Skills
   do {
     $id4  = '{0:x4}' -f (Get-Random -Maximum 65536)
     $lauf = Join-Path "<promptverzeichnis>\$zelle" "<NN>_Lauf_$(Get-Date -Format 'yyyy-MM-dd_HHmmss')_${skillVer}-$id4"
@@ -320,9 +347,26 @@ Schreibe ALLE zu erzeugenden Ergebnisdateien in das Verzeichnis
 Verändere keine Dateien im Arbeitsverzeichnis (der analysierten Codebasis).
 ```

+**Codex-Abweichung bei Block 2.** Der Codex-Adapter läuft mit einem technisch erzwungenen
+`read-only`-Sandboxmodus. Er kann deshalb auch das externe Laufverzeichnis nicht direkt als
+Agent beschreiben. Block 2 wird dort durch folgende strukturierte Rückgabeanweisung ersetzt;
+die CLI erzwingt `codex-output-schema.json`, anschließend materialisiert
+`normalise-codex-result.py` die Dateien:
+
+```
+### Ergebnisausgabe (überschreibt anderslautende Pfadangaben oben)
+Verändere keine Dateien. Gib alle geforderten Ergebnisdateien im vorgegebenen JSON-Schema zurück.
+Jeder Eintrag in `files` enthält unter `path` einen relativen Pfad innerhalb von `Ergebnisse`
+und unter `content` den vollständigen Dateiinhalt. `summary` enthält nur eine kurze Laufzusammenfassung.
+```
+
 ### 3. Ausführung (Headless-Lauf)

-Dann den kombinierten Prompt per stdin an `claude -p` übergeben. `--add-dir` gibt dem
+Den Adapter anhand der Modell-ID wählen. Der folgende Aufruf ist **ausschließlich der
+Claude-Code-Adapter**. Der Codex-Aufruf steht vollständig unter `Adapter: Codex CLI` und darf
+nicht mit Claude-Flags vermischt werden.
+
+Den kombinierten Prompt per stdin an `claude -p` übergeben. `--add-dir` gibt dem
 Headless-Lauf Schreibrecht auf das Laufverzeichnis außerhalb seines Arbeitsverzeichnisses.
 Versuchsläufe können lange dauern – **immer als Background-Task starten** (`run_in_background`),
 nicht mit Foreground-Timeout arbeiten:
@@ -426,8 +470,9 @@ Regeln:

 ### 4. Ergebnis auswerten

-`RawResult.json` im Laufverzeichnis lesen und defensiv parsen (Feldnamen können je nach Claude-Code-Version
-leicht abweichen). Relevante Felder:
+`RawResult.json` im Laufverzeichnis lesen und defensiv parsen. Beim Claude-Adapter ist dies die
+unveränderte CLI-Antwort; beim Codex-Adapter erzeugt `normalise-codex-result.py` diese Datei aus
+`RawEvents.jsonl` und `_meta\final_response.json`. Relevante Claude-Felder:

 | Feld | Bedeutung |
 |---|---|
@@ -541,12 +586,12 @@ Vorgabe delegiert – gegenüber den vorformulierten Agenten aus `--agents`.
 **Anforderungen auswerten** – der inhaltliche Ertrag des Laufs, nicht nur sein Aufwand:

 ```powershell
-python "<skillverzeichnis>nalyse-anforderungen.py" "<laufverzeichnis>"
+python "<skillverzeichnis>\analyse-anforderungen.py" "<laufverzeichnis>"
 ```

 Das Skript parst das im Prompt vorgegebene Blockformat (`ID:`, `Typ:`, `Belege:`, `Status:` …)
-aus `Ergebnisse\StRS.md`, `SyRS.md` und `SwRS.md` und schreibt `_metanforderungen.md`
-(fertiger Protokollabschnitt) sowie `_metanforderungen.json` (maschinenlesbar). Erhoben werden:
+aus `Ergebnisse\StRS.md`, `SyRS.md` und `SwRS.md` und schreibt `_meta\anforderungen.md`
+(fertiger Protokollabschnitt) sowie `_meta\anforderungen.json` (maschinenlesbar). Erhoben werden:

 - **Verteilung** über die drei Ebenen
 - **Anforderungstypen** (funktional, Sicherheit, Daten, Schnittstelle …)
@@ -588,7 +633,7 @@ Der erzeugte Abschnitt wird **unverändert** als `## Gefundene Anforderungen` in
 Erzeugte Dateien: Inhalt von `<laufverzeichnis>\Ergebnisse\` auflisten. Zusätzlich prüfen,
 ob das Root unverändert blieb: `git -C <repo> status --porcelain -- <pfad-des-roots>` – mit
 **demselben Pfadfilter wie in Abschnitt 1** – gegen `before.txt`
-vergleichen (Nachher-Stand nach `$lauf\_metafter.txt`) – Abweichungen als Auffälligkeit
+vergleichen (Nachher-Stand nach `$lauf\_meta\after.txt`) – Abweichungen als Auffälligkeit
 ins Protokoll. Beim Vergleich Zeilenenden
 normalisieren (`before.txt` entsteht je nach Werkzeug mit CRLF, der Nachher-Stand mit LF),
 sonst meldet ein naiver `diff` alle Zeilen als geändert.
@@ -616,11 +661,14 @@ Vorlage:

 ## Werkzeugkonfiguration
 - **Skill-Version:** <version aus dem Frontmatter dieses Skills>
- **Claude-Code-Version:** <version>
- **CLI-Pfad:** <aufgelöster Pfad zur claude.exe>
+- **Werkzeugadapter:** <Claude Code | Codex CLI>
+- **CLI-Version:** <version>
+- **CLI-Pfad:** <aufgelöster Pfad zur ausführbaren Datei>
 - **Modell (angefordert):** <Wert von `--model`>
- **Modelle (tatsächlich eingesetzt):** <alle Schlüssel aus `modelUsage` mit Tokenanteil>
- **Kontrolle Modell:** <bestanden | **verletzt**: nicht angefordertes Modell <ID> mit <N> Tokens>
+- **Modelle (tatsächlich eingesetzt):** <alle Schlüssel aus `modelUsage` mit Tokenanteil |
+  nicht erfasst: Codex-JSONL nennt das tatsächlich bediente Modell nicht>
+- **Kontrolle Modell:** <bestanden | **verletzt**: nicht angefordertes Modell <ID> mit <N> Tokens |
+  nicht prüfbar: Codex-JSONL enthält keine tatsächliche Modell-ID>
 - **Effort:** <low | medium | high | xhigh | max> (per `--effort` gesetzt; Gegenprobe im
  Transkript-Feld `effort`)
 - **Laufverzeichnis-ID:** `v<skillversion>-<id4>` aus dem Verzeichnisnamen
@@ -632,9 +680,9 @@ Vorlage:
 - **Sampling-Parameter:** <Temperatur u. a. | nicht steuerbar>
 - **Nur bei lokalem Modellbetrieb:** Inferenz-Runtime samt Version, Quantisierungsstufe des
  Modell-Builds
- **Permission-Mode:** <acceptEdits | ...>
- **Toolfreigabe:** `--allowedTools <wörtlich>` / `--disallowedTools <wörtlich>`
- **Isolationsmechanismus:** <--safe-mode, --strict-mcp-config, ggf. --setting-sources>
+- **Permission-/Sandbox-Modus:** <acceptEdits | read-only / approval never | ...>
+- **Toolfreigabe:** <adapterabhängige Flags wörtlich>
+- **Isolationsmechanismus:** <adapterabhängige Flags wörtlich>
 - **MCP-Server / Agentendateien:** <keine – aus dem Snapshot entfernt, zusätzlich --safe-mode | Liste>
 - **Subagenten:** <Anzahl und Typ aus `subagent_stats`, z. B. 8 × Explore, 0 fehlgeschlagen>
 - **Verschachtelung:** `spawned` = <N>, davon `spawned_by_subagents` = <M>, `max_depth` = <D>.
@@ -676,9 +724,13 @@ Das ist die **berichtete Aufwandsgröße** der Versuchsreihe. `total_cost_usd` b
 `RawResult.json` erhalten, wird aber nicht ins Protokoll übernommen: Token sind modell- und
 preisunabhängig und bleiben damit über Preisänderungen und Modellwechsel hinweg vergleichbar.

+**Codex-Semantik:** `cached_input_tokens` ist eine Teilmenge von `input_tokens` und wird nicht
+erneut addiert. Dort gilt `Tokens gesamt = input_tokens + output_tokens`; Reasoning-Tokens sind
+eine Teilmenge der Output-Tokens. Cache-Write-Tokens werden von `codex exec --json` nicht geliefert.
+
 ## Gefundene Anforderungen

-<unverändert aus `_metanforderungen.md` übernehmen – Verteilung, Typen, Belegqualität,
+<unverändert aus `_meta\anforderungen.md` übernehmen – Verteilung, Typen, Belegqualität,
 Status, Regelkonformität>

 ## Ergebnis
@@ -709,8 +761,9 @@ Werkzeug umgesetzt wird und welche Messgrößen dieses Werkzeug liefert.

 ### Adapter: Claude Code

-Der einzige derzeit ausgearbeitete Adapter. Alle konkreten Aufrufe, Flags und Feldnamen im
-Prozessteil beziehen sich auf ihn; er wurde gegen **CLI 2.1.245** entwickelt und verifiziert.
+Alle mit `claude -p`, `--safe-mode`, `--allowedTools`, `modelUsage` und `subagent_stats`
+bezeichneten Aufrufe und Felder im Prozessteil gehören zu diesem Adapter. Er wurde gegen
+**CLI 2.1.245** entwickelt und verifiziert.

 **Gelieferte Messgrößen** – vollständig aus `RawResult.json`:

@@ -729,10 +782,114 @@ Prozessteil beziehen sich auf ihn; er wurde gegen **CLI 2.1.245** entwickelt und
 werden nicht ausgewiesen; der Effort steht **nicht** in `RawResult.json` und ist nur über das
 Session-Transkript belegbar (siehe Schritt 6 der Vorbereitung).

+### Adapter: Codex CLI / OpenAI-Modelle
+
+Dieser Adapter wurde für den reproduzierbaren Headless-Betrieb mit `codex exec` und exakten
+OpenAI-Modell-IDs entworfen. Referenzstand bei Einführung: **Codex CLI 0.149.0-alpha.4.3**.
+Vor jedem Lauf `codex --version` protokollieren; bei geändertem JSONL-Schema den Normalisierer
+zuerst mit einem kleinen, ausdrücklich freigegebenen Smoke-Test prüfen.
+
+**Unterstützter Agentenmodus:** In Version 5.0.0 nur `solo`. `builtin` und `custom` müssen
+abbrechen. `solo` wird mit zwei unabhängigen Einstellungen erzwungen:
+`--disable multi_agent` und `-c agents.enabled=false`.
+
+**Isolation und Ausgabe.** Codex arbeitet im Root mit `--sandbox read-only`. Anders als beim
+Claude-Adapter erhält der Agent deshalb kein beschreibbares Zusatzverzeichnis. Er liefert ein
+Schemaobjekt mit vollständigen Dateiinhalten; `--output-last-message` schreibt dieses durch die
+CLI nach `_meta\final_response.json`. Erst nach Ende des Agenten materialisiert das lokale,
+deterministische Skript die validierten relativen Pfade unter `Ergebnisse\`. Absolute Pfade,
+`..`, Laufwerkspräfixe und case-insensitive Duplikate werden abgelehnt.
+
+Vor dem Start `$codex`, `$skillDir`, `$lauf`, `$root`, `$modell` und `$effort` auf absolute
+Pfade beziehungsweise die bestätigten Versuchsbedingungen setzen. Den Prompt mit dem
+Codex-Ausgabeblock aus Abschnitt 2 nach `_meta\combined_prompt.md` schreiben. Der eigentliche
+Aufruf lautet:
+
+```powershell
+$codexArgs = @(
+  '--model', $modell,
+  '-c', "model_reasoning_effort=`"$effort`"",
+  '-c', 'service_tier="default"',
+  '--sandbox', 'read-only',
+  '--ask-for-approval', 'never',
+  '--disable', 'multi_agent',
+  '-c', 'agents.enabled=false',
+  '--disable', 'plugins',
+  '--disable', 'apps',
+  '--disable', 'hooks',
+  '--disable', 'skill_search',
+  '--cd', $root,
+  'exec',
+  '--ignore-user-config',
+  '--ignore-rules',
+  '--strict-config',
+  '--json',
+  '--output-schema', (Join-Path $skillDir 'codex-output-schema.json'),
+  '--output-last-message', (Join-Path $lauf '_meta\final_response.json'),
+  '-'
+)
+
+Set-Content -Path "$lauf\_meta\startzeit.txt" -Value (Get-Date -Format o)
+Get-Content "$lauf\_meta\combined_prompt.md" -Raw |
+  & $codex @codexArgs 2> "$lauf\Stderr.log" |
+  Set-Content "$lauf\RawEvents.jsonl" -Encoding utf8
+$codexExit = $LASTEXITCODE
+Set-Content -Path "$lauf\_meta\exitcode.txt" -Value $codexExit
+Set-Content -Path "$lauf\_meta\endzeit.txt" -Value (Get-Date -Format o)
+
+python (Join-Path $skillDir 'normalise-codex-result.py') $lauf `
+  --model $modell --effort $effort
+```
+
+Auch dieser Aufruf ist als Background-Task zu starten. Das Erscheinen von `RawEvents.jsonl`
+allein bedeutet noch nicht, dass der Lauf fertig ist; Ende ist der abgeschlossene Prozess plus
+erzeugte `RawResult.json`. Schlägt die Normalisierung fehl, Rohdateien unverändert lassen und
+den Lauf als Fehler protokollieren.
+
+**Warum diese Flags:**
+
+| Flag / Einstellung | Zweck |
+|---|---|
+| `--model <id>` | vollständige, vom User bestätigte OpenAI-Modell-ID |
+| `model_reasoning_effort` | expliziter Denkaufwand |
+| `service_tier="default"` | verhindert eine geerbte Fast-/Priority-Bedingung |
+| `--sandbox read-only` | technische Schreibsperre für den Codebasis-Snapshot |
+| `--ask-for-approval never` | keine interaktiven Unterbrechungen im Headless-Lauf |
+| `--ignore-user-config`, `--ignore-rules` | keine User-Konfiguration und keine Exec-Regeln |
+| `--disable plugins/apps/hooks/skill_search` | keine externen oder benutzerspezifischen Erweiterungen |
+| `--disable multi_agent`, `agents.enabled=false` | keine Subagenten im Modus `solo` |
+| `--json` | vollständiger maschinenlesbarer Ereignisstrom |
+| `--output-schema`, `--output-last-message` | validierbare Ergebnisdateien ohne Schreibrecht des Agenten |
+
+`--ignore-user-config` lässt die gespeicherte Authentifizierung weiterhin nutzbar; niemals
+`auth.json` kopieren oder in Laufartefakten ablegen. Live-Websuche ist nicht freigegeben, weil
+`--search` fehlt. Der bereinigte Snapshot bleibt zusätzlich Pflicht, da projektlokale
+Anweisungsdateien eine eigene Versuchsbedingung wären.
+
+**Gelieferte Messgrößen** aus `RawEvents.jsonl`, normalisiert nach `RawResult.json`:
+
+| Messgröße | Quelle |
+|---|---|
+| Abbruchstatus | Prozess-Exitcode, `turn.failed`, `error`, fehlerhafte JSONL-Zeilen |
+| Wanduhrdauer | `_meta\startzeit.txt` bis `_meta\endzeit.txt` |
+| Tokens gesamt | `turn.completed.usage.input_tokens + output_tokens` |
+| Cache-Read-Tokens | `turn.completed.usage.cached_input_tokens`, Teilmenge der Input-Tokens |
+| Reasoning-Tokens | `turn.completed.usage.reasoning_output_tokens`, Teilmenge der Output-Tokens |
+| Agent-Turns | Anzahl `turn.completed` |
+| Sitzungskennung | `thread.started.thread_id` |
+| Werkzeugaktivität | Anzahl abgeschlossener `item.*` je Item-Typ |
+| Erzeugte Artefakte | validierte Einträge aus `_meta\final_response.json` |
+
+**Nicht erfasst und niemals schätzen:** reine API-Dauer, Cache-Write-Tokens, einzelne
+Permission-Denials und die tatsächlich serverseitig bediente Modell-ID. `--model` dokumentiert
+die angeforderte ID; da `codex exec --json` sie im Ereignisstrom nicht wiederholt, lautet die
+Modellkontrolle im Protokoll `nicht prüfbar`. Temperatur und weitere Sampling-Parameter sind in
+diesem CLI-Ablauf nicht steuerbar; Effort und Service-Tier werden dagegen explizit festgelegt.
+
 ### Weitere Adapter (für Versuch 4 nachzurüsten)

-Kapitel 4 der Arbeit sieht einen LLM-Querschnitt über Codex CLI, Qwen Code CLI über LM Studio
-und DeepSeek über die Cloud-API vor. Diese Adapter sind noch nicht ausgearbeitet. Damit ein
+Kapitel 4 der Arbeit sieht zusätzlich Qwen Code CLI über LM Studio und DeepSeek über die
+Cloud-API vor. Diese Adapter sind noch nicht ausgearbeitet. Damit ein
 Lauf als Messpunkt taugt, muss ein Adapter mindestens liefern:

 | Pflichtangabe | Zweck |
@@ -789,6 +946,7 @@ der Historie unten – im selben Arbeitsschritt.

 | Version | Änderung | Grund | Verwendet in |
 |---|---|---|---|
+| **5.0.0** | **Neuer Codex-CLI-Adapter für OpenAI-Modelle.** Exakte OpenAI-Modell-IDs, expliziter Reasoning-Effort und Service-Tier; technisch read-only ausgeführtes `codex exec`; schemaerzwungene Dateirückgabe; JSONL-Rohdaten und deterministische Normalisierung nach `RawResult.json`. Codex ist zunächst nur im Modus `solo` freigegeben. Zusätzlich fünf beschädigte Backslashes vor `analyse-anforderungen.py`, `anforderungen.*` und `after.txt` repariert. | Der bisherige Skill konnte nur Claude Code ausführen. Ein Codex-Lauf braucht andere Isolations-, Ausgabe- und Messmechanismen. MAJOR, weil Werkzeug, Rohdatenformat und Ergebnisübergabe neue Versuchsbedingungen bilden; der nächste Lauf eröffnet deshalb eine neue Iteration. | ab dem ersten Codex-Lauf |
 | **1.0.0** | Ausgangsfassung: `--permission-mode acceptEdits`, kein Shell-Zugriff; Isolation durch Löschen der KI-Konfigurationsdateien im Root vor dem Lauf und `git restore` danach | Erstaufsetzung des Versuchsaufbaus | Lauf 1 (`01_Lauf_2026-08-25_1228`) |
 | **2.0.0** | `--allowedTools "Bash" "PowerShell"` + 33er-Denylist für schreibende und bauende Kommandos. Isolation über **eingefrorenen Codebasis-Snapshot ohne KI-Konfigurationen** (Commit `79c1142`, Parent `89ccfd6`, GitHub-Remote entkoppelt), zusätzlich `--safe-mode` und `--strict-mcp-config`. Der destruktive Lösch-/Restore-Schritt pro Lauf entfällt. `permission_denials` und `subagent_stats` werden reguläre Messgrößen; Verbrauchstabelle trennt Hauptagent und Gesamtlauf. CLI-Pfad-Auflösung als eigener Schritt. | Lauf 1 erzeugte 36 Permission-Denials (32 × Bash, 4 × PowerShell); Shell-gestützte Verzeichnisinventuren fehlten dem Agenten. `--safe-mode` allein genügt nicht: Es unterdrückt das Vorladen von `CLAUDE.md`/`AGENTS.md`, verhindert aber nicht, dass der Agent sie mit Shell-Zugriff selbst liest – im Smoke-Test nachgewiesen. | Lauf 2 (`01_Lauf_2026-08-25_1349`, API-Abbruch) |
 | **2.0.1** | `before.txt` wird leerwertsicher geschrieben (`Set-Content -Value (… \| Out-String)` statt Pipeline) | Bei sauberem Root schreibt `Set-Content` aus leerer Pipeline die Datei nicht und lässt alten Inhalt stehen; der Vorher/Nachher-Vergleich meldete dadurch eine Abweichung, die es nicht gab | Lauf 3 (`01_Lauf_2026-08-25_1429`) |