session orchestratorv5.20.0

ENDE

32 Befehle · Claude Code · Codex CLI · Cursor IDE · Pi

Welcher Befehl hilft mir gerade?

Such dir aus, was du tun willst. Jeder Befehl unten sagt, wann du ihn nutzt, was du bekommst, wie du ihn tippst und was danach passiert.

Ich will …

So tippst du einen Befehl in deinem Coding-Tool

Wie jedes Coding-Tool einen Befehl ausführt
Claude CodeTippe /name in den Chat. Im Headless-Modus claude -p brauchen nur /session und /plan die lange Form, zum Beispiel /session-orchestrator:session deep.
Codex CLIWähle den Skill im Codex-Chat: $session-orchestrator:name. Es ist kein Shell-Befehl. Das einfache /go und /close funktioniert dort nicht, und Codex startet go oder close nie von selbst.
Cursor IDETippe /name. Die Agents arbeiten nacheinander.
PiTippe /name. Jeder Befehl ist eine Prompt-Vorlage.

Hier anfangen

Sechs Befehle reichen für deine ersten Sessions. Lerne diese und lass den Rest liegen, bis du ihn brauchst.

/bootstrap Hier anfangen

Wann
Du nutzt session-orchestrator zum ersten Mal in einem Repository.
Du bekommst
Eine CLAUDE.md (auf Codex und Pi AGENTS.md) mit einer Session Config und der Mindeststruktur für das Repository, committet. Du siehst die angelegten Dateien und den Commit-Hash.
Eingabe
Claude Code
/bootstrap [--upgrade <tier>]
Codex
$session-orchestrator:bootstrap
Cursor
/bootstrap
Pi
/bootstrap
Wirkung
Committet fragt vorher 7 bis 9 Fragen zur Einrichtung; /bootstrap --fast --no-interview überspringt sie und nimmt sinnvolle Standardwerte
Braucht
Ein Git-Repository.
Danach
Starte mit /session feature deine erste Session.

Quelle: skills/bootstrap/SKILL.md

/session Hier anfangen

Wann
Du setzt dich an die Arbeit in einem Repository und willst wissen, was als Nächstes dran ist.
Du bekommst
Es liest dein Repository (Git-Stand, Issues, CI, Umgebung) und schlägt vor, woran du arbeitest. Nichts ändert sich, bis du zustimmst.
Modi
  • housekeeping aufräumen und pflegen
  • feature eine klare Funktion bauen (am besten für die erste Session)
  • deep große oder unklare Änderung: erst untersuchen, dann bauen (der Standard)
  • ultradeep ein optionales, längeres Profil von deep für eine benannte Forschungsfrage; kein vierter Typ
Eingabe
Claude Code
/session [housekeeping|feature|deep|ultradeep] [task]
Codex
$session-orchestrator:session deep
Cursor
/session deep
Pi
/session
Wirkung
Ändert Dateien fragt vorher nur den Session-Stand (STATE.md, Session-Sperre); Code wartet auf /go
Braucht
/bootstrap ist erledigt. Gibt es noch keinen Session-Verlauf, fragt ein einfaches /session zuerst nach Aufgabe und Modus.
Danach
Stimme dem Plan mit /go zu.

Quelle: commands/session.md

/go Hier anfangen

Wann
Du hast den Session-Plan gelesen und bist einverstanden.
Du bekommst
Die vereinbarte Arbeit, erledigt in Runden (Waves). Jede Runde wird mit deinen Tests geprüft, und du bekommst eine Zusammenfassung des Fortschritts.
Eingabe
Claude Code
/go [instructions]
Codex
$session-orchestrator:go
Cursor
/go
Pi
/go
Wirkung
Ändert Dateien ändert Code nach dem Plan; ohne Plan tut es nichts
Braucht
Einen Plan aus /session in diesem Chat, oder die pausierte STATE.md dieser Session.
Danach
Tippe /close, wenn die Runden fertig sind.

Quelle: skills/go/SKILL.md

/close Hier anfangen

Wann
Die Arbeit dieser Session ist fertig und du willst sie abschließen.
Du bekommst
Die volle Prüfung, einen sauberen Commit, Issues für das, was offen bleibt, und eine Zusammenfassung der Session.
Eingabe
Claude Code
/close
Codex
$session-orchestrator:close
Cursor
/close
Pi
/close
Wirkung
Committet legt auch Issues an und pusht, wenn das so eingestellt ist; verweigert sich, wenn die STATE.md einer anderen Session gehört
Braucht
Eine aktive Session von dir. Argumente werden ignoriert.
Danach
Starte die nächste Session mit /session.

Quelle: skills/close/SKILL.md

/plan Hier anfangen

Wann
Du willst ein neues Projekt oder eine Funktion planen, oder auf eine abgeschlossene Phase zurückschauen.
Du bekommst
Eine recherchierte Fragerunde, danach ein PRD oder ein Retro-Dokument und priorisierte Issues.
Modi
  • new ein neues Projekt: legt auch das Repository an und committet
  • feature eine Funktion: PRD und Issues
  • retro auf eine abgeschlossene Phase zurückschauen
Eingabe
Claude Code
/plan [new|feature|retro]
Codex
$session-orchestrator:plan feature
Cursor
/plan feature
Pi
/plan
Wirkung
Öffnet Issues fragt vorher schreibt das PRD oder die Retro; new legt auch ein Repository an und committet
Braucht
/bootstrap ist erledigt. /plan new nutzt plan-baseline-path, wenn gesetzt, sonst die mitgelieferten Vorlagen; feature und retro brauchen es nie.
Welcher
Nur eine Idee: /brainstorm. Umfang bekannt: /plan feature. Ganz klar: /session feature. Das PRD landet standardmäßig in docs/prd/ (plan-prd-location).
Beispiel
Tippe /plan feature. Beantworte die erste Frage (was gebaut werden soll) mit deiner Aufgabe, zum Beispiel „Füge der Rechnungsliste einen CSV-Export hinzu“. Das PRD wird nach docs/prd/YYYY-MM-DD-<feature-name>.md geschrieben.
Danach
Wenn du willst, prüfe das PRD mit /grill, dann baust du es mit /session feature.

Quelle: skills/plan/SKILL.md

/evolve Hier anfangen

Wann
Nach ein paar Sessions willst du aus dem lernen, was gut oder schlecht lief.
Du bekommst
Vorgeschlagene Lehren aus deinen früheren Sessions. Du entscheidest, welche du behältst.
Modi
  • analyze Lehren vorschlagen (Standard)
  • review gespeicherte Lehren bearbeiten
  • list gespeicherte Lehren zeigen
  • dialectic USER.md und AGENT.md aktualisieren, nur mit --apply
Eingabe
Claude Code
/evolve analyze
Codex
$session-orchestrator:evolve analyze
Cursor
/evolve analyze
Pi
/evolve
Wirkung
Ändert Dateien fragt vorher speichert eine Lehre erst, wenn du sie bestätigst
Braucht
/bootstrap ist erledigt, persistence: true in deiner Session Config, etwas Session-Verlauf.
Danach
Tippe /reconcile, um Lehren in Regeln zu verwandeln.

Quelle: skills/evolve/SKILL.md

Eine Idee klären

Aus einer vagen Idee wird etwas, das du planen kannst.

/brainstorm

Wann
Du hast eine Idee für eine Funktion, aber Umfang oder UX sind noch unscharf.
Du bekommst
Einen kurzen Fragendialog (3 bis 5 Runden) und eine freigegebene Design-Spezifikation in docs/specs/.
Eingabe
Claude Code
/brainstorm [topic-slug]
Codex
$session-orchestrator:brainstorm export-to-csv
Cursor
/brainstorm export-to-csv
Pi
/brainstorm
Wirkung
Ändert Dateien fragt vorher schreibt nur die Spezifikation; keine Code-Arbeit, bis du das Design freigibst
Braucht
/bootstrap ist erledigt.
Danach
/plan feature mit der Spezifikation, oder /write-executable-plan.

Quelle: skills/brainstorm/SKILL.md

/grill

Wann
Ein Plan oder PRD wirkt fertig, und du willst ihn angreifen lassen, bevor jemand baut.
Du bekommst
Harte Fragen, eine Entscheidung nach der anderen, gestützt auf deinen Code. Widersprüche und schwache Annahmen kommen ans Licht.
Eingabe
Claude Code
/grill [file-or-topic]
Codex
$session-orchestrator:grill docs/prd/<file>.md
Cursor
/grill <file>
Pi
/grill
Wirkung
Ändert Dateien fragt vorher meist nur Gespräch; schreibt auf Wunsch eine Grill-Notiz in docs/specs/
Braucht
Einen Plan im Chat, oder eine Datei zum Prüfen.
Danach
/plan feature, um den gehärteten Plan aufzuschreiben.

Quelle: skills/grill/SKILL.md

/deepen

Wann
Ein Bericht, eine Analyse, ein Plan oder ein Audit soll so gemacht werden, wie es ein Profi täte, ohne größer zu werden.
Du bekommst
Dieselbe Aufgabe neu formuliert, mit Rohdaten als Eingabe, schärferen Methoden und einer unabhängigen Prüfinstanz, und einen Halt, bevor etwas läuft. Kleine Änderungen und Anfragen mit „nur“ oder „schnell“ laufen unverändert durch.
Eingabe
Claude Code
/deepen [task]
Codex
$session-orchestrator:deepen <task>
Cursor
/deepen
Pi
/deepen
Wirkung
Liest nur fragt vorher liest, bis du die Neufassung bestätigst; danach erledigt es die Aufgabe, die du gewählt hast
Braucht
Eine Aufgabe im Chat oder als Argument.
Danach
Wähle die Neufassung, das Original oder eine engere Version.

Quelle: skills/deepen/SKILL.md

Ein Projekt starten

Ein Repository einrichten, die Einrichtung prüfen oder ein Produkt in ein eigenes Repository auslagern.

Auch: /bootstrap und /plan new unter Hier anfangen.

/spinout

Wann
Ein Produkt oder eine bereinigte Kopie soll aus diesem Repository in ein eigenes umziehen.
Du bekommst
Eine geführte Auslagerung in 5 Schritten: Ziel, Prüfung auf sensible Inhalte, Kopie mit frischem Git, Einfriermarke, Remotes.
Eingabe
Claude Code
/spinout [--type venture|snapshot] [--dry-run]
Codex
$session-orchestrator:spinout
Cursor
/spinout
Pi
/spinout
Wirkung
Committet fragt vorher legt ein neues Repository an und hinterlässt eine Einfriermarke in der Quelle; --dry-run druckt nur den Plan
Braucht
/bootstrap ist erledigt. Du kennst Zielpfad und Konto.
Danach
Tippe /bootstrap im neuen Repository.

Quelle: skills/spinout/SKILL.md

/harness-audit

Wann
Du willst prüfen, ob session-orchestrator in diesem Repository richtig eingerichtet ist.
Du bekommst
Eine Bewertung (healthy, warn oder critical) und jede Kategorie unter 7 von 10.
Eingabe
Claude Code
/harness-audit
Codex
$session-orchestrator:harness-audit
Cursor
/harness-audit
Pi
/harness-audit
Wirkung
Ändert Dateien hängt einen Eintrag an .orchestrator/metrics/audit.jsonl an
Braucht
Nichts. Argumente werden ignoriert.
Danach
Behebe schwache Kategorien, zum Beispiel mit /bootstrap --upgrade.

Quelle: skills/harness-audit/SKILL.md

Eine Funktion planen

Schreib auf, was gebaut werden soll, bevor es gebaut wird.

Auch: /plan feature unter Hier anfangen.

/write-executable-plan

Wann
Du hast ein freigegebenes PRD oder eine Design-Spezifikation und willst Schritte, denen jeder Agent folgen kann.
Du bekommst
Einen Plan in docs/plans/ mit den Dateien je Aufgabe, vollständigem Code und genauen Prüfbefehlen.
Eingabe
Claude Code
/write-executable-plan
Codex
$session-orchestrator:write-executable-plan
Cursor
/write-executable-plan
Pi
/write-executable-plan
Wirkung
Ändert Dateien eine Plan-Datei; lehnt Platzhalter wie TBD oder TODO ab
Braucht
/bootstrap ist erledigt, dazu ein freigegebenes PRD (aus /plan feature) oder eine Spezifikation (aus /brainstorm).
Danach
Baue ihn in /session.

Quelle: skills/write-executable-plan/SKILL.md

Bauen

Die Arbeit in geprüften Runden erledigen.

Meistens: /session, /go, /close unter Hier anfangen.

/autopilot

Wann
Mehrere volle Sessions sollen von selbst laufen, während du weg bist.
Du bekommst
Wiederholte Schleifen aus Start, Plan, Bauen und Abschluss. 10 Notbremsen stoppen es; jeder Lauf steht in autopilot.jsonl.
Eingabe
Claude Code
/autopilot [--headless] [--max-sessions=N] [--max-hours=H] [--dry-run]
Codex
$session-orchestrator:autopilot
Cursor
/autopilot
Pi
/autopilot
Wirkung
Committet ändert und committet wie /go und /close; --dry-run führt nichts aus
Braucht
Starte es auf oberster Ebene, nie in einer laufenden Session. --headless braucht eine Anmeldung bei claude -p.
Danach
Lies autopilot.jsonl und die Zusammenfassungen der Sessions.

Quelle: skills/autopilot/SKILL.md

Pflegen

Halte Code, Gedächtnis und Einrichtung in Form.

Auch: /session housekeeping für eine kurze Aufräumrunde.

/architecture

Wann
Der Code wirkt verwickelt, und du willst Ideen, die ihn leichter testbar und auffindbar machen.
Du bekommst
Vorgeschlagene Umbauten, die flache Module zu tiefen machen.
Eingabe
Claude Code
/architecture
Codex
$session-orchestrator:architecture
Cursor
/architecture
Pi
/architecture
Wirkung
Liest nur schlägt vor, ändert nichts
Braucht
Funktioniert am besten mit CONTEXT.md und docs/adr/. Ohne CONTEXT.md fragt es zuerst nach deiner Fachdomäne.
Danach
Mach aus einem Vorschlag ein /plan feature oder eine Session-Aufgabe.

Quelle: skills/architecture/SKILL.md

/backlog

Wann
Agents fragen nach oder raten, weil Issues Labels, eine Abnahmeprüfung oder eine klare Größe fehlen.
Du bekommst
Einen Bericht über deine offenen GitLab-Issues: Labels nach der Taxonomie des Repos, Bereitschaft der status:ready-Issues, zu große Issues, Epics und Abhängigkeiten von geschlossenen Issues. Danach Vorschläge zum Teilen, Zusammenfassen, Ergänzen und für Epics.
Eingabe
Claude Code
/backlog [path | group/name]
Codex
$session-orchestrator:backlog
Cursor
/backlog
Pi
/backlog
Wirkung
Öffnet Issues fragt vorher die Prüfung liest nur; Labels, Kommentare und Issues ändern sich nur bei Vorschlägen, die du freigibst
Braucht
Ein GitLab-Repository. GitHub wird noch nicht unterstützt.
Danach
Greife die bereiten Issues in /session auf.

Quelle: skills/backlog/SKILL.md

/memory-cleanup

Wann
Die Gedächtnisnotizen von Claude zu diesem Repository sind veraltet, widersprüchlich oder zu lang.
Du bekommst
Einen aufgeräumten Gedächtnisordner mit einer MEMORY.md unter 200 Zeilen, oder einen Vorschlag, den du später anwendest.
Eingabe
Claude Code
/memory-cleanup [--dry-run | --apply-pending]
Codex
$session-orchestrator:memory-cleanup
Cursor
/memory-cleanup
Pi
/memory-cleanup
Wirkung
Ändert Dateien fragt vorher ändert ~/.claude/projects/<repo>/memory/; --dry-run schreibt nur einen Vorschlag
Braucht
Einen vorhandenen Gedächtnisordner.
Danach
Arbeite weiter. Wiederhole es alle 5 oder mehr Sessions.

Quelle: skills/memory-cleanup/SKILL.md

/repo-audit

Wann
Du willst wissen, ob ein Repository die Grundanforderungen erfüllt: Konfiguration, CI, Tests, Sicherheit, Doku.
Du bekommst
Einen Prüfbericht über 9 Kategorien: pass, fail oder warn.
Eingabe
Claude Code
/repo-audit
Codex
$session-orchestrator:repo-audit
Cursor
/repo-audit
Pi
/repo-audit
Wirkung
Ändert Dateien nur ein Bericht, behebt nie etwas; schreibt eine JSON-Datei nach .orchestrator/metrics/
Braucht
Nichts. Argumente werden ignoriert.
Danach
Behebe durchgefallene Kategorien in /session housekeeping.

Quelle: skills/repo-audit/SKILL.md

/sunset-review

Wann
Einmal im Quartal willst du Skills, Agents oder Befehle finden, die niemand mehr nutzt.
Du bekommst
Jeden Eintrag einsortiert in Active, Investigate, Demote oder Retire.
Eingabe
Claude Code
/sunset-review [--kind skill|agent|command] [--window-days N]
Codex
$session-orchestrator:sunset-review
Cursor
/sunset-review
Pi
/sunset-review
Wirkung
Ändert Dateien schreibt einen Bericht; löscht nie etwas
Braucht
Nutzungsaufzeichnungen (Standardzeitraum 90 Tage).
Danach
Entscheide selbst über die Kandidaten für Retire und Demote.

Quelle: skills/sunset-review/SKILL.md

Untersuchen

Finde Probleme und ihre Ursachen, bevor du etwas behebst.

/discovery

Wann
Du willst systematisch nach Qualitätsproblemen und technischen Schulden suchen.
Du bekommst
Eine Liste von Funden, die du einzeln durchgehst. Bestätigte werden zu Issues.
Eingabe
Claude Code
/discovery [all|code|infra|ui|arch|session|audit|vault|feature]
Codex
$session-orchestrator:discovery code
Cursor
/discovery code
Pi
/discovery
Wirkung
Öffnet Issues fragt vorher schaut nur, ohne etwas zu ändern; öffnet Issues nur für Funde, die du bestätigst
Braucht
/bootstrap ist erledigt. --since und --full lassen sich nicht kombinieren.
Danach
Greife die neuen Issues in /session auf.

Quelle: skills/discovery/SKILL.md

/debug

Wann
Ein Test schlägt fehl, der Build bricht, oder etwas verhält sich unerwartet.
Du bekommst
Eine Ursachenforschung in 4 Schritten, aufgeschrieben, bevor ein Fix vorgeschlagen wird.
Eingabe
Claude Code
/debug [bug-or-issue]
Codex
$session-orchestrator:debug "test timeout in CI"
Cursor
/debug <bug>
Pi
/debug
Wirkung
Ändert Dateien fragt vorher schreibt zuerst eine Debug-Notiz nach .orchestrator/debug/
Braucht
/bootstrap ist erledigt. Ohne Argument wählt es einen wahrscheinlichen Fehler und bestätigt ihn mit dir.
Danach
Behebe ihn in einer Session und verweise dabei auf die Debug-Notiz.

Quelle: skills/debug/SKILL.md

Testen

Prüfe, ob die App funktioniert und ob deine Tests es wert sind, behalten zu werden.

/test

Wann
Du willst prüfen, ob eine Web- oder macOS-App für einen Nutzer wirklich funktioniert.
Du bekommst
Gesteuerte Testläufe mit Screenshots, ein UX-Urteil und einen Bericht, der mit deinen offenen Issues abgeglichen ist.
Eingabe
Claude Code
/test [scope|profile] [--dry-run]
Codex
$session-orchestrator:test smoke
Cursor
/test smoke
Pi
/test
Wirkung
Öffnet Issues schreibt Test-Artefakte und einen Bericht; --dry-run druckt nur den Plan
Braucht
Ein lauffähiges Ziel: Playwright für das Web, Peekaboo für macOS.
Danach
Behebe die Funde in einer Session oder mit /debug.

Quelle: skills/test/SKILL.md

/test-audit

Wann
Du fragst dich, ob sich ein Test lohnt, oder deine Test-Suite ist zu groß geworden.
Du bekommst
Ein Urteil über einen neuen Test (gate), oder eine kleinere Suite, in der jedes Löschen und Zusammenlegen einen Beleg trägt.
Eingabe
Claude Code
/test-audit [gate|audit|campaign] [scope]
Codex
$session-orchestrator:test-audit audit tests/lib
Cursor
/test-audit audit <scope>
Pi
/test-audit
Wirkung
Ändert Dateien audit und campaign ändern Tests unter einer Abdeckungsgrenze; gate urteilt nur
Braucht
Eine Test-Suite. Ein fehlender Bereich wird einmal erfragt.
Danach
Lass deine vollen Tests laufen und committe mit /close.

Quelle: skills/test-audit/SKILL.md

/ux-grill

Wann
Eine Web-App läuft lokal, und du willst ihre UX jedes Mal gleich prüfen.
Du bekommst
Gemessene Prüfungen je Route und Bildschirmgröße, danach einen Rundgang durch jede Nutzer-Reise mit Screenshots.
Eingabe
Claude Code
/ux-grill [loopback-url | manifest-path]
Codex
$session-orchestrator:ux-grill http://127.0.0.1:3100
Cursor
/ux-grill <url>
Pi
/ux-grill
Wirkung
Öffnet Issues fragt vorher schreibt Messwerte; committet nie und ändert keinen Produktcode
Braucht
Die App läuft unter einer lokalen URL, und agent-browser ist installiert.
Danach
Behebe die Issues und lass es danach noch einmal laufen, um zu vergleichen.

Quelle: skills/ux-grill/SKILL.md

Zurückschauen

Sieh, wie eine Session oder eine Phase wirklich gelaufen ist.

Auch: /plan retro für eine abgeschlossene Phase.

/eval

Wann
Du willst eine ehrliche Bewertung, wie gut die letzte Session ihrem Ablauf gefolgt ist.
Du bekommst
Eine Bewertung je Dimension nach einem festen Raster (keine einzelne Gesamtnote) und auf Wunsch einen HTML-Bericht.
Eingabe
Claude Code
/eval [--session <id>] [--no-write]
Codex
$session-orchestrator:eval
Cursor
/eval
Pi
/eval
Wirkung
Ändert Dateien hängt an .orchestrator/metrics/eval.jsonl an, außer mit --no-write
Braucht
Mindestens eine abgeschlossene Session.
Danach
Tippe /evolve, um aus den schwachen Dimensionen zu lernen.

Quelle: skills/eval/SKILL.md

Es lernt, mit deinem Ja

Derselbe Fehler soll nicht
jede Woche wiederkommen.

Jede Session hinterlässt eine kurze Aufzeichnung. /evolve schaut über diese Aufzeichnungen und schlägt eine Lehre vor. Du entscheidest. Nur eine Lehre, die du behältst, kann zur Regel werden.

  1. 1Eine Session hinterlässt eine Aufzeichnung

    Eine Zeile pro Session: ihr Typ, ihre Runden und Agents, was fertig wurde und was weitergetragen wurde.

    .orchestrator/metrics/sessions.jsonl

  2. 2/evolve schlägt eine Lehre vor

    Sie zeigt die Belege, einen Konfidenzwert und die Dateien, um die es in der Lehre geht. Die echte Lehre unten betrifft die eigenen Werkzeuge dieses Projekts. In deinem Repository geht es um deinen Code, zum Beispiel um eine Prüfung, die deine Agents immer wieder auslassen.

    { "type": "convention",
      "evidence": "Session … three reviews against …",
      "file_paths": ["skills/_shared/fleet-protocol.md",
                     "skills/wave-executor/SKILL.md"],
      "expires_at": "2027-01-12T00:10:00.000Z" }
  3. 3Du entscheidest

    Behalten, korrigieren oder verwerfen. Ohne dich wird nichts zur Regel.

  4. 4/reconcile schreibt eine Regel

    Eine kleine Regeldatei, die ihre Quelle, ihre Konfidenz und ein Ablaufdatum nennt.

    auto-generated: true
    paths:
      - "skills/_shared/**"
      - "skills/wave-executor/**"
    learning-key: convention/owner-inbox-…
    confidence: 0.8
    expires-at: 2027-01-12
  5. 5Die nächste Session nutzt sie

    Agents bekommen die Regel nur, wenn sie an passenden Dateien arbeiten. Nach dem Ablaufdatum entfernt Housekeeping sie, sobald du zustimmst.

Eine Person am Schreibtisch hält eine Karte aus dem Logbuch eines Agenten hoch, eine verworfene Karte liegt zerknüllt in einer Ablage, und ein Agent nimmt einen markierten Ordner aus dem Regelregal.
Nur eine Lehre, die du bestätigst, wird zur Regel · mit KI erstellt

Die Beispiele in Schritt 2 und 4 sind echte Dateien aus diesem Repository, gekürzt.

Was, wann?

/plan retro
nach einer abgeschlossenen Phase: was gut lief, was sich ändern soll
/evolve
wenn sich in deinen Sessions ein Muster wiederholt
/reconcile
wenn eine behaltene Lehre zur wirksamen Regel werden soll
/eval
um zu bewerten, wie eine Session gelaufen ist, aus ihren eigenen Aufzeichnungen
/session housekeeping
um die ganze Pflege in einem Durchgang zu erledigen

Was es nicht tut: Es trainiert kein Modell, und es ändert sich nicht ohne deine Zustimmung. Gemessene Tests, die zwei Versionen eines Skills vergleichen, sind geplant, nicht ausgeliefert.

Zuerst: /evolve unter Hier anfangen.

/reconcile

Wann
Du hast bestätigte Lehren und willst, dass die starken zu Regeln werden.
Du bekommst
Vorgeschlagene Regeln in .claude/rules/, vier auf einmal. Deine Agents lesen sie beim nächsten Mal.
Eingabe
Claude Code
/reconcile [--dry-run]
Codex
$session-orchestrator:reconcile
Cursor
/reconcile
Pi
/reconcile
Wirkung
Ändert Dateien fragt vorher schreibt nur die Regeln, die du freigibst; --dry-run schreibt nichts
Braucht
Gespeicherte Lehren aus /evolve.
Danach
Committe die neuen Regeln mit /close.

Quelle: skills/reconcile/SKILL.md

Viele Repositories führen

Sieh alle deine Repositories auf einmal und wähle das nächste.

/portfolio Für Maintainer

Wann
Du betreust viele Repositories und willst eine Übersicht über ihre Issues, MRs und ihr Alter.
Du bekommst
Eine Dashboard-Datei in deinem Vault: 01-projects/_PORTFOLIO.md.
Eingabe
Claude Code
/portfolio [--dry-run] [--repo <name>]
Codex
$session-orchestrator:portfolio
Cursor
/portfolio
Pi
/portfolio
Wirkung
Ändert Dateien schreibt das Dashboard; --dry-run druckt nur den Diff
Braucht
gitlab-portfolio.enabled: true und einen Vault-Ordner in deiner Session Config; glab oder gh angemeldet.
Danach
Wähle ein Repository, oder frage /dispatcher.

Quelle: skills/portfolio/SKILL.md

/dispatcher

Wann
Ein Repository ist fertig, und du willst wissen, an welchem es sich als Nächstes am meisten lohnt zu arbeiten.
Du bekommst
Eine Rangliste der freien Repositories und eine Empfehlung. Sobald du bestätigst, belegt es dieses Repository und übergibt an /session.
Eingabe
Claude Code
/dispatcher [--dry-run] [--repo <name>]
Codex
$session-orchestrator:dispatcher
Cursor
/dispatcher
Pi
/dispatcher
Wirkung
Ändert Dateien fragt vorher liest nur, bis du bestätigst; dann nimmt es die Session-Sperre dieses Repositorys
Braucht
Mehrere Repositories unter einem Ordner.
Danach
Tippe das vorgeschlagene /session im gewählten Repository.

Quelle: skills/dispatcher/SKILL.md

Weitere Werkzeuge

Kleinere Helfer für Sonderfälle.

/persona-panel

Wann
Ein Text oder eine Datei soll von mehreren Experten- oder Käufer-Personas auf einmal geprüft werden.
Du bekommst
Ein Urteil je Persona, zusammengeführt zu einem Gesamturteil.
Eingabe
Claude Code
/persona-panel <target> [--mode voting|hard-gate|summary]
Codex
$session-orchestrator:persona-panel docs/landing.md
Cursor
/persona-panel <target>
Pi
/persona-panel
Wirkung
Ändert Dateien schreibt eine Ergebnisdatei nach .orchestrator/persona-panel/; --dry-run schreibt nichts
Braucht
Ein Ziel im Projekt und Persona-Dateien in .claude/personas/.
Danach
Überarbeite das Ziel anhand der Urteile.

Quelle: skills/persona-panel/SKILL.md

/eli5

Wann
Die letzte Antwort war zu technisch oder zu lang.
Du bekommst
Dieselben Fakten in einfachen Worten, in deiner Sprache, ohne dass etwas fehlt.
Eingabe
Claude Code
/eli5 [topic]
Codex
$session-orchestrator:eli5
Cursor
/eli5
Pi
/eli5
Wirkung
Liest nur formuliert nur Text im Chat um
Braucht
Nichts.
Danach
Handle nach der jetzt klaren Antwort.

Quelle: skills/eli5/SKILL.md

/release Für Maintainer

Wann
Du betreust dieses Paket und willst eine neue Version herausgeben.
Du bekommst
Die Release-Schritte in der vorgeschriebenen Reihenfolge, mit den Bedingungen, die ein Release stoppen.
Eingabe
Claude Code
/release [X.Y.Z]
Codex
$session-orchestrator:release X.Y.Z
Cursor
/release
Pi
/release
Wirkung
Veröffentlicht veröffentlicht auf npm; das lässt sich nicht rückgängig machen
Braucht
Einen sauberen main-Branch auf dem Stand von origin, einen aktuellen GitHub-Spiegel, einen CHANGELOG-Eintrag und alle Prüfungen von release.mjs --check grün.
Danach
Prüfe mit npm view session-orchestrator versions.

Quelle: skills/release/SKILL.md

/tmux-layout

Wann
In einer langen Session willst du STATE.md, CI und Ereignisse nebeneinander sehen.
Du bekommst
Ein tmux-Layout mit 4 Bereichen zum Zuschauen. Der Chat bleibt in deinem Terminal.
Eingabe
Claude Code
/tmux-layout [--layout debug]
Codex
$session-orchestrator:tmux-layout
Cursor
/tmux-layout
Pi
/tmux-layout
Wirkung
Liest nur öffnet Bereiche nur zum Zuschauen
Braucht
tmux ist installiert. Dieser Skill ist optional (status: proposed).
Danach
Arbeite weiter im Chat.

Quelle: skills/tmux-layout/SKILL.md

/templates-ack

Wann
Die Templates-first-Prüfung blockiert ein gh- oder glab-create, aber du hast die Vorlage schon gelesen.
Du bekommst
Issues und MRs lassen sich für den Rest dieser Session anlegen.
Eingabe
Claude Code
/templates-ack [reason]
Codex
$session-orchestrator:templates-ack (wirkt auf Codex nicht)
Cursor
/templates-ack
Pi
/templates-ack
Wirkung
Ändert Dateien schreibt eine Bestätigungsdatei nach .orchestrator/runtime/
Braucht
Eine Claude-Code-Session. Ohne sie wird es abgelehnt.
Danach
Führe den gh- oder glab-create-Befehl noch einmal aus.

Quelle: commands/templates-ack.md

Passiert im Hintergrund

Diese tippst du nie. Sie laufen, wenn ein Befehl sie braucht.

23 interne Skills

Bausteine, die die Befehle oben aufrufen, zum Beispiel session-start für /session und wave-executor für /go.

  • claude-md-drift-check
  • convergence-monitoring
  • docs-orchestrator
  • ecosystem-health
  • frontmatter-guard
  • gitlab-ops
  • gitlab-portfolio
  • hook-development
  • mcp-builder
  • mode-selector
  • npm-publish
  • peekaboo-driver
  • playwright-driver
  • quality-gates
  • remote-offload
  • session-end
  • session-plan
  • session-start
  • test-runner
  • using-orchestrator
  • vault-mirror
  • vault-sync
  • wave-executor
14 Agent-Rollen

Die Agents, die eine Runde losschickt: Jede Rolle erledigt eine Art Arbeit, etwa Code schreiben, Tests schreiben oder prüfen.

  • analyst
  • architect-reviewer
  • code-implementer
  • db-specialist
  • dialectic-deriver
  • docs-writer
  • eval-judge
  • qa-strategist
  • security-reviewer
  • session-reviewer
  • skill-applied-judge
  • test-writer
  • ui-developer
  • ux-evaluator
10 Hook-Ereignisse

Zeitpunkte in Claude Code, an denen die Guards und die Session-Aufzeichnungen laufen. Codex nutzt sechs davon; Pi bildet fünf über eine Brücke ab.

  • SessionStart
  • SessionEnd
  • PreToolUse
  • PostToolUse
  • Stop
  • SubagentStop
  • PostToolUseFailure
  • PostToolBatch
  • SubagentStart
  • CwdChanged
2 MCP-Tools

Optionale Tools, die dein Coding-Tool aufrufen kann. Es sind keine Slash-Befehle.

session_config
Liest die Session Config aus CLAUDE.md oder AGENTS.md.
session_metrics
Liest die letzten fünf Session-Aufzeichnungen aus .orchestrator/metrics/sessions.jsonl.