> ## Documentation Index
> Fetch the complete documentation index at: https://code.claude.com/docs/llms.txt
> Use this file to discover all available pages before exploring further.

# Referenz für Plugin-Befehle

> Referenz für die Claude-Plugin-Shell-Befehle, /plugin und /reload-plugins in einer Sitzung, und die Flags, die ein Plugin für eine Sitzung laden.

Sie führen Plugin-Befehle entweder als `claude plugin` aus Ihrer Shell oder einem Skript aus, oder als `/plugin` und `/reload-plugins` innerhalb einer Claude Code-Sitzung. Diese Referenz gibt die Flags, Standardwerte, Ausgabe und Exit-Codes jedes Befehls an, zusammen mit den zwei Flags, die ein Plugin für eine Sitzung laden.

Die folgenden Tabellen listen die häufig verwendeten Optionen jedes Unterbefehls auf, nicht jede Option. Führen Sie `claude plugin --help` in Ihrer Shell aus, um zu sehen, welche Unterbefehle Ihre Version hat, und `claude plugin <subcommand> --help` für die vollständige Optionsliste eines Unterbefehls.

> [!NOTE]
>
> Diese Fälle werden auf anderen Seiten behandelt:
>
> * **Installieren und Verwalten von Schritten, und wo `/plugin` ausgeführt wird**: siehe [Plugins installieren und verwalten](https://code.claude.com/docs/de/plugins/install.md)
> * **Was ein Befehl auf der Festplatte ändert und welcher Bereich Vorrang hat**: siehe [Plugin-Ladeverzeichnis](https://code.claude.com/docs/de/plugins/loading.md)
> * **Was eine Fehlermeldung bedeutet**: siehe [Plugins beheben](https://code.claude.com/docs/de/plugins/troubleshooting.md)

## Befehle von claude plugin

Führen Sie `claude plugin <subcommand>` in Ihrer Shell oder in einem Skript aus, außerhalb einer Claude Code-Sitzung. Diese Unterbefehle installieren und verwalten Plugins, ohne das [`/plugin`](#plugin-in-a-session)-Panel zu öffnen.

`claude plugins` ist ein Alias für `claude plugin`.

Alle Unterbefehle verwenden dieselben Exit-Codes, Plugin-Argumente und Werte für den Geltungsbereich:

* **Exit-Codes**: `0` bei Erfolg und `1` bei einem Fehler. `validate` ergänzt den Exit-Code `2` für einen unerwarteten Fehler, und `eval` ergänzt die in [seinem Abschnitt](#plugin-eval) aufgeführten Codes.
* **Plugin-Argumente**: Ein `<plugin>`-Argument ist ein Plugin-`name` oder `name@marketplace`. Wenn zwei Marketplaces denselben Namen anbieten, verwenden Sie die qualifizierte Form. `configure` akzeptiert nur die qualifizierte Form.
* **Geltungsbereiche**: `--scope` akzeptiert `user`, `project` oder `local` und benennt die Einstellungsdatei, in die der Befehl schreibt. `update` akzeptiert zusätzlich `managed`.

### plugin init

Erstellt das Grundgerüst eines neuen Plugins unter `~/.claude/skills/<name>/`. Sofern Ihr Administrator [Plugins aus dem Skills-Verzeichnis nicht blockiert hat](https://code.claude.com/docs/de/plugins/loading.md#skills-directory-plugins-blocked-by-managed-settings), wird es in Ihrer nächsten Sitzung als `<name>@skills-dir` geladen, ohne Installationsschritt.

`new` ist ein Alias für `init`.

Den Workflow zum Erstellen, Testen und Bearbeiten, der mit diesem Befehl beginnt, finden Sie unter [Ein Plugin erstellen](https://code.claude.com/docs/de/plugins/create.md).

```bash theme={null}
claude plugin init <name> [options]
```

`<name>` wird zum Verzeichnisnamen unter `~/.claude/skills/` und zum `name` des Plugins in seinem Manifest.

Der Befehl hat kein Flag für einen anderen Speicherort. Wie Sie das Grundgerüst stattdessen innerhalb eines Projekts erstellen, erfahren Sie unter [Ein Plugin erstellen](https://code.claude.com/docs/de/plugins/create.md).

| Flag | Beschreibung |
| :- | :- |
| `--description <text>` | Beschreibung im Manifest |
| `--author <name>` | Name des Autors. Standardmäßig `git config user.name` |
| `--author-email <email>` | E-Mail-Adresse des Autors. Standardmäßig `git config user.email` |
| `--with <components...>` | Zusätzlich Startdateien für `skills`, `agents`, `hooks`, `mcp`, `lsp`, `output-style` oder `channel` erstellen |
| `-f, --force` | Ein vorhandenes `.claude-plugin/` am Ziel überschreiben |

Ein Plugin mit Startdateien für Skills und Hooks erstellen:

```bash theme={null}
claude plugin init my-helper --with skills hooks
```

Claude Code validiert, was es geschrieben hat, und gibt `Created plugin "my-helper" at ~/.claude/skills/my-helper` aus, gefolgt von der ID, unter der es geladen wird, und dem Befehl `claude plugin disable`, mit dem Sie es ausschalten.

Claude Code beendet sich mit `1`, ohne etwas zu schreiben, wenn es das Grundgerüst nicht sicher erstellen kann, und die Meldung nennt den Grund. Häufige Gründe sind:

* Ein unbekannter Wert für `--with`
* Ein vorhandenes Grundgerüst am Ziel ohne `--force`
* Eine verwaltete Marketplace-Allowlist ohne die Quelle `skills-dir` oder eine Denylist, die sie nennt. Die Meldung lautet [`Plugins from ~/.claude/skills/ are blocked by your organization's managed settings`](https://code.claude.com/docs/de/plugins/troubleshooting#plugins-from-claude-skills-are-blocked-by-your-organizations-managed-s).

### plugin install

Installiert ein Plugin aus einem Ihrer Marketplaces. `i` ist ein Alias für `install`.

```bash theme={null}
claude plugin install <plugin> [options]
```

Die meisten Plugins werden ohne Rückfrage installiert. Bei einem Plugin, dessen Marketplace-Eintrag [zur Installation einen Befehl ausführt](https://code.claude.com/docs/de/plugins/host-marketplace.md) oder [für seinen Download einen `headersHelper` festlegt](https://code.claude.com/docs/de/plugins/host-marketplace#how-users-accept-a-headershelper-command), gibt Claude Code zunächst den Befehl aus und fragt `Run this command now? [y/N]`.

| Flag | Beschreibung |
| :- | :- |
| `-s, --scope <scope>` | Geltungsbereich der Installation: `user`, `project` oder `local`. Standardmäßig `user` |
| `--config <key=value>` | Legt eine [`userConfig`](https://code.claude.com/docs/de/plugins/manifest-reference)-Option fest, die das Manifest des Plugins deklariert. Wiederholen Sie das Flag für jede Option. Ein als `<server>.<key>` geschriebener Schlüssel legt stattdessen eine Einstellung fest, die ein [gebündelter MCP-Server](https://code.claude.com/docs/de/plugins/components.md#include-a-packaged-mcpb-server) in seinem eigenen `user_config` deklariert – für eine Bundle-Datei, die im Plugin mitgeliefert wird. Die Form `<server>.<key>` erfordert Claude Code v2.1.285 oder höher |
| `-y, --yes` | Akzeptiert den angezeigten Installationsbefehl ohne die Rückfrage `Run this command now?`. Wird ignoriert, wenn der Befehl innerhalb einer Claude Code-Sitzung ausgeführt wird, etwa über das Bash-Tool oder einen Hook. Erfordert Claude Code v2.1.229 oder höher |
| `--accept-command <sha256>` | Akzeptiert anstelle von `-y` den angezeigten Installationsbefehl, dessen `sha256` ein vorheriger [`--json`-Lauf](#plugin-json-result) in `shownCommand` gemeldet hat. Kann nicht mit `-y` kombiniert werden. Siehe [Einen angezeigten Installationsbefehl akzeptieren](#accept-a-displayed-install-command). Erfordert Claude Code v2.1.271 oder höher |
| `--json` | Gibt das Ergebnis statt der lesbaren Meldung als ein JSON-Objekt in der letzten Zeile von stdout aus, zur Verwendung in Skripten. Siehe [Format des JSON-Ergebnisses](#plugin-json-result). Erfordert Claude Code v2.1.268 oder höher |
| `--marketplace <source>` | Installiert `<plugin>`, angegeben mit seinem bloßen Namen, aus dem Marketplace unter `<source>` und fügt den Marketplace zuerst hinzu, falls Sie ihn noch nicht hinzugefügt haben. Siehe [Einen Marketplace hinzufügen und mit einem Befehl installieren](https://code.claude.com/docs/de/plugins/install.md#add-a-marketplace-and-install-in-one-command). Erfordert Claude Code v2.1.292 oder höher |

Führen Sie `claude plugin install --help` in Ihrer Shell aus, um alle Optionen zu sehen, die Ihre Version unterstützt.

Übergeben Sie `-y` in Ihrem eigenen Terminal, um den angezeigten Befehl ohne Rückfrage zu akzeptieren. Folgendes geschieht ohne TTY und wenn Claude den Befehl ausführt:

* **stdin oder stdout ist kein TTY, und Sie übergeben weder `-y` noch `--accept-command`**: Die Installation wird abgelehnt. Die Ausgabe besagt, dass der Befehl nur angezeigt wurde, und der Exit-Code ist `1`
* **Claude führt den Befehl über sein Bash-Tool aus**: `-y` wird ignoriert. Führen Sie den Befehl stattdessen in Ihrem eigenen Terminal aus

Ein Plugin für alle installieren, die das Projekt klonen:

```bash theme={null}
claude plugin install formatter@my-marketplace --scope project
```

Claude Code gibt `Successfully installed plugin: formatter@my-marketplace (scope: project)` aus. Wenn nichts Neues installiert wird, nennt die Ausgabe den Grund:

* **Bereits in diesem Geltungsbereich installiert**: Die Ausgabe lautet `Plugin "formatter@my-marketplace" is already installed (scope: project)`, und der Exit-Code ist `0`
* **Sie lehnen eine Rückfrage zu einer Befehlsquelle ab**: Die Ausgabe lautet `Aborted.`, und der Exit-Code ist `1`
* **Sie lehnen eine `headersHelper`-Rückfrage ab, oder sie kann ohne TTY nicht bestätigt werden**: Die Ausgabe lautet `Aborted — the command was not run.`, und der Exit-Code ist `1`

#### Format des JSON-Ergebnisses

Wenn Sie `--json` an `plugin install` übergeben, ist die letzte Zeile von stdout ein JSON-Objekt. Werten Sie nur diese Zeile aus, denn Claude Code gibt davor alle Befehle aus, die der Marketplace deklariert.

Drei Felder sind immer vorhanden:

* `command`: der ausgeführte Unterbefehl, etwa `install`
* `outcome`: `ok` oder `failed`
* `message`: eine lesbare Beschreibung des Ergebnisses

Andere Felder wie `pluginId`, `scope` und `failureCode` erscheinen nur, wenn sie zutreffen.

Die Option `--json` bei `plugin uninstall`, `plugin update`, `plugin enable` und `plugin disable` gibt dasselbe Objekt mit den eigenen Feldern des jeweiligen Unterbefehls aus.

Ein Verwendungsfehler, etwa ein ungültiges `--scope`, gibt keine Ergebniszeile aus und beendet sich mit `1`, wobei der Grund auf stderr ausgegeben wird.

#### JSON-Ergebnis für Marketplace-Befehle

Bei `plugin marketplace add`, `plugin marketplace remove` und `plugin marketplace update` gibt `--json` ein JSON-Objekt mit den Feldern `command`, `outcome` und `message` in der letzten Zeile von stdout aus. Das Folgende ist das Ergebnis von `claude plugin marketplace remove your-marketplace --json`:

```json theme={null}
{"command":"marketplace-remove","outcome":"ok","marketplace":"your-marketplace","message":"Successfully removed marketplace: your-marketplace"}
```

Der Wert von `command` ist `marketplace-add`, `marketplace-remove` oder `marketplace-update`. Die folgenden Felder erscheinen nur, wenn sie zutreffen:

* `marketplace`: der Name des Marketplace, auf den der Befehl angewendet wurde
* `failureCode`: ein Code für den Grund, warum der Befehl fehlgeschlagen ist, etwa `invalid_source`

`plugin marketplace add` und `plugin marketplace remove` geben möglicherweise keine Ergebniszeile aus, wenn das Argument der [reservierte Name](https://code.claude.com/docs/de/plugins/marketplace-reference.md#reserved-names) `anthropic-plugin-directory` ist. Prüfen Sie für diesen Namen daher den Exit-Code.

#### Einen angezeigten Installationsbefehl akzeptieren

Wenn ein `--json`-Lauf einen vom Marketplace deklarierten Befehl anzeigt und ihn nicht ausführt, enthält das `failed`-Ergebnis zusätzlich ein `shownCommand`-Objekt. Seine Felder umfassen den Befehl in der angezeigten Form, das Plugin, zu dem er gehört, und den `sha256` des Befehls.

Um genau diesen Befehl zu akzeptieren, führen Sie den Lauf in Ihrem eigenen Terminal erneut mit diesem `sha256` als `--accept-command` aus, denn das Flag hat innerhalb einer Claude Code-Sitzung keine Wirkung. Erfordert Claude Code v2.1.271 oder höher.

Der `sha256` gilt als Zustimmung für genau diesen Befehl, dieses Plugin und diesen Marketplace-Katalog. Wenn sich einer davon seit der Anzeige des Befehls geändert hat, akzeptiert Claude Code den `sha256` nicht und zeigt den Befehl erneut an. Eine Änderung, die die eigene Marketplace-Aktualisierung des Laufs abruft, zählt ebenfalls als solche Änderung.

Wenn `shownCommand.acceptCommandMatched` `false` ist, stimmt der übergebene `sha256` nicht mit dem nun angezeigten Befehl überein. Prüfen Sie diesen Befehl, bevor Sie den Lauf mit seinem `sha256` erneut ausführen.

### plugin uninstall

Entfernt ein installiertes Plugin aus einem Geltungsbereich. `remove` und `rm` sind Aliasse für `uninstall`.

```bash theme={null}
claude plugin uninstall <plugin> [options]
```

| Flag | Beschreibung |
| :- | :- |
| `-s, --scope <scope>` | Geltungsbereich für die Deinstallation: `user`, `project` oder `local`. Standardmäßig `user` |
| `--keep-data` | Das persistente Datenverzeichnis des Plugins, `~/.claude/plugins/data/<id>/`, beibehalten |
| `--prune` | Zusätzlich automatisch installierte [Abhängigkeiten](https://code.claude.com/docs/de/plugins/dependencies.md) entfernen, die kein verbleibendes Plugin benötigt |
| `-y, --yes` | Die Bestätigungsabfrage von `--prune` überspringen. Zusammen mit `--prune` erforderlich, wenn stdin oder stdout kein TTY ist |
| `--json` | Gibt das Ergebnis als ein JSON-Objekt in der letzten Zeile von stdout aus, im [gleichen Format wie `plugin install --json`](#plugin-json-result). Kann nicht mit `--prune` kombiniert werden. Erfordert Claude Code v2.1.268 oder höher |

Ein Plugin aus dem Projekt-Geltungsbereich deinstallieren:

```bash theme={null}
claude plugin uninstall formatter@my-marketplace --scope project
```

Claude Code gibt `Successfully uninstalled plugin: formatter (scope: project)` aus. Wenn das Plugin in diesem Geltungsbereich nicht installiert ist, gibt der Befehl eine Zeile aus, die mit `Failed to uninstall plugin "formatter@my-marketplace":` beginnt, und beendet sich mit `1`.

Wenn die Fehlerzeile mit `"formatter" was not uninstalled:` fortgesetzt wird und eine Einstellungsdatei nennt, konnte Claude Code nicht bestätigen, dass die Einstellungen des Geltungsbereichs das Plugin nicht mehr einschalten. Das Plugin bleibt daher mit allem, was es gespeichert hat, installiert. Mit `--json` enthält das Ergebnis `failureCode: "settings_still_on"`. Diese Prüfung der Einstellungen erfordert Claude Code v2.1.282 oder höher.

#### Was eine Deinstallation löscht und beibehält

Wenn Sie ein Plugin aus dem letzten Geltungsbereich deinstallieren, in dem es installiert ist, löscht Claude Code auch die gespeicherten [Optionen und Geheimnisse](https://code.claude.com/docs/de/plugins/manifest-reference.md#user-configuration) des Plugins sowie sein Datenverzeichnis `~/.claude/plugins/data/<id>/`. Es gibt drei Ausnahmen:

* Mit `--keep-data` bleibt das Datenverzeichnis erhalten
* Wenn ein anderes installiertes Plugin denselben Ordner verwendet, etwa eines, dessen ID sich von der dieses Plugins nur in der Groß- und Kleinschreibung unterscheidet, bleibt das Datenverzeichnis erhalten
* Wenn Claude Code die Liste der installierten Plugins nicht zurücklesen kann, nachdem es das Plugin aus diesem Geltungsbereich entfernt hat, bleiben Optionen, Geheimnisse und Datenverzeichnis allesamt erhalten, da das Plugin möglicherweise noch in einem anderen Geltungsbereich installiert ist. Die Deinstallation ist trotzdem erfolgreich. Die Meldung listet auf, was erhalten blieb und wie Sie es löschen, und mit `--json` enthält das Ergebnis `savedKept: "install_records_unreadable"`

Mit `--json` gibt `keptData` an, ob das Verzeichnis erhalten blieb, und `/plugin` zeigt in diesem Fall `· data preserved` an. Für ein Verzeichnis, das ohne `--keep-data` erhalten bleibt, erfordert diese Angabe Claude Code v2.1.281 oder höher. Das Feld `savedKept` erfordert Claude Code v2.1.282 oder höher.

### plugin enable

Aktiviert ein deaktiviertes Plugin. Übergeben Sie für ein [von claude.ai synchronisiertes Plugin](https://code.claude.com/docs/de/plugins/loading.md#synced-plugins) `<name>@synced` als Plugin.

```bash theme={null}
claude plugin enable <plugin> [options]
```

| Flag | Beschreibung |
| :- | :- |
| `-s, --scope <scope>` | Geltungsbereich, in dem aktiviert wird: `user`, `project` oder `local`. Wird automatisch erkannt, wenn weggelassen |
| `--json` | Gibt das Ergebnis als ein JSON-Objekt in der letzten Zeile von stdout aus, im [gleichen Format wie `plugin install --json`](#plugin-json-result). Erfordert Claude Code v2.1.268 oder höher |

Ohne `--scope` prüft der Befehl Ihre Einstellungsdateien in der Reihenfolge local, project, user und verwendet den ersten Geltungsbereich, der das Plugin erwähnt.

Wenn Sie einen `--scope` übergeben, in dem das Plugin nicht deklariert ist, schreibt der Befehl entweder eine Überschreibung oder schlägt fehl:

* **Ein Geltungsbereich, der [Vorrang](https://code.claude.com/docs/de/plugins/loading.md) vor dem deklarierenden hat**: Claude Code schreibt eine Überschreibung in den übergebenen Geltungsbereich. Beispielsweise schaltet `claude plugin disable formatter --scope local` ein auf Projektebene aktiviertes Plugin nur für Sie aus
* **Jeder andere Geltungsbereich**: Der Befehl schlägt mit `Plugin "formatter" is installed at project scope, not user. Use --scope project or omit --scope to auto-detect.` fehl

Wenn das Plugin im ermittelten Geltungsbereich bereits aktiviert ist, gibt der Befehl `Plugin "formatter" is already enabled` aus und beendet sich mit `1`. Mit `--json` enthält das Ergebnis `"failureCode": "already_in_goal_state"` und `"alreadyInGoalState": true`, sodass ein Skript diesen Fall als Erfolg behandeln kann.

Wenn das Plugin [Abhängigkeiten](https://code.claude.com/docs/de/plugins/dependencies.md) deklariert, aktiviert Claude Code diese ebenfalls. In diesen Fällen schlägt der Befehl fehl:

* **Eine Abhängigkeit ist nicht installiert**: Die Aktivierung schlägt fehl und gibt für jede fehlende Abhängigkeit den Befehl `claude plugin install` aus
* **Eine Abhängigkeit wird von der Plugin-Richtlinie Ihrer Organisation blockiert**: Die Aktivierung schlägt fehl und nennt die blockierte Abhängigkeit
* **Eine Abhängigkeit ist in einem Geltungsbereich mit höherem Vorrang als dem Zielgeltungsbereich auf `false` gesetzt**: Die Aktivierung schlägt fehl. Aktivieren Sie die Abhängigkeit in diesem Geltungsbereich, oder übergeben Sie `--scope`, um dorthin zu schreiben

Ein Plugin dort erneut aktivieren, wo es deklariert ist:

```bash theme={null}
claude plugin enable formatter
```

Claude Code gibt `Successfully enabled plugin: formatter (scope: project)` aus und nennt dabei den erkannten Geltungsbereich.

### plugin disable

Deaktiviert ein Plugin, ohne es zu deinstallieren. Übergeben Sie für ein [von claude.ai synchronisiertes Plugin](https://code.claude.com/docs/de/plugins/loading.md#synced-plugins) `<name>@synced` als Plugin.

```bash theme={null}
claude plugin disable [plugin] [options]
```

| Flag | Beschreibung |
| :- | :- |
| `-a, --all` | Alle aktivierten Plugins deaktivieren. Kann nicht mit einem Plugin-Namen oder `--scope` kombiniert werden |
| `-s, --scope <scope>` | Geltungsbereich, in dem deaktiviert wird: `user`, `project` oder `local`. Wird automatisch erkannt, wenn weggelassen |
| `--json` | Gibt das Ergebnis als ein JSON-Objekt in der letzten Zeile von stdout aus, im [gleichen Format wie `plugin install --json`](#plugin-json-result). Erfordert Claude Code v2.1.268 oder höher |

Ohne `--scope` wird der Geltungsbereich in derselben Reihenfolge local, project, user automatisch erkannt wie bei [`plugin enable`](#plugin-enable).

Wenn Sie weder einen Plugin-Namen noch `--all` übergeben, gibt Claude Code `Please specify a plugin name or use --all to disable all plugins` aus und beendet sich mit `1`. Das Deaktivieren eines bereits deaktivierten Plugins gibt `Plugin "formatter" is already disabled` aus und beendet sich mit `1`, so wie [`plugin enable`](#plugin-enable) es bei einem bereits aktivierten Plugin tut.

Der Befehl schlägt bei einem Plugin fehl, das noch benötigt wird:

* **Ein anderes aktiviertes Plugin [hängt davon ab](https://code.claude.com/docs/de/plugins/dependencies.md)**: Der Befehl schlägt fehl und nennt die abhängigen Plugins, die Sie zuerst deaktivieren müssen
* **Ihre Organisation verlangt es als synchronisiertes Plugin**: Der Befehl schlägt fehl und speichert nichts

Ein Plugin deaktivieren:

```bash theme={null}
claude plugin disable formatter
```

Claude Code gibt `Successfully disabled plugin: formatter (scope: project)` aus.

### plugin update

Aktualisiert ein Plugin auf die neueste Version, die sein Marketplace anbietet. Die neue Version wird in Ihrer nächsten Sitzung geladen oder nachdem Sie in einer laufenden Sitzung `/reload-plugins` ausgeführt haben.

```bash theme={null}
claude plugin update <plugin> [options]
```

| Flag | Beschreibung |
| :- | :- |
| `-s, --scope <scope>` | Zu aktualisierender Geltungsbereich: `user`, `project`, `local` oder `managed`. Wird automatisch erkannt, wenn weggelassen |
| `-y, --yes` | Akzeptiert einen geänderten Installationsbefehl eines [Plugins mit Befehlsquelle](https://code.claude.com/docs/de/plugins/host-marketplace.md) ohne Rückfrage. Erforderlich, wenn stdin oder stdout kein TTY ist, sofern Sie nicht `--accept-command` übergeben. Erfordert Claude Code v2.1.229 oder höher |
| `--accept-command <sha256>` | Akzeptiert anstelle von `-y` den vom Marketplace deklarierten Befehl, dessen `sha256` ein vorheriger [`--json`-Lauf](#plugin-json-result) in `shownCommand` gemeldet hat. Kann nicht mit `-y` kombiniert werden. Erfordert Claude Code v2.1.271 oder höher |
| `--json` | Gibt das Ergebnis als ein JSON-Objekt in der letzten Zeile von stdout aus, im [gleichen Format wie `plugin install --json`](#plugin-json-result). Erfordert Claude Code v2.1.268 oder höher |

Ein Plugin aktualisieren:

```bash theme={null}
claude plugin update formatter@my-marketplace
```

Claude Code gibt `Checking for updates for plugin "formatter@my-marketplace"…` und dann das Ergebnis aus. Wenn nichts Neueres vorhanden ist, gibt es `formatter is already at the latest version (1.0.0).` aus und beendet sich mit `0`, es sei denn, es [versucht die Abhängigkeitsinstallation des Plugins erneut](#retry-an-unfinished-dependency-install) und diese Installation schlägt fehl.

#### Welchen Geltungsbereich der Befehl aktualisiert

Wenn Sie `--scope` weglassen, aktualisiert der Befehl das Plugin im spezifischsten Geltungsbereich, in dem es für Ihr aktuelles Projekt installiert ist, und prüft dabei local, project, user und dann managed.

Vor v2.1.281 verwendete der Befehl `user`, wenn Sie `--scope` wegließen, sodass die Aktualisierung eines nur im Projekt- oder lokalen Geltungsbereich installierten Plugins mit `Plugin "<name>" is not installed at scope user` fehlschlug. Übergeben Sie bei diesen Versionen `--scope`.

`managed` ist der einzige Geltungsbereich, den Sie aktualisieren, aber in den Sie nicht installieren können. Zu von Administratoren installierten Plugins siehe [Plugins für Ihre Organisation verwalten](https://code.claude.com/docs/de/plugins/org.md).

#### Aktualisierung über den bloßen Namen

Sie können einen bloßen Plugin-Namen übergeben, den der Befehl mit Ihren installierten Plugins abgleicht. Wenn installierte Plugins aus verschiedenen Marketplaces denselben Namen haben, lehnt der Befehl die Aktualisierung ab und listet stattdessen die auszuführenden qualifizierten Befehle mit `plugin-name@marketplace-name` auf. Die Aktualisierung über den bloßen Namen erfordert Claude Code v2.1.246 oder höher.

#### Eine unvollständige Abhängigkeitsinstallation erneut versuchen

Wenn das Plugin bereits auf der neuesten Version ist, kann der Befehl auch eine unvollständige Abhängigkeitsinstallation in seiner zwischengespeicherten Kopie erneut versuchen. Zu den Fällen, in denen dieser Wiederholungsversuch ausgeführt oder übersprungen wird, siehe [Die aufgeführten Pakete sind nicht installiert](https://code.claude.com/docs/de/plugins/troubleshooting.md#the-packages-it-lists-are-not-installed). Wenn der Wiederholungsversuch fehlschlägt, lautet die Ausgabe `Failed to update plugin "formatter@my-marketplace"` mit dem Grund, und der Exit-Code ist `1`. Vor v2.1.287 meldete der Befehl das Plugin als auf der neuesten Version, ohne die Installation erneut zu versuchen.

### plugin list

Listet installierte Plugins mit ihrer Version, ihrem Geltungsbereich und ihrem Status auf.

```bash theme={null}
claude plugin list [options]
```

| Flag | Beschreibung |
| :- | :- |
| `--json` | Die Liste als JSON ausgeben |
| `--available` | Zusätzlich Plugins auflisten, die Ihre Marketplaces anbieten und die Sie nicht installiert haben. Hat ohne `--json` keine Wirkung |
| `--data-size [plugin]` | Misst das [gespeicherte Datenverzeichnis](#what-an-uninstall-deletes-and-keeps) jedes installierten Plugins oder nur das des genannten Plugins, angegeben als `name@marketplace`. Hat ohne `--json` keine Wirkung. Wenn für den Namen kein Installationseintrag existiert, gibt der Befehl statt der Liste `--data-size names a plugin that is not installed` aus und beendet sich mit `1`. Erfordert Claude Code v2.1.285 oder höher |

Claude Code gruppiert die lesbare Ausgabe danach, wie jedes Plugin geladen wird:

* **`Installed plugins:`**: Plugins, die Sie aus einem Marketplace installiert haben
* **`Session-only plugins (--plugin-dir / --plugin-url):`**: Plugins, die durch diese Flags im selben Befehl geladen werden, wie in `claude --plugin-dir ./my-plugin plugin list`
* **`Skills-directory plugins (.claude/skills/*):`**: Plugins, die Claude Code in einem Skills-Verzeichnis gefunden hat
* **`Synced from claude.ai`**: [von Ihrem claude.ai-Konto synchronisierte Plugins](https://code.claude.com/docs/de/plugins/loading.md#synced-plugins)

Wenn keine Gruppe Einträge enthält, gibt Claude Code ``No plugins installed. Use `claude plugin install` to install a plugin.`` aus.

#### JSON-Ausgabe

Mit `--json` gibt Claude Code ein Array mit einem Objekt pro Installation aus. Jedes Objekt enthält die folgenden Felder. `id`, `version`, `scope`, `enabled` und `installPath` sind immer vorhanden, die anderen erscheinen nur, wenn sie zutreffen.

| Feld | Typ | Beschreibung |
| :- | :- | :- |
| `id` | string | `name@marketplace` für Installationen, `name@inline` für Plugins, die nur für die Sitzung gelten, `name@skills-dir` für Plugins aus dem Skills-Verzeichnis, `name@synced` für von claude.ai synchronisierte Plugins |
| `version` | string | Bei einer Marketplace-Installation die [von Claude Code berechnete Version](https://code.claude.com/docs/de/plugins/loading.md#versions-and-updates) zum Zeitpunkt der Installation. Bei einem Plugin, das nur für die Sitzung gilt, aus dem Skills-Verzeichnis stammt oder synchronisiert ist, die `version` des Manifests oder `unknown`, wenn es keine deklariert |
| `scope` | string | `user`, `project`, `local` oder `managed` für Installationen; `user` oder `project` für Plugins aus dem Skills-Verzeichnis; `session` für Plugins, die nur für die Sitzung gelten; `synced` für von claude.ai synchronisierte Plugins |
| `enabled` | boolean | Ob das Plugin in Ihren zusammengeführten Einstellungen aktiviert ist |
| `installPath` | string | Verzeichnis, aus dem das Plugin geladen wird, außer bei einem Plugin, das Sitzungen [direkt aus dem Ordner seines Marketplace laden](https://code.claude.com/docs/de/plugins/loading.md#in-place-and-copied-plugins) |
| `readFromFolder` | string | Bei einem Plugin, das Sitzungen [direkt aus dem Ordner seines Marketplace laden](https://code.claude.com/docs/de/plugins/loading.md#in-place-and-copied-plugins), das Quellverzeichnis des Plugins innerhalb dieses Ordners. Erfordert Claude Code v2.1.289 oder höher |
| `folderVersion` | string | Zusammen mit `readFromFolder` die `version` des Plugins, wie Claude Code sie aus diesem Ordner geladen hat; sie kann vom obigen Feld `version` abweichen. Fehlt, wenn das Plugin nicht geladen wurde oder keine Version deklariert. Erfordert Claude Code v2.1.289 oder höher |
| `installedAt` | string | ISO-Zeitstempel der Installation. Nur bei Marketplace-Installationen |
| `lastUpdated` | string | ISO-Zeitstempel der letzten Aktualisierung. Nur bei Marketplace-Installationen |
| `projectPath` | string | Projekt, zu dem die Installation gehört. Nur bei den Geltungsbereichen `project` und `local` |
| `mcpServers` | object | Die MCP-Server-Definitionen des Plugins, wenn ein aus einem Marketplace installiertes Plugin welche hat |
| `errors` | array of strings | Ladefehler, wenn das Plugin nicht geladen werden konnte |
| `notes` | array of strings | Warnungen, die keine Ladefehler sind, etwa Probleme bei der Erstellung oder [nicht installierte Pakete](https://code.claude.com/docs/de/plugins/loading.md#when-the-dependency-install-fails-or-is-skipped) |
| `errorDetails` | array of objects | Ein Objekt pro `errors`-Eintrag mit dessen Diagnosetyp `type` und den Namen, auf die er sich bezieht, etwa Plugin, Marketplace, Server oder Datei. Erfordert Claude Code v2.1.268 oder höher |
| `noteDetails` | array of objects | Dieselben Detailobjekte für jeden `notes`-Eintrag. Erfordert Claude Code v2.1.268 oder höher |
| `hasUserConfig` | boolean | Vorhanden und `true`, wenn das Plugin geladen wurde und sein Manifest [`userConfig`-Optionen](https://code.claude.com/docs/de/plugins/manifest-reference#user-configuration) deklariert. Fehlt bei einem Plugin, das nicht geladen werden konnte, unabhängig davon, was sein Manifest deklariert. Gespeicherte Werte sind nie enthalten. Erfordert Claude Code v2.1.285 oder höher |
| `projectEnabled` | boolean | Ob die gemeinsam genutzte `.claude/settings.json` des Projekts das Plugin einschaltet. Nur bei Marketplace-Installationen. Erfordert Claude Code v2.1.285 oder höher |
| `dataDirSize` | object | Mit `--data-size` die Größe des [gespeicherten Datenverzeichnisses](#what-an-uninstall-deletes-and-keeps) des Plugins als `bytes` und `human`; fehlt, wenn das Verzeichnis nicht vorhanden oder leer ist. Nur bei Marketplace-Installationen. Erfordert Claude Code v2.1.285 oder höher |
| `dataDirUnreadable` | boolean | Mit `--data-size` `true`, wenn das gespeicherte Datenverzeichnis existiert, aber nicht gemessen werden konnte. Nur bei Marketplace-Installationen. Erfordert Claude Code v2.1.285 oder höher |

Mit `--json --available` gibt Claude Code statt eines Arrays ein einzelnes Objekt aus. Sein Feld `installed` enthält das Array der Objekte für installierte Plugins, und sein Feld `available` enthält ein Objekt pro nicht installiertem Marketplace-Plugin mit den folgenden Feldern.

| Feld | Typ | Beschreibung |
| :- | :- | :- |
| `pluginId` | string | `name@marketplace` |
| `name` | string | Der Name des Plugins im Marketplace |
| `marketplaceName` | string | Der Marketplace, der es anbietet |
| `source` | string or object | Die [Quelle](https://code.claude.com/docs/de/plugins/marketplace-reference.md) des Marketplace-Eintrags: ein String für einen relativen Pfad, andernfalls ein Objekt |
| `description` | string | Die Beschreibung des Eintrags, sofern vorhanden |
| `version` | string | Die Version des Eintrags, sofern er eine deklariert |
| `installCount` | number | Anzahl der Installationen, sofern Claude Code eine für das Plugin hat |

### plugin details

Zeigt die Komponentenübersicht eines Plugins und seine voraussichtlichen Token-Kosten an.

Das Plugin muss geladen sein: installiert, in einem Skills-Verzeichnis gefunden oder im selben Befehl mit `--plugin-dir` oder `--plugin-url` übergeben. `<name>` ist ein Plugin-`name` oder `name@marketplace`.

```bash theme={null}
claude plugin details <name>
```

Der Befehl akzeptiert außer `--help` keine Flags.

Anzeigen, was ein installiertes Plugin beiträgt:

```bash theme={null}
claude plugin details formatter
```

Claude Code gibt Name, Version, Beschreibung und Quelle des Plugins aus, gefolgt von diesen Abschnitten:

* **`Component inventory`**: die Skills, Agenten, Hooks, MCP-Server und LSP-Server des Plugins
* **`Projected token cost`**: die dauerhaft aktiven Token, die das Plugin jeder Sitzung hinzufügt
* **`Per-component (rounded)`**: Schätzungen für dauerhaft aktive und beim Aufruf anfallende Token für jeden Skill, jeden Agenten und jeden Befehl. Entfällt, wenn das Plugin keine hat

Was die beiden Kostenangaben bedeuten, erfahren Sie unter [Kosten und Nutzung von Plugins messen](https://code.claude.com/docs/de/plugins/measure.md).

Bei einem Plugin, das nicht geladen ist, gibt Claude Code diese Meldung aus und beendet sich mit `1`:

```text theme={null}
Plugin "formatter" not found. Run `claude plugin list` to see installed plugins, or pass --plugin-dir <path> to load one from disk.
```

Eine ID, die auf `@builtin` endet, bezeichnet eines der [in Claude Code integrierten Plugins](https://code.claude.com/docs/de/plugins/mods/overview.md#mods-built-into-claude-code). Wenn Sie eine solche ID übergeben und Claude Code dieses Plugin nicht findet, lautet die Meldung stattdessen:

```text theme={null}
Plugin "<name>@builtin" not found. Built-in plugins don't appear in `claude plugin list`. To see the ones available in a session, run /plugin in Claude Code and open the Installed tab.
```

### plugin configure

Zeigt die [`userConfig`](https://code.claude.com/docs/de/plugins/manifest-reference#user-configuration)-Optionen eines installierten Plugins und welche davon gesetzt sind an, oder speichert über stdin übergebene Werte. Erfordert Claude Code v2.1.285 oder höher.

```bash theme={null}
claude plugin configure <plugin>
```

| Flag | Beschreibung |
| :- | :- |
| `--values-stdin` | Optionswerte von stdin als JSON-Objekt aus einzeiligen Strings lesen und speichern. Optionen, die Sie weglassen, behalten ihre gespeicherten Werte |
| `--json` | Das Ergebnis als ein JSON-Objekt auf stdout ausgeben. Ohne `--values-stdin` enthält das Objekt `schema` und `choices` der Optionen, ihre anfänglichen `inputs` sowie die Optionsnamen `configured` und `unconfigured`. Mit `--values-stdin` enthält es die Namen der `saved` Optionen und, sofern sie zurückgelesen werden konnten, die `unconfigured` |

Ohne Flags listet der Befehl jede Option mit bis zu drei Kennzeichnungen auf: `required` oder `optional`, dann `sensitive` für eine Option, die das Manifest als sensibel deklariert, dann `set` oder `not set`. Er gibt keine gespeicherten Werte aus. Mit `--json` enthält die Ausgabe die gespeicherten Werte von Optionen, die nicht sensibel sind, aber niemals den Text einer sensiblen Option.

Um Werte zu speichern, schreiben Sie sie als JSON-Objekt, das Optionsschlüssel auf String-Werte abbildet, in eine Datei und übergeben Sie die Datei dann über stdin. Ersetzen Sie `formatter@my-marketplace` durch die ID Ihres eigenen Plugins, wie `claude plugin list` sie anzeigt. Dieses Beispiel setzt eine Option namens `api_url` aus einer Datei `values.json`, die `{"api_url": "https://example.com"}` enthält:

```bash theme={null}
claude plugin configure formatter@my-marketplace --values-stdin < values.json
```

Claude Code validiert jeden Wert anhand des deklarierten Typs der Option und gibt `Configuration saved. Restart Claude Code to apply it.` aus. Wenn Sie einen Schlüssel übergeben, den das Manifest nicht deklariert, oder einen Wert, der die Validierung nicht besteht, speichert der Befehl nichts, gibt `Failed to save configuration:` mit dem Grund aus und beendet sich mit `1`. Mit `--json` gibt ein abgelehnter Wert zusätzlich ein Objekt auf stdout aus, dessen Feld `refused` die `message` und, wenn eine einzelne Option die Ursache ist, deren `option`-Schlüssel enthält.

Übergeben Sie die vollständige `name@marketplace`-ID des Plugins, wie `claude plugin list` sie anzeigt. `configure` akzeptiert keinen bloßen `name`. Wenn kein geladenes Plugin diese ID hat, gibt der Befehl `No installed plugin has the id "<plugin>".` aus und beendet sich mit `1`.

Zu den Einstellungen eines gebündelten MCP-Servers siehe [`plugin install --config`](#plugin-install) oder den Eintrag **Configure** in `/plugin`.

### plugin prune

Entfernt automatisch installierte [Abhängigkeiten](https://code.claude.com/docs/de/plugins/dependencies.md), die kein installiertes Plugin mehr benötigt. Der Befehl entfernt niemals ein Plugin, das Sie selbst installiert haben. `autoremove` ist ein Alias für `prune`.

```bash theme={null}
claude plugin prune [options]
```

| Flag | Beschreibung |
| :- | :- |
| `-s, --scope <scope>` | Geltungsbereich für die Bereinigung: `user`, `project` oder `local`. Standardmäßig `user` |
| `--dry-run` | Auflisten, was entfernt würde, ohne es zu entfernen |
| `-y, --yes` | Die Bestätigungsabfrage überspringen. Erforderlich, wenn stdin oder stdout kein TTY ist |

Vorschau dessen, was eine Bereinigung entfernen würde:

```bash theme={null}
claude plugin prune --dry-run
```

Claude Code listet die verwaisten Abhängigkeiten auf und endet mit `(dry run — nothing removed)`. Wenn nichts zu entfernen ist, gibt es eine Zeile aus, die mit `Nothing to prune` beginnt.

Ohne `--dry-run` entfernt der Befehl die verwaisten Abhängigkeiten erst, nachdem Sie bei der Abfrage bestätigt oder `-y` übergeben haben.

Der Exit-Code ist `0`, unabhängig davon, was Sie bei der Abfrage antworten.

Was `prune` tut, hängt davon ab, ob ein Terminal angeschlossen ist und ob Sie `-y` übergeben:

| Terminal und Flags | Was geschieht |
| :- | :- |
| Interaktives Terminal, kein `-y` | Listet die verwaisten Abhängigkeiten auf und fragt `Remove? [y/N]` |
| Beliebiges Terminal, `-y` | Entfernt sie und gibt `Removed N auto-installed plugins: <names>` aus |
| stdin oder stdout kein TTY, kein `-y` | Gibt die Liste und ``Not a TTY — run `claude plugin prune -y` to remove.`` aus und entfernt nichts |

### plugin eval

Führt die [Eval-Fälle](https://code.claude.com/docs/de/plugin-evals.md) eines Plugins aus und meldet bewertete Ergebnisse. Erfordert Claude Code v2.1.269 oder höher.

Jeder Fall besteht aus einem Prompt und Gradern. Claude Code führt ihn mehrmals in einer isolierten Sitzung aus, in der nur das Ziel-Plugin geladen ist, und standardmäßig auch ohne das Plugin, sodass der Bericht den Unterschied zeigt.

Das Fallformat, Grader, Ergebnisse und die Verwendung in CI finden Sie unter [Plugins mit Evals testen](https://code.claude.com/docs/de/plugin-evals.md).

```bash theme={null}
claude plugin eval [target] [options]
```

Das optionale `target` ist standardmäßig das aktuelle Verzeichnis und akzeptiert jede dieser Formen:

* Ein Plugin-Verzeichnis
* Eine einzelne `prompt.md`- oder `case.yaml`-Datei
* Ein installiertes Plugin als `name` oder `name@marketplace`
* `name@skills-dir`

Setzen Sie das Ziel vor `--tag`, `--allow-tools` und `--json`. Jede dieser Optionen übernimmt die nachfolgenden Wörter als ihren Wert, sodass ein Ziel, das nach einer von ihnen steht, als Tag, als Tool-Name oder als Pfad für die JSON-Ausgabe gelesen wird statt als Ziel.

Diese Tabelle listet die Optionen auf, die die meisten Läufe verwenden. Führen Sie `claude plugin eval --help` aus, um die vollständige Liste zu sehen, einschließlich `--case`, `--tag`, `--output-dir`, `--report`, `--allow-real-servers`, `--keep-temp` und `--verbose`.

| Option | Beschreibung | Standard |
| :- | :- | :- |
| `--runs <n>` | Läufe pro Fall in jedem [Arm](https://code.claude.com/docs/de/plugin-evals.md#compare-against-a-no-plugin-baseline) | `runs` des jeweiligen Falls, sonst 3 |
| `-j, --concurrency <n>` | Anzahl gleichzeitig ausgeführter Agenten-Sitzungen, 1 bis 8. Sie teilen sich Ihr Rate-Limit | `1` |
| `--model <model>` | Modell für den getesteten Agenten | `model` des jeweiligen Falls, sonst `ANTHROPIC_MODEL`, falls gesetzt, sonst der Standard von Claude Code |
| `--judge-model <model>` | Modell für die Grader `llm` und `baseline` | Das Modell für [Hintergrundaufgaben](https://code.claude.com/docs/de/plugin-evals.md#grade-the-result) |
| `--ablation <mode>` | `none` oder `with-without`. Siehe [Mit der Baseline ohne Plugin vergleichen](https://code.claude.com/docs/de/plugin-evals.md#compare-against-a-no-plugin-baseline) | Wird pro Fall entschieden, wie in jenem Abschnitt beschrieben |
| `--threshold <0..1>` | Mit 1 beenden, wenn ein Fall unter diesem Wert abschneidet | `1.0` |
| `--max-cost-usd <usd>` | Vor dem nächsten Lauf anhalten, sobald die Ausgaben diesen Wert erreichen, mit 2 beenden und Teilergebnisse melden | Kein Limit |
| `--allow-tools <tools...>` | Tools über den nur lesenden Satz hinaus gewähren, etwa `Bash`, `Write`, `Edit` oder `"mcp__plugin_<plugin>_<server>__*"`. Siehe [Tools gewähren](https://code.claude.com/docs/de/plugin-evals.md#grant-tools) | |
| `--scaffold` | Das [`scaffold_script`](https://code.claude.com/docs/de/plugin-evals#add-setup-or-history-with-case-yaml) jedes Falls ausführen | Aus |
| `--trust-plugin` | Die Vertrauensabfrage beim ersten Lauf überspringen, für CI. Siehe [Worauf ein Lauf zugreifen kann](https://code.claude.com/docs/de/plugin-evals.md#security) | Aus |
| `--mocks <mode>` | `record` oder `off`. Siehe [MCP-Server mocken](https://code.claude.com/docs/de/plugin-evals.md#mock-mcp-servers) | `record` |
| `--eval-dir <dir>` | Verzeichnis unterhalb des Plugins, das die Fälle enthält | `experimental.evals` des Manifests, sonst `evals` |
| `--json [path]` | Das [Ergebnisdokument](https://code.claude.com/docs/de/plugin-evals.md#json-result) auf stdout ausgeben oder in einen `.json`-Pfad schreiben | |
| `--no-publish` | Den HTML-Bericht lokal behalten | |

Der Exit-Code gibt an, wie der Lauf geendet hat. Wie Sie in einer Pipeline darauf reagieren, erfahren Sie unter [Evals in CI ausführen](https://code.claude.com/docs/de/plugin-evals.md#run-evals-in-ci).

| Exit-Code | Bedeutung |
| :- | :- |
| `0` | Die Suite wurde bestanden: Jeder Fall erreicht den Schwellenwert, und nichts anderes hat den Lauf fehlschlagen lassen |
| `1` | Ein fehlschlagender Fall, ein Ladefehler, ein nicht vertrauenswürdiges Plugin-Verzeichnis, ein Lauf, der [mit einem API-Fehler endete](https://code.claude.com/docs/de/plugin-evals.md#runs-ended-on-an-api-error), oder eine andere unter [Evals in CI ausführen](https://code.claude.com/docs/de/plugin-evals.md#run-evals-in-ci) aufgeführte Ursache |
| `2` | Ein unvollständiger Lauf |
| `130` | Unterbrochen |
| `143` | Beendet |

### plugin eval init

Erstellt eine Eval-Suite für das Plugin im aktuellen Verzeichnis. Erfordert Claude Code v2.1.269 oder höher. Siehe [Ihre erste Eval-Suite erstellen](https://code.claude.com/docs/de/plugin-evals.md#create-your-first-eval-suite).

```bash theme={null}
claude plugin eval init [name] [options]
```

Führen Sie den Befehl im Stammordner des Plugins aus, dem Verzeichnis, das `.claude-plugin/plugin.json` oder die `SKILL.md` des Skills enthält. Um die Suite bewusst in einem anderen Verzeichnis zu erstellen, übergeben Sie `--eval-dir`.

In einem Terminal öffnet der Befehl eine interaktive Claude Code-Sitzung für ein Erstellungsinterview. Im Interview führt Claude Folgendes aus:

1. Liest das Plugin
2. Fragt Sie, was es gut können soll
3. Schlägt Fälle und Grader vor
4. Schreibt die Falldateien
5. Führt die Fälle aus und prüft die Bewertungen mit Ihnen, um sicherzustellen, dass die Grader so bewerten, wie Sie es tun würden

Mit `--bare` oder ohne Terminal schreibt der Befehl stattdessen eine leere Vorlage für einen einzelnen Fall. Wenn Claude den Befehl aus einer Claude Code-Sitzung heraus ausführt, gibt der Befehl die Interviewanweisungen aus, denen diese Sitzung folgen soll, statt eine Vorlage zu schreiben.

Der optionale `name` ist ein Fallname. Er ist mit `--bare` oder ohne Terminal erforderlich, da der Befehl die leere Vorlage für diesen Fall schreibt. Ein Fallname beginnt mit einem Buchstaben oder einer Ziffer und enthält nur Buchstaben, Ziffern, `.`, `_` und `-`. Auf allen Plattformen lehnt der Befehl außerdem Namen ab, die Windows nicht speichern kann, etwa `con` oder einen Namen, der auf `.` endet.

Der Befehl akzeptiert diese Optionen:

| Option | Beschreibung | Standard |
| :- | :- | :- |
| `--bare` | Statt das Interview auszuführen, eine leere `prompt.md` und `graders/criteria.md` für `<name>` schreiben | |
| `-i, --interactive` | Das Interview erzwingen. Schlägt ohne Terminal fehl, statt eine Vorlage zu schreiben | |
| `--eval-dir <dir>` | Verzeichnis unterhalb des aktuellen Verzeichnisses, in das Fälle geschrieben werden | `experimental.evals` des Manifests, sonst `evals` |

### plugin tag

Erstellt ein annotiertes Git-Tag namens `<name>--v<version>` für ein Plugin-Release. Vor dem Taggen prüft der Befehl, dass die `plugin.json` des Plugins und jeder Marketplace-Eintrag, der es auflistet, bei der Version übereinstimmen.

Wann Sie ein Release taggen sollten, erfahren Sie unter [Ein Plugin veröffentlichen](https://code.claude.com/docs/de/plugins/publish.md).

```bash theme={null}
claude plugin tag [path] [options]
```

`[path]` ist das Plugin-Verzeichnis, standardmäßig das aktuelle Verzeichnis. Der Befehl findet den Marketplace-Eintrag, indem er von diesem Verzeichnis aus nach oben bis zu einer `.claude-plugin/marketplace.json` sucht, die das Plugin auflistet.

| Flag | Beschreibung |
| :- | :- |
| `--push` | Das Tag nach dem Erstellen an `--remote` pushen |
| `--dry-run` | Ausgeben, was getaggt würde, ohne das Tag zu erstellen |
| `-f, --force` | Die Prüfungen auf einen unsauberen Arbeitsbaum und ein bereits vorhandenes Tag überspringen |
| `-m, --message <msg>` | Annotationsnachricht des Tags. `%s` steht für die Version. Standardmäßig `<name> <version>` |
| `--remote <name>` | Remote, an das mit `--push` gepusht wird. Standardmäßig `origin` |

Vorschau des Tags für ein Plugin in einem Marketplace-Checkout:

```bash theme={null}
claude plugin tag plugins/formatter --dry-run
```

Claude Code gibt den Plan aus:

* Den Plugin-Namen
* Die Version und aus welcher Datei sie stammt
* Den passenden Marketplace-Eintrag, sofern vorhanden
* Den Tag-Namen
* Die Befehle `git tag` und `git push`, die es ausführen würde

Ohne `--dry-run` gibt Claude Code `Created tag formatter--v1.0.0` und entweder `Pushed to origin` oder den Push-Befehl aus, den Sie selbst ausführen müssen. Wenn der Push fehlschlägt, ist das Tag trotzdem lokal erstellt, und der Befehl beendet sich mit einem Fehler.

Der Befehl beendet sich mit `1` und gibt den Grund aus, wenn er nicht sicher taggen kann. Häufige Gründe sind:

* Keine `version` in `plugin.json` oder im Marketplace-Eintrag
* Das Tag existiert bereits
* Der Arbeitsbaum ist nicht sauber

### plugin test

Führt die Tests für einen [Mod](https://code.claude.com/docs/de/plugins/mods/overview.md) aus, ein Plugin, dessen Code Event-Handler registriert. Der Befehl benötigt keine Sitzung, keine Anmeldung und kein Netzwerk. Wie Sie einen Test schreiben, erfahren Sie unter [Einen Mod testen](https://code.claude.com/docs/de/plugins/mods/test.md).

```bash theme={null}
claude plugin test [directory]
```

`[directory]` ist das Verzeichnis des Mods, standardmäßig das aktuelle Verzeichnis. Der Befehl führt jede Datei darunter aus, deren Name auf `.test.ts` oder `.test.tsx` endet, und beendet sich mit Status 1, wenn ein Test fehlschlägt.

Die Tests für einen Mod in `./first-mod` ausführen:

```bash theme={null}
claude plugin test ./first-mod
```

### plugin validate

Validiert ein Plugin-Manifest, ein Marketplace-Manifest oder die Skills, Agenten und Befehle in einem Verzeichnis und beendet sich mit einem Code, auf den ein CI-Job reagieren kann. Den Workflow zum Erstellen, Testen und Bearbeiten finden Sie unter [Ein Plugin erstellen](https://code.claude.com/docs/de/plugins/create.md). Was der Validator in jedem Manifest prüft, finden Sie in der [Plugin-Manifest-Referenz](https://code.claude.com/docs/de/plugins/manifest-reference.md) und der [Marketplace-Referenz](https://code.claude.com/docs/de/plugins/marketplace-reference.md).

```bash theme={null}
claude plugin validate <path> [options]
```

| Flag | Beschreibung |
| :- | :- |
| `--strict` | Warnungen als Fehler behandeln, sodass nicht erkannte Felder und fehlende Metadaten, die die Laufzeit toleriert, den Lauf fehlschlagen lassen |
| `--json` | Den Validierungsbericht als ein JSON-Objekt mit denselben Exit-Codes ausgeben. Erfordert Claude Code v2.1.259 oder höher |

Ein Plugin vor dem Committen validieren:

```bash theme={null}
claude plugin validate ./my-plugin --strict
```

#### Ein Verzeichnis validieren

`<path>` ist eine [Manifestdatei](#validate-a-manifest-file) oder ein Verzeichnis. Bei einem Verzeichnis wählt Claude Code anhand dessen, was es dort findet, aus, was validiert wird:

* `.claude-plugin/marketplace.json`, sofern vorhanden
* Andernfalls `.claude-plugin/plugin.json`
* Andernfalls die Komponentendateien, ausgewählt anhand des Verzeichnisnamens. Die Validierung von Komponentendateien ohne Manifest erfordert Claude Code v2.1.233 oder höher:
  * Ein Verzeichnis namens `skills`, `agents` oder `commands`: die Dateien darin
  * Ein Verzeichnis namens `.claude`: die Verzeichnisse `skills`, `agents` und `commands` darin
  * Jedes andere Verzeichnis: diese drei Verzeichnisse unter seinem `.claude`

Wenn das Verzeichnis sowohl eine `.claude-plugin/marketplace.json` als auch eine `.claude-plugin/plugin.json` enthält, validiert Claude Code den Marketplace sowie das Manifest und die Komponentendateien des Plugins. Dies erfordert Claude Code v2.1.289 oder höher.

Claude Code folgt keinen Symlinks innerhalb des angegebenen Verzeichnisses. Was es tut, hängt davon ab, wo sich der Link befindet:

* **Ein verlinktes Verzeichnis `skills`, `agents` oder `commands` unter dem Plugin- oder `.claude`-Stamm**: Claude Code warnt, dass nichts darin gelesen wurde.
* **Ein verlinkter Eintrag innerhalb eines Verzeichnisses `skills`, `agents` oder `commands`**: Claude Code überspringt ihn und warnt pro Verzeichnis, wie viele Einträge es übersprungen hat, die eine Sitzung laden würde.
* **Das angegebene Verzeichnis `skills`, `agents` oder `commands` ist selbst ein Symlink, oder sein übergeordnetes `.claude`-Verzeichnis ist einer**: Claude Code meldet einen Fehler und prüft nichts darin. Geben Sie stattdessen das tatsächliche Verzeichnis an.

Einige Dateien werden bei einem Validierungslauf nicht gelesen:

* **Eine `SKILL.md` im Plugin-Stamm**: Wenn Sie `claude plugin validate` für ein Plugin-Verzeichnis ausführen, prüft Claude Code keine `SKILL.md` im Plugin-Stamm
* **Eine `CLAUDE.md` im Plugin-Stamm**: Bei einem Plugin-Lauf warnt Claude Code außerdem vor einer `CLAUDE.md` im Plugin-Stamm
* **Plugin-Dateien bei einem Marketplace-Lauf**: Von einem Marketplace-Verzeichnis aus öffnet Claude Code weder die Skill-, Agenten-, Befehls- oder Hook-Dateien von Plugins, die der Marketplace in anderen Verzeichnissen auflistet, noch die MCP-Server-Dateien, die sie bündeln. Um Fehler in diesen Dateien zu finden, validieren Sie jedes Plugin-Verzeichnis

#### Eine Manifestdatei validieren

Wenn die Datei weder `plugin.json` noch `marketplace.json` heißt und sich nicht in einem `.claude-plugin`-Verzeichnis befindet, entscheidet Claude Code anhand ihrer Felder, worum es sich handelt. In diesen Fällen validiert es die Datei als Marketplace, andernfalls als Plugin-Manifest:

* `plugins` ist ein Array
* `plugins` und `owner` sind beide vorhanden
* Die Datei hat ein Feld, das nur `marketplace.json` definiert, etwa `owner`, und keines, das nur `plugin.json` definiert, etwa `author`

Um die Prüfungen selbst zu wählen, benennen Sie die Datei `plugin.json` oder `marketplace.json`. Jede andere Datei in einem `.claude-plugin`-Verzeichnis validiert Claude Code als Plugin-Manifest.

#### Ausgabe und Exit-Codes

Claude Code gibt die validierte Datei, alle Fehler und Warnungen mit ihren Pfaden sowie eine Ergebniszeile aus. Der Exit-Code entspricht dem Ergebnis:

| Exit-Code | Ergebniszeile | Bedeutung |
| :- | :- | :- |
| `0` | `Validation passed` oder `Validation passed with warnings` | Das Manifest wird geladen. Mit `--strict` zusätzlich keine Warnungen |
| `1` | `Validation failed` oder `Validation failed (--strict treats warnings as errors)` | Ein Fehler oder eine Warnung unter `--strict`. [Hinweise](#advice-on-the-readme) zählen nicht, weder mit noch ohne `--strict` |
| `2` | `Unexpected error during validation: <reason>` | Der Validator selbst ist fehlgeschlagen, etwa bei einem nicht lesbaren Pfad |

Mit `--json` schreibt Claude Code den Bericht als ein JSON-Objekt mit diesen Feldern der obersten Ebene auf stdout:

* `success`: dasselbe Ergebnis, das der Exit-Code angibt
* `strict`: ob der Lauf Warnungen als Fehler behandelt hat
* `target`: der aufgelöste Pfad, den Claude Code validiert hat
* `manifest`: das eigene Ergebnis des Manifests oder `null` bei einem Lauf ohne Manifest
* `contents`: Ergebnisse pro Datei, die jeweils ihre `file` nennen und die Arrays `errors`, `warnings` und `notes` enthalten. Dateien ohne Fehler, Warnung oder Anmerkung erhalten keinen Eintrag, sodass `contents` leer ist, wenn es nichts zu melden gibt. Bei einem [Verzeichnis mit `marketplace.json` und `plugin.json`](#validate-a-directory) ist `manifest` das Ergebnis von `marketplace.json`, und die Ergebnisse von `plugin.json` stehen in `contents`
  * `gatingHooks`: ob jeder Hook eines [Mods](https://code.claude.com/docs/de/plugins/mods/overview.md), der eine Aktion ablehnen kann, etwa ein `tool.call`-Hook, einen [`.catch`-Handler](https://code.claude.com/docs/de/plugins/mods/events#handle-a-hook-that-fails) hat. Jeder Eintrag enthält `module`, `pattern`, `hook` und `hasCatch`. Erfordert Claude Code v2.1.290 oder höher
* `advice`: die [Hinweise](#advice-on-the-readme) des Laufs; jeder Eintrag nennt die README als `file` und enthält eine `message` sowie die einzufügende `installLine`. Leer, wenn es keine gibt. Erfordert Claude Code v2.1.295 oder höher

Bei Exit-Code `2` schreibt der Befehl nichts auf stdout. Die Fehlermeldung wird auf stderr ausgegeben.

#### Hinweise zur README

Ein `Advice`-Block in der Ausgabe von `claude plugin validate` bedeutet, dass die README eines Plugins keine Zeile enthält, die das Plugin aus einem Marketplace installiert, und er gibt Ihnen eine Zeile zum Hinzufügen vor. Ein Hinweis ist weder ein Fehler noch eine Warnung. Er ändert weder die Ergebniszeile noch den Exit-Code, weder mit noch ohne `--strict`. Er erfordert Claude Code v2.1.295 oder höher.

Beispielsweise gibt die Validierung des Verzeichnisses des Marketplace `acme-tools` diesen Hinweis für dessen Plugin `deploy-helper` aus:

```text theme={null}
Validating marketplace manifest: /path/to/acme-tools/.claude-plugin/marketplace.json

ℹ Advice (does not change the verdict):

  ❯ /path/to/acme-tools/plugins/deploy-helper/README.md: This README has no line that installs "deploy-helper" from a marketplace. Add the install line, which works in one step on Claude Code 2.1.275 or later.
      /plugin install deploy-helper --marketplace acme/tools

✔ Validation passed
```

Um den Hinweis zu beseitigen, fügen Sie die vorgeschlagene Zeile in die genannte README ein und führen Sie dann `claude plugin validate` erneut in Ihrer Shell aus. Der `Advice`-Block ist dann verschwunden.

Wenn die vorgeschlagene Zeile den Platzhalter `<owner>/<repo>` enthält, beseitigt das unveränderte Einfügen den Hinweis nicht. Ermitteln Sie zuerst die tatsächliche Quelle:

* **Sie haben das eigene Verzeichnis des Plugins validiert**: Wenn der Marketplace das Plugin aus einem Verzeichnis innerhalb seines eigenen auflistet, validieren Sie stattdessen dieses Verzeichnis. Wenn er das Plugin von einem anderen Ort auflistet, etwa aus einem GitHub-Repository, tragen Sie `<owner>/<repo>` selbst ein
* **Sie haben das Verzeichnis des Marketplace validiert**: Claude Code ermittelt die Quelle aus dem Remote `origin` des `.git`-Verzeichnisses auf oberster Ebene dieses Verzeichnisses. Wenn es dieses Remote nicht verwenden kann, etwa weil keines vorhanden ist, ersetzen Sie `<owner>/<repo>` selbst durch die Quelle Ihres Marketplace

Eine bereits von Ihnen geschriebene Installationszeile zählt, wenn auf `plugin install` oder dessen Kurzform `plugin i` in derselben Zeile eines der folgenden Elemente folgt. Die Schreibweisen `/plugin` und `claude plugin` zählen beide:

* `<plugin>@<marketplace>`, etwa `/plugin install deploy-helper@acme-tools`
* Der Name des Plugins und `--marketplace <source>`, etwa `/plugin install deploy-helper --marketplace acme/tools`

## claude plugin marketplace-Befehle

Führen Sie `claude plugin marketplace <subcommand>` aus Ihrer Shell aus, um die Marktplätze, von denen Sie Plugins installieren, hinzuzufügen, aufzulisten, zu aktualisieren und zu entfernen.

* **Exit-Codes**: diese Unterbefehle folgen der [Exit-Code-Konvention](#claude-plugin-commands) der Plugin-Befehle
* **Bereiche**: ihr `--scope`-Flag hat keine `-s`-Kurzform

Für das, was ein Marktplatz ist und wie Claude Code ihn zwischenspeichert, siehe [Plugin-Ladeverzeichnis](https://code.claude.com/docs/de/plugins/loading.md).

### plugin marketplace add

Fügen Sie einen Marktplatz von einem GitHub-Repository, einer git-URL, einem gehosteten `marketplace.json` oder einem lokalen Pfad hinzu, und deklarieren Sie ihn in einer Einstellungsdatei.

Nachdem Sie ihn hinzugefügt haben, installiert Claude Code alle [Abhängigkeiten](https://code.claude.com/docs/de/plugins/dependencies.md), die Ihre installierten Plugins vermisst haben.

```bash theme={null}
claude plugin marketplace add <source> [options]
```

| Flag | Beschreibung |
| :- | :- |
| `--scope <scope>` | Einstellungsdatei zum Deklarieren des Marktplatzes: `user`, `project` oder `local`. Standardwert ist `user` |
| `--sparse <paths...>` | Begrenzen Sie den git-Checkout auf diese Verzeichnisse, für Monorepos. Nur `github`- und `git`-Quellen |
| `--claudeai` | Lesen Sie das Argument als den Namen eines [auf claude.ai gehosteten Marktplatzes](https://code.claude.com/docs/de/plugins/install.md#add-from-claude-ai) statt einer Quelle. Erfordert Claude Code v2.1.273 oder später |
| `--json` | Geben Sie aus, ob der Befehl erfolgreich war, sowie seine Meldung, als ein JSON-Objekt in der letzten Zeile von stdout im [JSON-Ergebnisformat](#plugin-json-result). Hat keine Wirkung mit `--claudeai`. Erfordert Claude Code v2.1.287 oder später |

`<source>` nimmt jede der Formen in der Tabelle unten, und seine Form entscheidet den Quellentyp und wie Claude Code den Marktplatz abruft. Für das resultierende Quellobjekt siehe die [Marktplatz-Referenz](https://code.claude.com/docs/de/plugins/marketplace-reference.md).

| Sie tippen | Quellentyp | Wie Claude Code ihn abruft |
| :- | :- | :- |
| `owner/repo`, `owner/repo#ref` oder `owner/repo@ref` | `github` | Klont das GitHub-Repository, angeheftet an `ref`, wenn gegeben. Besitzer und Repo müssen GitHub-Benennungsregeln folgen |
| `user@host:path[.git][#ref]` | `git` | Klont über SSH |
| Eine `http://`- oder `https://`-URL, die auf `.git[#ref]` endet oder `/_git/` enthält, wie `https://example.com/repo.git` | `git` | Klont die URL, einschließlich Azure DevOps-URLs |
| `https://github.com/owner/repo` oder `https://gitlab.com/namespace/project`, oder das gleiche über `http://` | `git` | Klont die URL nach dem Anhängen von `.git` |
| Jede andere `http://`- oder `https://`-URL, einschließlich eines selbstgehosteten git-Hosts ohne `.git` | `url` | Ruft die URL als `marketplace.json` ab. Um stattdessen ein Repository dort zu klonen, hängen Sie `.git` an |
| `./path`, `../path`, `/path` oder `~/path` zu einem Verzeichnis | `directory` | Liest das Verzeichnis an Ort und Stelle. Unter Windows funktionieren auch `.\`, `..\` und `C:\`-Formen |
| Die gleichen Pfadformen, zu einer `.json`-Datei | `file` | Liest die Datei an Ort und Stelle |

Für einen Host, dessen Klon-URLs das `.git`-Suffix nicht tragen, wie AWS CodeCommit, fügen Sie den Marktplatz stattdessen als git-Eintrag in [`extraKnownMarketplaces`](https://code.claude.com/docs/de/settings-reference#extraknownmarketplaces) hinzu. Claude Code klont einen git-Eintrag, ob seine URL mit `.git` endet oder nicht.

Claude Code klont auch eine `gitlab.com`-URL mit verschachtelten Untergruppen, wie `https://gitlab.com/group/subgroup/project`.

Fügen Sie einen Marktplatz hinzu und teilen Sie ihn mit dem Projekt:

```bash theme={null}
claude plugin marketplace add your-org/your-marketplace --scope project
```

Claude Code druckt `Successfully added marketplace: your-marketplace (declared in project settings)`, wobei der `name` aus dem eigenen Manifest des Marktplatzes verwendet wird. Ein wiederholtes Hinzufügen oder eine ungültige Quelle druckt stattdessen eines dieser Ergebnisse:

* **Marktplatz bereits auf der Festplatte**: die Ausgabe ist `Marketplace 'your-marketplace' already on disk — declared in project settings` und der Exit-Code ist `0`
* **Unerkannte Quelle**: die Ausgabe ist `Invalid marketplace source format. Try: owner/repo, https://..., or ./path` und der Exit-Code ist `1`
* **Bloßer Host wie `gitlab.example.com/team/plugins`**: das Hinzufügen schlägt als ungültige `owner/repo`-Kurzform fehl, und die Meldung sagt Ihnen, `https://` hinzuzufügen oder einen lokalen Pfad zu verwenden

Fügen Sie einen [auf claude.ai gehosteten Marktplatz](https://code.claude.com/docs/de/plugins/install.md#add-from-claude-ai) nach dem Namen hinzu, der im `From claude.ai:`-Abschnitt von `claude plugin marketplace list` gedruckt wird:

```bash theme={null}
claude plugin marketplace add --claudeai claudeai-organization-library
```

Mit `--claudeai` weigert sich der Befehl, `--scope` und `--sparse` zu akzeptieren. Der Marktplatz wird für Ihr Konto gehostet, nicht in einer Einstellungsdatei deklariert, sodass Sie ihn nicht durch das `.claude/settings.json` eines Projekts teilen können.

### plugin marketplace list

Listet jeden Marktplatz auf, den Sie hinzugefügt haben, mit seiner Quelle.

```bash theme={null}
claude plugin marketplace list [options]
```

| Flag | Beschreibung |
| :- | :- |
| `--json` | Drucken Sie die Liste als JSON |

Claude Code druckt `Configured marketplaces:` und eine `Source:`-Zeile pro Marktplatz, oder `No marketplaces configured`.

Mit `--json` druckt Claude Code ein Array mit einem Objekt pro Marktplatz, tragend die unten aufgelisteten Felder. Jedes Feld ist ein string.

| Feld | Beschreibung |
| :- | :- |
| `name` | Der Name des Marktplatzes |
| `source` | `github`, `git`, `url`, `directory`, `file` oder `claudeai` |
| `repo` | `owner/repo`. Nur `github`-Quellen |
| `url` | Die Klon- oder Abruf-URL. Nur `git`- und `url`-Quellen |
| `path` | Der lokale Pfad. Nur `directory`- und `file`-Quellen |
| `ref` | Der angeheftete Branch oder Tag. Nur `github`- und `git`-Quellen, wenn angeheftet |
| `installLocation` | Wo Claude Code den Marktplatz zwischengespeichert hat |

Ein hinzugefügter [claude.ai-Marktplatz](https://code.claude.com/docs/de/plugins/install.md#add-from-claude-ai) hat keinen lokalen Klon, sodass sein Eintrag seine claude.ai-Identifikatoren, `marketplaceId` und `organizationUuid`, anstelle von `installLocation` trägt. Er trägt auch `scope`, wenn einer aufgezeichnet ist, und `status`.

Wenn Ihre Terminal-Sitzungen [Plugins von Ihrem claude.ai-Konto synchronisieren](https://code.claude.com/docs/de/plugins/loading.md#synced-plugins), endet die Text-Auflistung mit einem `From claude.ai:`-Abschnitt. Dieser Abschnitt nennt die Marktplätze, die claude.ai für Ihr Konto auflistet, die Sie nicht hinzugefügt haben, sowohl git-basiert als auch gehostet. Er erfordert Claude Code v2.1.273 oder später.

Um einen Marktplatz aus diesem Abschnitt hinzuzufügen, siehe [Marktplatz von claude.ai hinzufügen](https://code.claude.com/docs/de/plugins/install.md#add-from-claude-ai).

Die `--json`-Ausgabe deckt nur konfigurierte Marktplätze ab und lässt den Abschnitt weg.

### plugin marketplace remove

Entfernen Sie die Deklaration eines Marktplatzes aus Ihren Einstellungen. `rm` ist ein Alias für `remove`.

> [!WARNING]
>
> Wenn Sie einen Marktplatz aus dem letzten Bereich entfernen, der ihn deklariert, löscht Claude Code auch seinen Cache und deinstalliert jedes Plugin, das Sie von ihm installiert haben. Es löscht auch ihre gespeicherten [Optionen und Geheimnisse](https://code.claude.com/docs/de/plugins/manifest-reference.md#user-configuration) und [Daten](https://code.claude.com/docs/de/plugins/components.md#path-variables-and-persistent-data), wo es kann.
>
> Um einen Marktplatz zu aktualisieren, ohne seine Plugins zu verlieren, führen Sie stattdessen `plugin marketplace update` aus.

```bash theme={null}
claude plugin marketplace remove <name> [options]
```

Der `<name>` ist der Marktplatz-Name, den `plugin marketplace list` zeigt, nicht die Quelle, die Sie an `add` übergeben haben.

| Flag | Beschreibung |
| :- | :- |
| `--scope <scope>` | Entfernen Sie die Deklaration aus einem Einstellungsbereich: `user`, `project` oder `local`. Ohne ihn entfernt Claude Code die Deklaration aus jedem Bereich |
| `--json` | Geben Sie aus, ob der Befehl erfolgreich war, sowie seine Meldung, als ein JSON-Objekt in der letzten Zeile von stdout im [JSON-Ergebnisformat](#plugin-json-result). Erfordert Claude Code v2.1.287 oder später |

Entfernen Sie einen Marktplatz aus jedem Bereich:

```bash theme={null}
claude plugin marketplace remove your-marketplace
```

Claude Code druckt `Successfully removed marketplace: your-marketplace`. Wenn der Befehl Plugins deinstalliert, listet die Ausgabe sie unter einer Zeile wie `Also uninstalled 2 plugins from this marketplace:` auf. Um eines von ihnen erneut zu verwenden, fügen Sie den Marktplatz wieder hinzu und installieren Sie das Plugin neu.

Wenn Sie einen Bereich scopen, der den Marktplatz nicht deklariert, schlägt der Befehl fehl mit `Marketplace 'your-marketplace' is not declared in project settings. Omit --scope to remove it from all scopes.`

### plugin marketplace update

Aktualisieren Sie einen Marktplatz oder jeden Marktplatz von seiner Quelle, um neue Plugins und Versionen abzurufen. Ein Marktplatz, der mit einem Branch oder Tag `ref` hinzugefügt wurde, wird auf den neuesten Commit dieses Refs aktualisiert, nicht auf den Standard-Branch des Repositorys.

```bash theme={null}
claude plugin marketplace update [name] [options]
```

| Flag | Beschreibung |
| :- | :- |
| `--json` | Geben Sie aus, ob der Befehl erfolgreich war, sowie seine Meldung, als ein JSON-Objekt in der letzten Zeile von stdout im [JSON-Ergebnisformat](#plugin-json-result). Ohne Namen verweigert der Befehl `--json` und beendet sich mit `1`. Erfordert Claude Code v2.1.287 oder später |

Aktualisieren Sie einen Marktplatz:

```bash theme={null}
claude plugin marketplace update your-marketplace
```

Claude Code druckt `Successfully updated marketplace: your-marketplace`. Wenn Sie den Namen weglassen, druckt es eine Anzahl wie `Successfully updated 2 marketplaces`.

## /plugin in einer Sitzung

Innerhalb einer interaktiven Sitzung öffnet `/plugin` das Plugin-Panel. Jeder Unterbefehl öffnet das Panel auf einem Tab, führt eine Aktion dort aus oder druckt ein Ergebnis inline. `/plugins` und `/marketplace` sind Aliase für `/plugin`.

Sie können diese Befehle nur in einer interaktiven Terminal-Sitzung ausführen. In einem nicht-interaktiven Lauf wie `claude -p` antwortet Claude Code, dass `/plugin` in dieser Umgebung nicht verfügbar ist.

Für welche Oberflächen `/plugin` haben, wie man ohne es installiert, und was jeder Panel-Tab zeigt, siehe [Plugins installieren und verwalten](https://code.claude.com/docs/de/plugins/install.md).

Ein `<plugin>` ist ein Plugin-`name` oder `name@marketplace`.

Die Tabelle unten listet jede Sitzungsform auf. Die Shell-Unterbefehle `init`, `update`, `details`, `prune`, `eval`, `eval init` und `test` haben keine Sitzungsform.

| Befehl | Aliase | Was er tut |
| :- | :- | :- |
| `/plugin` | | Öffnet das Panel auf dem **Discover**-Tab. Jedes unerkannte erste Wort nach `/plugin` tut das gleiche |
| `/plugin help` | `/plugin --help`, `/plugin -h` | Zeigt die Nutzungsliste der `/plugin`-Unterbefehle |
| `/plugin list [--enabled\|--disabled]` | `ls` | Druckt Ihre über einen Marketplace installierten Plugins inline, mit Version, Geltungsbereich und Status. Ein Filter-Flag zeigt nur diesen Status. Ein Plugin, dessen Aktivierungsstatus noch nicht angewendet wurde, ist mit `— run /reload-plugins to apply` gekennzeichnet |
| `/plugin install` | `i` | Öffnet den **Discover**-Tab |
| `/plugin install <plugin>` | `i` | Öffnet die Details des Plugins im **Discover**-Tab. Mit `name@marketplace` öffnet sie in der Liste dieses Marktplatzes |
| `/plugin install <source>` | `i` | Meldet einen [Marktplatz nicht gefunden](https://code.claude.com/docs/de/plugins/troubleshooting.md#marketplace-not-found)-Fehler und installiert nichts, wenn das Ziel ein Pfad, eine URL oder `owner/repo` ist, auch eine Quelle, die Sie bereits hinzugefügt haben. Um von einer Quelle zu installieren, siehe [Marktplatz hinzufügen und in einem Befehl installieren](https://code.claude.com/docs/de/plugins/install.md#add-a-marketplace-and-install-in-one-command) |
| `/plugin install <plugin> --marketplace <source>` | `i` | Fügt den Marktplatz unter `<source>` hinzu, wenn Sie ihn noch nicht hinzugefügt haben, und fragt Sie zuerst zur Bestätigung auf, dann öffnet die Details des Plugins. Siehe [Marktplatz hinzufügen und in einem Befehl installieren](https://code.claude.com/docs/de/plugins/install.md#add-a-marketplace-and-install-in-one-command). Erfordert Claude Code v2.1.275 oder später |
| `/plugin manage` | | Öffnet den **Installed**-Tab |
| `/plugin stats` | | Öffnet den **Stats**-Tab, in Sitzungen, wo [`/skill-doctor`](https://code.claude.com/docs/de/skills#find-unused-skills) verfügbar ist. Überall sonst öffnet es das Panel auf dem **Discover**-Tab |
| `/plugin enable <plugin>` | | Öffnet den **Installed**-Tab beim Plugin und aktiviert es |
| `/plugin disable <plugin>` | | Öffnet den **Installed**-Tab beim Plugin und deaktiviert es |
| `/plugin uninstall <plugin>` | | Öffnet den **Installed**-Tab beim Plugin und deinstalliert es |
| `/plugin configure <plugin>` | `config` | Öffnet den [`userConfig`](https://code.claude.com/docs/de/plugins/manifest-reference)-Dialog des Plugins, oder meldet, dass das Plugin keinen deklariert |
| `/plugin validate <path>` | | Druckt den gleichen Bericht wie `claude plugin validate`, inline |
| `/plugin tag [path] [--push] [--dry-run] [--force]` | | Erstellt das Release-Tag wie `claude plugin tag`. Akzeptiert `--push`, `--dry-run` und `--force` oder `-f`; mit jedem anderen Flag oder einem zusätzlichen Argument druckt Claude Code stattdessen die Nutzung |
| `/plugin marketplace` | `market` | Tut nichts Sichtbares. Übergeben Sie `add`, `list`, `update` oder `remove` |
| `/plugin marketplace add [source]` | `market add` | Mit einer Quelle fügt sie sie hinzu und meldet das Ergebnis. Ohne eine öffnet sie die **Add marketplace**-Eingabe |
| `/plugin marketplace list` | `market list` | Druckt Ihre Marktplatz-Namen inline |
| `/plugin marketplace update [name]` | `market update` | Öffnet den **Marketplaces**-Tab. Mit einem Namen aktualisiert sie diesen Marktplatz dort |
| `/plugin marketplace remove [name]` | `market remove`, `market rm`, `marketplace rm` | Öffnet den **Marketplaces**-Tab. Mit einem Namen entfernt sie diesen Marktplatz dort |

Wenn Sie ein Plugin benennen, das nicht im aktuellen Projekt installiert ist, in `/plugin enable`, `disable`, `uninstall` oder `configure`, druckt Claude Code stattdessen `Plugin "<plugin>" is not installed in this project`.

## /reload-plugins

Wenden Sie ausstehende Plugin-Änderungen auf die laufende Sitzung an, ohne sie neu zu starten. Ausstehende Änderungen sind Plugins, die Sie seit dem Start der Sitzung installiert, aktualisiert, aktiviert, deaktiviert oder auf der Festplatte bearbeitet haben.

Wenn Sie das `/plugin`-Panel mit ausstehenden Änderungen schließen, die Sie darin vorgenommen haben, führt Claude Code `/reload-plugins` für Sie aus. Führen Sie es selbst nach Plugin-Änderungen aus, die außerhalb des Panels stattfinden, wie ein `claude plugin`-Befehl, den Sie in einem anderen Terminal ausgeführt haben.

```text theme={null}
/reload-plugins [--force]
```

| Flag | Beschreibung |
| :- | :- |
| `--force` | Wenden Sie das Neuladen an, auch wenn es den Prompt-Cache ungültig machen würde. `force` ohne Bindestriche funktioniert auch |

### Neuladen-Zusammenfassung

Claude Code lädt jedes aktive Plugin neu und druckt eine Zusammenfassungszeile, `Reloaded: N plugins · N skills · N agents · N hooks · N plugin MCP servers · N plugin LSP servers`, wobei die Plugin-MCP-Server-Anzahl in einer Sitzung ohne interaktives Terminal weggelassen wird. Wenn ein Plugin fehlgeschlagen ist, fügt die Zusammenfassung `N errors during load. Run /plugin for details.` hinzu.

Die Skills-Anzahl deckt jeden Skill ab, den ein Plugin bereitstellt, sowohl seine `commands/`-Einträge als auch seine SKILL.md-Skills. Die Agents-Anzahl ist die Anzahl der in der Sitzung geladenen Agents, einschließlich derjenigen, die nicht von Plugins stammen.

Wenn die [Abhängigkeiten](https://code.claude.com/docs/de/plugins/dependencies.md) eines neu geladenen Plugins fehlen, installiert Claude Code sie, lädt erneut und hängt `(+ N dependencies: <names>) resolved` an die Zusammenfassung an.

### Neuladungen, die MCP-Tools ändern

Wenn das Neuladen einen Plugin-MCP-Server oder das `LSP`-Tool hinzufügen oder entfernen würde, und diese Änderung würde den [Prompt-Cache](https://code.claude.com/docs/de/prompt-caching.md#enabling-or-disabling-a-plugin) ungültig machen, wendet Claude Code das Neuladen nicht an. Es druckt eine Zeile wie `This reload changes MCP tools (<server>) — your next message will re-read the whole conversation instead of using the cache. Run /reload-plugins --force to apply.` Übergeben Sie `--force`, um es trotzdem anzuwenden.

### Sitzungen ohne interaktives Terminal

`/reload-plugins` läuft auch in Sitzungen ohne interaktives Terminal, wie die Desktop-App, das Agent SDK und [nicht-interaktiver Modus](https://code.claude.com/docs/de/headless.md) mit `-p`. Erfordert Claude Code v2.1.260 oder später.

In diesen Sitzungen läuft der Befehl nur, wenn Sie ihn selbst in die Sitzung eingeben, wie in der `-p`-Eingabeaufforderung oder dem Eingabefeld der Desktop-App. Wenn er auf andere Weise ankommt, wie durch [Remote Control](https://code.claude.com/docs/de/remote-control.md) oder eine von Slack weitergeleitet Meldung, antwortet der Befehl `/reload-plugins isn't available over a remote connection in this session.` und lädt nichts neu.

Das Neuladen in diesen Sitzungen verbindet oder trennt Plugin-MCP-Server nicht. Diese Änderungen treten in Ihrer nächsten Sitzung in Kraft.

## Flags, die ein Plugin für eine Sitzung laden

Zwei `claude`-Flags laden ein Plugin für eine Sitzung nur, ohne es zu installieren. Beide sind wiederholbar.

Plugin-Autoren verwenden sie, um ein Plugin vor der Veröffentlichung zu testen. Für den Laden-Bearbeiten-Neuladen-Workflow siehe [Entwickeln ohne einen Marktplatz](https://code.claude.com/docs/de/plugins/create.md#develop-without-a-marketplace).

| Flag | Beschreibung | Beispiel |
| :- | :- | :- |
| `--plugin-dir <path>` | Laden Sie ein Plugin aus einem Verzeichnis oder einem `.zip`-Archiv davon. Ein Ordner von Plugins lädt jeden Unterordner, der ein `.claude-plugin/plugin.json` hält. Jedes Flag nimmt einen Pfad | `claude --plugin-dir ./my-plugin --plugin-dir ./other.zip` |
| `--plugin-url <url>` | Rufen Sie ein Plugin `.zip`-Archiv von einer URL ab. Wiederholen Sie das Flag, oder übergeben Sie mehrere URLs durch Leerzeichen getrennt in einem angeführten Wert | `claude --plugin-url "https://example.com/a.zip https://example.com/b.zip"` |

Ein Plugin, das eines dieser Flags lädt, ist ein Sitzungs-Plugin. [`claude plugin list`](#plugin-list) zeigt es nur, wenn das gleiche Flag dem Unterbefehl vorausgeht, wie in `claude --plugin-dir ./my-plugin plugin list`. Das Plugin wird als `<name>@inline` unter einer Überschrift angezeigt, die mit `Session-only plugins` beginnt, und `--json` meldet seinen `scope` als `session`.

Wenn ein Sitzungs-Plugin einen Namen mit einem installierten Plugin teilt, lädt Claude Code die Sitzungs-Kopie für diese Sitzung und überspringt die installierte. Die installierte Kopie wird stattdessen geladen, wenn Sie die Sitzungs-Kopie mit `claude plugin disable <name>@inline` deaktiviert haben, oder wenn verwaltete Einstellungen diesen Plugin-Namen sperren. Für den Vorrang siehe [Plugin-Ladeverzeichnis](https://code.claude.com/docs/de/plugins/loading.md).

Ein Administrator kann beide Flags und Ordner, die in der [`CLAUDE_CODE_PLUGIN_DIRS`](https://code.claude.com/docs/de/env-vars#variables)-Variable benannt sind, mit der verwalteten [`disableSideloadFlags`](https://code.claude.com/docs/de/settings-reference#disablesideloadflags)-Einstellung ablehnen. Claude Code druckt dann, dass das Flag durch die verwalteten Einstellungen Ihrer Organisation deaktiviert ist, und beendet sich mit `1` ohne zu starten.

Aus dem Agent SDK ist die [`plugins`](https://code.claude.com/docs/de/agent-sdk/plugins)-Option das Äquivalent von `--plugin-dir`.

## Nächste Schritte

* [Plugins installieren und verwalten](https://code.claude.com/docs/de/plugins/install.md): die gleichen Operationen wie Schritte, mit dem, was Sie bei jedem sehen
* [Plugin-Ladeverweis](https://code.claude.com/docs/de/plugins/loading.md): was jeder Befehl auf der Festplatte ändert und welcher Bereich wirksam wird
* [Plugins Fehlerbehebung](https://code.claude.com/docs/de/plugins/troubleshooting.md): Installations-, Marketplace-, Lade- und Validierungsfehlermeldungen mit ihren Lösungen
* [Plugin-Manifest-Verweis](https://code.claude.com/docs/de/plugins/manifest-reference.md): die Felder, die `claude plugin validate` überprüft