Go Premium Account

plugins-reference.md 2026-09-24 22:57 UTC to 2026-09-25 23:58 UTC

This page contains 0 additions and 1645 deletions.

2026

Wed 9 22:58 Sat 12 03:02 Fri 18 23:58 Tue 22 23:59 Fri 25 23:58

This document has no rendered page for this history range.

plugins-reference.md +0 −1645 deleted

File Deleted View Diff

~~1> ## Documentation Index~~

~~2> Fetch the complete documentation index at: https://code.claude.com/docs/llms.txt~~

~~3> Use this file to discover all available pages before exploring further.~~

~~5# Plugins-Referenz~~

~~7> Vollständige technische Referenz für das Claude Code Plugin-System, einschließlich Schemas, CLI-Befehle und Komponentenspezifikationen.~~

~~9<Tip>~~

10 Möchten Sie Plugins installieren? Siehe [Plugins entdecken und installieren](/docs/de/discover-plugins). Zum Erstellen von Plugins siehe [Plugins](/docs/de/plugins). Zum Verteilen von Plugins siehe [Plugin-Marktplätze](/docs/de/plugin-marketplaces).

~~11</Tip>~~

13Ein **Plugin** ist ein eigenständiges Verzeichnis von Komponenten, das Claude Code mit benutzerdefinierten Funktionen erweitert. Plugin-Komponenten umfassen Skills, Agents, Hooks, MCP-Server, LSP-Server und Monitore.

~~15<h2 id="plugin-components-reference">~~

~~16 Referenz für Plugin-Komponenten~~

~~17</h2>~~

~~19<h3 id="skills">~~

~~20 Skills~~

~~21</h3>~~

~~23Plugins fügen Claude Code Skills hinzu und erstellen `/name` Shortcuts, die Sie oder Claude aufrufen können.~~

~~25**Speicherort**: `skills/` oder `commands/` Verzeichnis im Plugin-Root oder eine einzelne `SKILL.md` Datei im Plugin-Root~~

~~27**Dateiformat**: Skills sind Verzeichnisse mit `SKILL.md`; Commands sind einfache Markdown-Dateien~~

~~29**Skill-Struktur**:~~

~~31```text theme={null}~~

~~32skills/~~

~~33├── pdf-processor/~~

~~34│ ├── SKILL.md~~

~~35│ ├── reference.md (optional)~~

~~36│ └── scripts/ (optional)~~

~~37└── code-reviewer/~~

~~38 └── SKILL.md~~

~~39```~~

~~41Skills und Commands werden automatisch erkannt, wenn das Plugin installiert wird.~~

43Wenn ein Plugin kein `skills/` Verzeichnis und kein `skills` Manifest-Feld hat, wird eine `SKILL.md` im Plugin-Root als einzelner Skill geladen. Setzen Sie das Frontmatter-Feld `name`, um den Aufrufen-Namen des Skills zu steuern. Ohne dieses Feld greift Claude Code auf den Installationsverzeichnisnamen zurück. Für ein Plugin, das [in den Cache kopiert wurde](#plugin-caching-and-file-resolution), ist dieser Name ein Versionsstring, der sich bei jedem Update ändert. Für Plugins, die mehr als einen Skill bereitstellen, verwenden Sie das oben gezeigte `skills/` Verzeichnis-Layout.

45In Plugin-Skills und Commands akzeptieren Boolean-Frontmatter-Felder wie `disable-model-invocation` `yes`, `no`, `on`, `off`, `1` und `0` in beliebiger Schreibweise zusätzlich zu `true` und `false`. Vor v2.1.218 erkannte Claude Code nur `true` und `false`.

~~47Vollständige Details finden Sie unter [Skills](/docs/de/skills).~~

~~49<h3 id="agents">~~

~~50 Agents~~

~~51</h3>~~

~~53Plugins können spezialisierte Subagents für spezifische Aufgaben bereitstellen, die Claude automatisch aufrufen kann, wenn dies angemessen ist.~~

~~55**Speicherort**: `agents/` Verzeichnis im Plugin-Root~~

~~57**Dateiformat**: Markdown-Dateien, die Agent-Fähigkeiten beschreiben~~

~~59**Agent-Struktur**:~~

~~61```markdown theme={null}~~

~~62name: agent-name~~

~~63description: Worauf sich dieser Agent spezialisiert und wann Claude ihn aufrufen sollte~~

~~64model: sonnet~~

~~65effort: medium~~

~~66maxTurns: 20~~

~~67disallowedTools: Write, Edit~~

~~69Detaillierte Systemaufforderung für den Agent, die seine Rolle, Expertise und sein Verhalten beschreibt.~~

~~70```~~

~~72<h4 id="plugin-agent-frontmatter">~~

~~73 Plugin-Agent-Frontmatter~~

~~74</h4>~~

76Eine Plugin-Agent-Datei verwendet die gleichen [Frontmatter-Felder wie eine Subagent-Datei](/docs/de/sub-agents#supported-frontmatter-fields), aber Claude Code berücksichtigt nur einige davon, wenn der Agent von einem Plugin stammt:

78* **Unterstützt**: `name`, `description`, `model`, `effort`, `maxTurns`, `tools`, `disallowedTools`, `skills`, `memory`, `background`, `omitClaudeMd`, `isolation`, `color` und `experimental`. Der einzige gültige `isolation` Wert ist `"worktree"`.

79* **Nicht unterstützt, aus Sicherheitsgründen**: `hooks`, `mcpServers` und `permissionMode`. Claude Code ignoriert diese, wenn der Agent von einem Plugin geladen wird. Um sie zu verwenden, kopieren Sie die Agent-Datei in `.claude/agents/` oder `~/.claude/agents/`.

~~80* **Nicht unterstützt**: `initialPrompt`.~~

82Sie können Plugin-Agent-Dateien in Unterordnern von `agents/` ablegen. Claude Code [lädt sie rekursiv](/docs/de/sub-agents#choose-the-subagent-scope) und verbindet den Plugin-Namen, jeden Unterordnernamen und den Dateinamen mit Doppelpunkten, um den scoped Namen des Agents zu bilden. Zum Beispiel wird `agents/review/security.md` in einem Plugin namens `my-plugin` als `my-plugin:review:security` geladen. Zwei Einstellungen ändern diesen Namen:

~~84* Frontmatter `name`: Es ersetzt nur den Dateinamen, daher wird `name: audit` in `agents/review/security.md` als `my-plugin:review:audit` geladen~~

85* Manifest [`agents`](#component-path-fields) Feld: Eine Datei, die Sie dort auflisten, wird ohne Unterordnernamen geladen, daher wird `"agents": "./custom/review/security.md"` als `my-plugin:security` geladen

~~87Claude Code lädt einen Plugin-Agent auch dann, wenn sein Frontmatter kein `name` Feld hat oder nicht geparst werden kann:~~

~~89* Kein `name`: Claude Code benennt den Agent nach der Datei, also wird `agents/reviewer.md` in einem Plugin namens `my-plugin` als `my-plugin:reviewer` geladen~~

~~90* Frontmatter, das nicht geparst werden kann: Claude Code benennt den Agent nach der Datei, verwendet `Agent from my-plugin plugin` als Beschreibung und ignoriert jedes Feld in der Datei~~

~~92Im Gegensatz dazu überspringt Claude Code eine Projekt-, Benutzer- oder verwaltete Agent-Datei, deren Frontmatter kein `name` Feld hat oder nicht geparst werden kann.~~

94Um Dateien im Standard-`agents/` Verzeichnis eines Plugins zu finden, deren Frontmatter nicht geparst werden kann, führen Sie `claude plugin validate` aus. Der Pfad, den Sie übergeben, hängt davon ab, ob das Plugin ein Manifest hat, und beide Beispiele verwenden `./my-plugin` als Plugin-Verzeichnis:

~~96* Ein Plugin mit Manifest: `claude plugin validate ./my-plugin`~~

~~97* Ein Plugin ohne Manifest: `claude plugin validate ./my-plugin/agents`. Erfordert Claude Code v2.1.233 oder später.~~

~~99Agents erscheinen in der [@-Mention Typeahead](/docs/de/sub-agents#invoke-subagents-explicitly) unter ihrem scoped Namen, wie `my-plugin:code-reviewer`, sobald das Plugin aktiviert ist.~~

~~100~~

101Vollständige Details finden Sie unter [Subagents](/docs/de/sub-agents).

~~102~~

103<h3 id="hooks">

104 Hooks

105</h3>

~~106~~

107Plugins können Event-Handler bereitstellen, die automatisch auf Claude Code Events reagieren.

~~108~~

109**Speicherort**: `hooks/hooks.json` im Plugin-Root oder inline in plugin.json

~~110~~

111**Format**: JSON-Konfiguration mit Event-Matchern und Aktionen

~~112~~

113`hooks/hooks.json` kann einen Top-Level-Schlüssel `$schema` enthalten, der eine JSON-Schema-URL für Editor-Autovervollständigung und Validierung benennt. Claude Code ignoriert den Schlüssel beim Laden.

~~114~~

115**Hook-Konfiguration**:

~~116~~

117```json theme={null}

118{

119 "hooks": {

120 "PostToolUse": [

121 {

122 "matcher": "Write|Edit",

123 "hooks": [

124 {

125 "type": "command",

126 "command": "\"${CLAUDE_PLUGIN_ROOT}\"/scripts/format-code.sh"

127 }

128 ]

129 }

130 ]

131 }

132}

133```

~~134~~

135Plugin-Hooks reagieren auf die gleichen Lifecycle-Events wie [benutzerdefinierte Hooks](/docs/de/hooks):

~~136~~

137| Ereignis | Wann es ausgelöst wird |

138| :-------------------- | :----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |

139| `SessionStart` | Wenn eine Sitzung beginnt oder fortgesetzt wird |

140| `Setup` | Wenn Sie Claude Code mit `--init-only` starten oder mit `--init` oder `--maintenance` im `-p`-Modus. Für einmalige Vorbereitung in CI oder Skripten |

141| `UserPromptSubmit` | Wenn Sie eine Eingabeaufforderung absenden, bevor Claude sie verarbeitet |

142| `UserPromptExpansion` | Wenn ein von Ihnen eingegebener Befehl in eine Eingabeaufforderung erweitert wird, bevor sie Claude erreicht. Kann die Erweiterung blockieren |

143| `PreToolUse` | Bevor ein Werkzeugaufruf ausgeführt wird. Kann ihn blockieren |

144| `PermissionRequest` | Wenn ein Werkzeugaufruf eine Genehmigungsentscheidung benötigt |

145| `PermissionDenied` | Wenn der automatische Modus einen Werkzeugaufruf ablehnt, einschließlich Ablehnungen ohne Klassifizierer-Urteil. Verwenden Sie JSON `hookSpecificOutput.retry: true`, um dem Modell mitzuteilen, dass es den abgelehnten Werkzeugaufruf möglicherweise erneut versuchen kann. Claude Code ignoriert `retry`, wenn der Klassifizierer kein Urteil gefällt hat |

146| `PostToolUse` | Nach erfolgreichem Werkzeugaufruf |

147| `PostToolUseFailure` | Nach fehlgeschlagenem Werkzeugaufruf |

148| `PostToolBatch` | Nach Auflösung eines vollständigen Satzes paralleler Werkzeugaufrufe, bevor der nächste Modellaufruf erfolgt |

149| `Notification` | Wenn Claude Code eine Benachrichtigung sendet |

150| `MessageDisplay` | Während der Text der Assistentnachricht angezeigt wird |

151| `SubagentStart` | Wenn ein Subagent erzeugt wird |

152| `SubagentStop` | Wenn ein Subagent beendet wird |

153| `TaskCreated` | Wenn eine Aufgabe über `TaskCreate` erstellt wird |

154| `TaskCompleted` | Wenn eine Aufgabe als abgeschlossen markiert wird |

155| `Stop` | Wenn Claude die Antwort beendet |

156| `StopFailure` | Wenn die Runde aufgrund eines API-Fehlers endet |

157| `TeammateIdle` | Wenn ein [Agent-Team](/docs/de/agent-teams)-Teamkollege im Begriff ist, untätig zu werden |

158| `InstructionsLoaded` | Wenn eine CLAUDE.md- oder `.claude/rules/*.md`-Datei in den Kontext geladen wird. Wird beim Sitzungsstart und beim verzögerten Laden von Dateien während einer Sitzung ausgelöst |

159| `ConfigChange` | Wenn sich eine Konfigurationsdatei während einer Sitzung ändert |

160| `CwdChanged` | Wenn sich das Arbeitsverzeichnis ändert, z. B. wenn Claude einen `cd`-Befehl ausführt. Nützlich für reaktive Umgebungsverwaltung mit Tools wie direnv |

161| `DirectoryAdded` | Wenn ein Arbeitsverzeichnis während einer Sitzung über `/add-dir` oder die SDK-Steueranforderung `register_repo_root` hinzugefügt wird |

162| `FileChanged` | Wenn sich eine überwachte Datei auf der Festplatte ändert. Das Feld `matcher` gibt an, welche Dateinamen überwacht werden sollen |

163| `WorktreeCreate` | Wenn ein Worktree über `--worktree`, `isolation: "worktree"` oder für eine Hintergrundsitzung erstellt wird. Ersetzt das Standard-Git-Verhalten |

164| `WorktreeRemove` | Wenn ein Worktree beim Sitzungsende, beim Beenden eines Subagenten oder beim Löschen einer Hintergrundsitzung entfernt wird |

165| `PreCompact` | Vor Kontextkomprimierung |

166| `PostCompact` | Nach Abschluss der Kontextkomprimierung |

167| `PreModelSwitch` | Bevor Claude Code einen Modellwechsel anwendet, den Sie oder ein Client angefordert haben. Kann den Wechsel blockieren |

168| `PostModelSwitch` | Nach Änderung des Modells der Sitzung, einschließlich Änderungen, die Claude Code selbst vornimmt, z. B. Wiederherstellung des Modells beim Fortsetzen einer Sitzung |

169| `Elicitation` | Wenn ein MCP-Server während eines Werkzeugaufrufs Benutzereingaben anfordert |

170| `ElicitationResult` | Nachdem ein Benutzer auf eine MCP-Abfrage antwortet, bevor die Antwort an den Server zurückgesendet wird |

171| `SessionEnd` | Wenn eine Sitzung beendet wird |

~~172~~

173**Hook-Typen**:

~~174~~

175* `command`: Shell-Commands oder Scripts ausführen

176* `http`: Das Event-JSON als POST-Request an eine URL senden

177* `mcp_tool`: Ein Tool auf einem konfigurierten [MCP Server](/docs/de/mcp) aufrufen

178* `prompt`: Eine Aufforderung mit einem LLM evaluieren (verwendet `$ARGUMENTS` Platzhalter für Kontext)

179* `agent`: Einen agentic Verifier mit Tools für komplexe Verifikationsaufgaben ausführen

~~180~~

181Hooks, die auf den eigenen [gebündelten MCP Server](#mcp-servers) des Plugins abzielen, müssen seine scoped Namen verwenden. Tool-Matcher und `if` Felder verwenden den scoped Tool-Namen `mcp__plugin_<plugin-name>_<server-name>__<tool>`, und das `server` Feld eines `mcp_tool` Hooks verwendet `plugin:<plugin-name>:<server-name>`. Ein Matcher, der gegen den bloßen Server-Schlüssel geschrieben wird, wird nie ausgelöst. Siehe [Match MCP tools](/docs/de/hooks#match-mcp-tools) und [Plugin-bereitgestellte MCP Server](/docs/de/mcp#plugin-provided-mcp-servers).

~~182~~

183<h3 id="mcp-servers">

184 MCP servers

185</h3>

~~186~~

187Plugins können Model Context Protocol (MCP) Server bündeln, um Claude Code mit externen Tools und Services zu verbinden.

~~188~~

189**Speicherort**: `.mcp.json` im Plugin-Root oder inline in plugin.json

~~190~~

191**Format**: Standard MCP Server-Konfiguration

~~192~~

193**MCP Server-Konfiguration**:

~~194~~

195```json theme={null}

196{

197 "mcpServers": {

198 "plugin-database": {

199 "command": "${CLAUDE_PLUGIN_ROOT}/servers/db-server",

200 "args": ["--config", "${CLAUDE_PLUGIN_ROOT}/config.json"],

201 "env": {

202 "DB_PATH": "${CLAUDE_PLUGIN_ROOT}/data"

203 }

204 },

205 "plugin-api-client": {

206 "command": "npx",

207 "args": ["@company/mcp-server", "--plugin-mode"]

208 }

209 }

210}

211```

~~212~~

213**Integrations-Verhalten**:

~~214~~

215* Plugin MCP Server starten automatisch, wenn das Plugin aktiviert ist

216* Server erscheinen als Standard MCP Tools in Claudes Toolkit

217* Plugin Server können unabhängig von Benutzer MCP Servern konfiguriert werden

218* Wenn Sie [`/reload-plugins`](/docs/de/discover-plugins#apply-plugin-changes-without-restarting) während einer Session ausführen, behält Claude Code die Live-Verbindungen von Servern bei, deren Konfiguration unverändert ist

~~219~~

220<h3 id="lsp-servers">

221 LSP servers

222</h3>

~~223~~

224<Tip>

225 Möchten Sie LSP Plugins verwenden? Installieren Sie diese aus dem offiziellen Marketplace: Suchen Sie nach "lsp" im `/plugin` Discover Tab. Dieser Abschnitt dokumentiert, wie Sie LSP Plugins für Sprachen erstellen, die nicht vom offiziellen Marketplace abgedeckt werden.

226</Tip>

~~227~~

228Plugins können [Language Server Protocol](https://microsoft.github.io/language-server-protocol/) (LSP) Server bereitstellen, um Claude [Echtzeit-Code-Intelligenz](/docs/de/discover-plugins#code-intelligence) beim Arbeiten an Ihrer Codebasis zu geben.

~~229~~

230**Speicherort**: `.lsp.json` im Plugin-Root oder inline in `plugin.json`

~~231~~

232**Format**: JSON-Konfiguration, die Language Server Namen ihren Konfigurationen zuordnet

~~233~~

234**`.lsp.json` Dateiformat**:

~~235~~

236```json theme={null}

237{

238 "go": {

239 "command": "gopls",

240 "args": ["serve"],

241 "extensionToLanguage": {

242 ".go": "go"

243 }

244 }

245}

246```

~~247~~

248**Inline in `plugin.json`**:

~~249~~

250```json theme={null}

251{

252 "name": "my-plugin",

253 "lspServers": {

254 "go": {

255 "command": "gopls",

256 "args": ["serve"],

257 "extensionToLanguage": {

258 ".go": "go"

259 }

260 }

261 }

262}

263```

~~264~~

265**Erforderliche Felder:**

~~266~~

267| Feld | Beschreibung |

268| :-------------------- | :--------------------------------------------------- |

269| `command` | Die auszuführende LSP-Binärdatei (muss in PATH sein) |

270| `extensionToLanguage` | Ordnet Dateierweiterungen Sprachbezeichnern zu |

~~271~~

272**Optionale Felder:**

~~273~~

274| Feld | Beschreibung |

275| :---------------------- | :---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |

276| `args` | Befehlszeilenargumente für den LSP Server |

277| `transport` | Kommunikations-Transport: `stdio` (Standard) oder `socket`. Claude Code akzeptiert `socket`, führt aber jeden Server über stdio aus, daher gelten die stdout-Protokoll-Regeln für alle Server |

278| `env` | Umgebungsvariablen, die beim Starten des Servers gesetzt werden |

279| `initializationOptions` | Optionen, die während der Initialisierung an den Server übergeben werden |

280| `settings` | Einstellungen, die über `workspace/didChangeConfiguration` übergeben werden |

281| `workspaceFolder` | Workspace-Ordnerpfad für den Server |

282| `startupTimeout` | Maximale Wartezeit für Server-Start (Millisekunden) |

283| `shutdownTimeout` | Maximale Wartezeit für ordnungsgemäßes Herunterfahren (Millisekunden). Wenn das Timeout abläuft, beendet Claude Code den Server-Prozess. Wenn nicht gesetzt, gilt kein Timeout |

284| `restartOnCrash` | Ob der Server nach einem Absturz neu gestartet werden soll. Standard ist `true`. Setzen Sie auf `false`, um einen abgestürzten Server gestoppt zu lassen, anstatt ihn neu zu starten |

285| `maxRestarts` | Maximale Anzahl von Neustartversuchen, bevor aufgegeben wird |

286| `diagnostics` | Ob Diagnostiken nach Änderungen in Claudes Kontext eingefügt werden sollen (Standard `true`). Setzen Sie auf `false`, um Code-Navigation beizubehalten, aber automatische Diagnostik-Einspeisung zu unterdrücken. |

~~287~~

288`restartOnCrash` und `shutdownTimeout` erfordern Claude Code v2.1.205 oder später. Vor v2.1.205 akzeptierte das Config-Schema beide Optionen, aber das Setzen einer dieser Optionen führte dazu, dass Claude Code diesen LSP Server beim Start vollständig übersprang, wobei der Grund nur in der `claude --debug` Ausgabe sichtbar war.

~~289~~

290**Mehrere Server für die gleiche Erweiterung**: Wenn mehr als ein aktivierter LSP Server die gleiche Dateierweiterung in `extensionToLanguage` deklariert, ob die Server von einem Plugin oder von verschiedenen Plugins stammen, verarbeitet der zuerst registrierte Server Dateien mit dieser Erweiterung und die anderen starten nie. Die `/plugin` Schnittstelle zeigt eine Warnung an, die das Plugin benennt, dessen Server aktiv ist.

~~291~~

292**Server, die nicht initialisiert werden können**: Claude Code überspringt einen Server, dessen Konfiguration ungültig ist, z. B. einer, dem `command` oder `extensionToLanguage` fehlt, und die anderen konfigurierten Server starten trotzdem. Führen Sie `claude --debug` aus, um zu sehen, warum ein Server übersprungen wurde.

~~293~~

294Ein übersprungener Server beansprucht seine Dateierweiterungen nicht, daher kann ein anderer gültiger Server, der die gleiche Erweiterung deklariert, vom gleichen oder einem anderen Plugin, diese Dateien trotzdem verarbeiten.

~~295~~

296**Senden Sie Log-Ausgabe an stderr, nicht stdout**: Claude Code liest den stdout eines Servers nur als Protokollmeldungen und akzeptiert Nachrichtenheader bis zu 64 KiB und einen Nachrichtentext bis zu 32 MiB. Claude Code trennt einen Server, der eines dieser Limits überschreitet oder nicht-Protokoll-Ausgabe an stdout schreibt, und zählt die Trennung als Absturz für `restartOnCrash` und `maxRestarts`. Wenn Sie mit `--debug` ausführen, schreibt Claude Code einen Fehler, der die Ursache benennt, in das Debug-Log.

~~297~~

298<Warning>

299 **Sie müssen die Language Server Binärdatei separat installieren.** LSP Plugins konfigurieren, wie Claude Code sich mit einem Language Server verbindet, aber sie enthalten den Server selbst nicht. Wenn Sie `Executable not found in $PATH` im `/plugin` Errors Tab sehen, installieren Sie die erforderliche Binärdatei für Ihre Sprache.

300</Warning>

~~301~~

302**Verfügbare LSP Plugins:**

~~303~~

304| Plugin | Language Server | Installationsbefehl |

305| :------------------ | :------------------------- | :------------------------------------------------------------------------------------------- |

306| `pyright-lsp` | Pyright (Python) | `pip install pyright` oder `npm install -g pyright` |

307| `typescript-lsp` | TypeScript Language Server | `npm install -g typescript-language-server typescript` |

308| `rust-analyzer-lsp` | rust-analyzer | [Siehe rust-analyzer Installation](https://rust-analyzer.github.io/manual.html#installation) |

~~309~~

310Installieren Sie zuerst den Language Server und dann das Plugin aus dem Marketplace.

~~311~~

312<h3 id="monitors">

313 Monitors

314</h3>

~~315~~

316Plugins können Background-Monitore deklarieren, die Claude Code automatisch startet, wenn das Plugin aktiv ist. Jeder Monitor führt einen Shell-Befehl für die Lebensdauer der Session aus und liefert jede stdout-Zeile als Benachrichtigung an Claude, damit Claude auf Log-Einträge, Statusänderungen oder abgerufene Events reagieren kann, ohne aufgefordert zu werden, die Überwachung selbst zu starten.

~~317~~

318Plugin-Monitore verwenden den gleichen Mechanismus wie das [Monitor Tool](/docs/de/tools-reference#monitor-tool) und teilen seine Verfügbarkeitsbeschränkungen. Sie laufen nur in interaktiven CLI-Sessions, laufen unsandboxed auf der gleichen Vertrauensebene wie [Hooks](#hooks) und werden auf Hosts übersprungen, wo das Monitor Tool nicht verfügbar ist.

~~319~~

320**Speicherort**: `monitors/monitors.json` im Plugin-Root oder inline in `plugin.json`

~~321~~

322**Format**: JSON-Array von Monitor-Einträgen

~~323~~

324Die folgende `monitors/monitors.json` überwacht einen Deployment-Status-Endpunkt und ein lokales Error-Log:

~~325~~

326```json theme={null}

327[

328 {

329 "name": "deploy-status",

330 "command": "\"${CLAUDE_PLUGIN_ROOT}\"/scripts/poll-deploy.sh",

331 "description": "Deployment status changes"

332 },

333 {

334 "name": "error-log",

335 "command": "tail -F ./logs/error.log",

336 "description": "Application error log",

337 "when": "on-skill-invoke:debug"

338 }

339]

340```

~~341~~

342Um Monitore inline zu deklarieren, setzen Sie `experimental.monitors` in `plugin.json` auf das gleiche Array. Um von einem nicht-Standard-Pfad zu laden, setzen Sie `experimental.monitors` auf einen relativen Pfad-String wie `"./config/monitors.json"`. Monitore sind eine [experimentelle Komponente](#experimental-components).

~~343~~

344**Erforderliche Felder:**

~~345~~

346| Feld | Beschreibung |

347| :------------ | :-------------------------------------------------------------------------------------------------------------------------------------------------------- |

348| `name` | Bezeichner, der innerhalb des Plugins eindeutig ist. Verhindert doppelte Prozesse, wenn das Plugin neu geladen wird oder ein Skill erneut aufgerufen wird |

349| `command` | Shell-Befehl, der als persistenter Background-Prozess im Session-Arbeitsverzeichnis ausgeführt wird |

350| `description` | Kurze Zusammenfassung dessen, was überwacht wird. Wird im Task-Panel und in Benachrichtigungszusammenfassungen angezeigt |

~~351~~

352**Optionale Felder:**

~~353~~

354| Feld | Beschreibung |

355| :----- | :-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |

356| `when` | Steuert, wann der Monitor startet. `"always"` startet ihn beim Session-Start und beim Plugin-Reload und ist der Standard. `"on-skill-invoke:<skill-name>"` startet ihn das erste Mal, wenn der benannte Skill in diesem Plugin versendet wird |

~~357~~

358Der `command` Wert unterstützt die [Pfad-Substitutionen](#environment-variables) `${CLAUDE_PLUGIN_ROOT}`, `${CLAUDE_PLUGIN_DATA}` und `${CLAUDE_PROJECT_DIR}`, plus alle `${ENV_VAR}` aus der Umgebung. Präfixieren Sie den Befehl mit `cd "${CLAUDE_PLUGIN_ROOT}" && `, wenn das Script aus dem eigenen Verzeichnis des Plugins ausgeführt werden muss.

~~359~~

360Ein Monitor `command` kann nicht auf [`${user_config.*}`](#user-configuration) Werte verweisen. Der Befehl läuft durch eine Shell, daher lehnt Claude Code den Monitor mit einem [Fehler](/docs/de/errors#plugin-command-references-user-config) ab, anstatt den Wert zu ersetzen. Monitor-Prozesse erhalten keine `CLAUDE_PLUGIN_OPTION_<KEY>` Umgebungsvariablen, daher sollte das Monitor-Script den Wert aus einer Konfigurationsdatei lesen, die es besitzt.

~~361~~

362Wenn Sie ein Plugin während einer Session deaktivieren, stoppt Claude Code nicht die Monitore, die bereits laufen; sie stoppen, wenn die Session endet.

~~363~~

364<h3 id="themes">

365 Themes

366</h3>

~~367~~

368Plugins können Farbthemes bereitstellen, die in `/theme` neben den integrierten Voreinstellungen und den lokalen Themes des Benutzers erscheinen. Ein Theme ist eine JSON-Datei in `themes/` mit einer `base` Voreinstellung und einer sparsamen `overrides` Map von Farb-Tokens. Themes sind eine [experimentelle Komponente](#experimental-components).

~~369~~

370```json theme={null}

371{

372 "name": "Dracula",

373 "base": "dark",

374 "overrides": {

375 "claude": "#bd93f9",

376 "error": "#ff5555",

377 "success": "#50fa7b"

378 }

379}

380```

~~381~~

382Wenn ein Benutzer ein Plugin-Theme auswählt, speichert Claude Code `custom:<plugin-name>:<slug>` in seiner Konfiguration. Plugin-Themes sind schreibgeschützt: Wenn ein Benutzer `Ctrl+E` auf einem in `/theme` drückt, kopiert Claude Code es in `~/.claude/themes/`, damit er die Kopie bearbeiten kann.

~~383~~

384***

~~385~~

386<h2 id="plugin-installation-scopes">

387 Installationsbereiche für Plugins

388</h2>

~~389~~

390Wenn Sie ein Plugin installieren, wählen Sie einen **Bereich** aus, der bestimmt, wo das Plugin verfügbar ist und wer es sonst noch verwenden kann:

~~391~~

392| Bereich | Einstellungsdatei | Anwendungsfall |

393| :-------- | :--------------------------------------- | :---------------------------------------------------------------------------------------- |

394| `user` | `~/.claude/settings.json` | Persönliche Plugins, die in allen Projekten verfügbar sind (Standard) |

395| `project` | `.claude/settings.json` | Team-Plugins, die über Versionskontrolle freigegeben werden |

396| `local` | `.claude/settings.local.json` | Projektspezifische Plugins, gitignored, wenn Claude Code eine Einstellung darin speichert |

397| `managed` | [Managed settings](/docs/de/managed-settings) | Verwaltete Plugins (schreibgeschützt, nur Update) |

~~398~~

399Plugins verwenden das gleiche Bereichssystem wie andere Claude Code-Konfigurationen. Installationsanweisungen und Bereichsflags finden Sie unter [Plugins installieren](/docs/de/discover-plugins#install-plugins). Eine vollständige Erklärung der Bereiche finden Sie unter [Konfigurationsbereiche](/docs/de/settings#where-settings-live).

~~400~~

401***

~~402~~

403<h2 id="skills-directory-plugins">

404 Plugins aus dem Skills-Verzeichnis

405</h2>

~~406~~

407Jeder Ordner unter einem Skills-Verzeichnis, der ein `.claude-plugin/plugin.json`-Manifest enthält, wird in der nächsten Sitzung als Plugin mit dem Namen `<name>@skills-dir` geladen, ohne Marketplace und ohne Installationsschritt. Erstellen Sie eines mit [`plugin init`](#plugin-init). Im Gegensatz zu einer kopierten Marketplace-Installation wird das Plugin an Ort und Stelle erkannt, anstatt in den Plugin-Cache kopiert zu werden.

~~408~~

409Eine Skills-Verzeichnisstruktur unterstützt drei verschiedene Dinge:

~~410~~

411| Was Sie haben | Was es ist |

412| :-------------------------------------------- | :----------------------------------------------------------------------------------------- |

413| `<skills-dir>/foo/SKILL.md` ohne Manifest | Ein einfaches [Skill](/docs/de/skills) mit dem Namen `foo` |

414| `<skills-dir>/foo/.claude-plugin/plugin.json` | Ein Plugin `foo@skills-dir`, das seine eigenen Skills, Agents, Hooks und mehr bündeln kann |

415| `<plugin>/skills/bar/SKILL.md` | Ein Skill `bar`, das in einem Plugin verpackt ist |

~~416~~

417<h3 id="choose-where-the-plugin-loads-from">

418 Wählen Sie, von wo aus das Plugin geladen wird

419</h3>

~~420~~

421| Skills-Verzeichnis | Bereich | Lädt |

422| :---------------------- | :--------- | :--------------------------------------------------------------------------------------------------------------------------------------- |

423| `~/.claude/skills/` | persönlich | In jedem Projekt, da der Speicherort nur Ihnen gehört |

424| `<cwd>/.claude/skills/` | Projekt | Nur nachdem Sie den Workspace-[Vertrauensdialog](/docs/de/permissions#what-runs-before-you-trust-a-folder) für diesen Ordner akzeptiert haben |

~~425~~

426Ein Plugin im Projektbereich wird in das Repository eingecheckt und erreicht jeden Mitarbeiter, der es klont. Da dieser Inhalt aus dem Repository und nicht von Ihnen stammt, wird er nur nach demselben Vertrauenstor geladen, das die Projekterlaubnisregeln in `.claude/settings.json` regelt. Das Vertrauen in einen übergeordneten Ordner oder das Ausführen mit `-p` ist daher nicht ausreichend, und Komponenten, die Code ausführen, sind weiter eingeschränkt:

~~427~~

428* MCP-Server, die es deklariert, durchlaufen die [gleiche Pro-Server-Genehmigung](/docs/de/mcp) wie ein Projekt `.mcp.json`

429* LSP-Server starten nur, nachdem Sie den Workspace vertrauen

430* [Hintergrund-Monitore](#monitors) werden nicht geladen

~~431~~

432Plugins im persönlichen Bereich haben keine dieser Einschränkungen.

~~433~~

434<Warning>

435 Plugins im Projektbereich `@skills-dir` werden nur aus dem `.claude/skills/` des [primären Arbeitsverzeichnisses](/docs/de/permissions#working-directories) der Sitzung geladen. Sie [gehen nicht bis zur Repository-Root](/docs/de/skills#discovery-from-parent-and-nested-directories) wie einfache Skills und Befehle, daher wird ein Plugin, das sich im Repository-Root befindet, übersehen, wenn Sie von einem Unterverzeichnis aus starten. Starten Sie vom Repository-Root, oder [verschieben Sie die Sitzung mit `/cd`](/docs/de/permissions#move-the-session-to-another-directory) auf v2.1.246 oder später dorthin.

436</Warning>

~~437~~

438<h3 id="edit-reload-and-disable-a-skills-directory-plugin">

439 Bearbeiten, neu laden und deaktivieren Sie ein Plugin aus dem Skills-Verzeichnis

440</h3>

~~441~~

442Änderungen, die Sie an der `SKILL.md` eines Skills vornehmen, werden sofort in der aktuellen Sitzung wirksam. Änderungen an anderen Komponenten des Plugins, wie `hooks/`, `.mcp.json`, `agents/` und `output-styles/`, werden nicht wirksam. Führen Sie `/reload-plugins` aus oder starten Sie Claude Code neu, um diese zu übernehmen. Siehe [Live-Änderungserkennung](/docs/de/skills#live-change-detection).

~~443~~

444Um das Laden eines Plugins aus dem Skills-Verzeichnis zu beenden, löschen Sie seinen Ordner oder deaktivieren Sie es nach Name. Es gibt keinen `uninstall`-Schritt, da nichts von einem Marketplace installiert wurde.

~~445~~

446```bash theme={null}

447claude plugin disable my-tool@skills-dir

448```

~~449~~

450***

~~451~~

452<h2 id="synced-plugins">

453 Plugins synchronisiert von claude.ai

454</h2>

~~455~~

456Claude Code lädt die für Ihr claude.ai-Konto aktivierten Plugins, einschließlich Plugins, die Ihre Organisation für ihre Mitglieder aktiviert, zusammen mit den Plugins, die Sie aus Marketplaces installieren. Es lädt jedes in `~/.claude/plugins/synced/` herunter und lädt es als `<name>@synced`, ohne Marketplace und ohne Installationsdatensatz. Ein synchronisiertes Plugin wird mit dem gleichen Vertrauen ausgeführt wie ein Marketplace-Plugin, das Sie installiert haben: seine Skills, Agents, Hooks, MCP-Server und LSP-Server werden alle geladen.

~~457~~

458Wo Claude Code diese Plugins synchronisiert, hängt von der Sitzung ab:

~~459~~

460* In [Cowork](https://claude.com/product/cowork) und [Cloud-Sitzungen](/docs/de/cloud-environments#what-carries-over-from-your-setup) lädt Claude Code sie in die eigene Umgebung der Sitzung herunter, wenn die Sitzung startet. Vor v2.1.239 lud Claude Code diese Plugins als `<name>@inline`, die Identität, die `--plugin-dir`-Plugins verwenden.

461* In Terminal-Sitzungen, in denen Sie sich mit Ihrem claude.ai-Konto anmelden, prüft Claude Code Ihr Konto einmal jedes Mal, wenn es startet, und lädt dann neue und aktualisierte Plugins herunter und entfernt die Plugins, die Sie oder Ihre Organisation ausgeschaltet haben, alles im Hintergrund. Die Synchronisierung in Terminal-Sitzungen erfordert Claude Code v2.1.273 oder später.

~~462~~

463Die Startprüfung wird im Hintergrund ausgeführt, sodass sie nach dem Start Ihrer Sitzung abgeschlossen sein kann. Wenn sie ein synchronisiertes Plugin in einer interaktiven Sitzung hinzufügt, aktualisiert oder entfernt, zeigt Claude Code `Plugins changed. Run /reload-plugins to activate.` an. Führen Sie [`/reload-plugins`](/docs/de/discover-plugins#apply-plugin-changes-without-restarting) aus, um die Änderung in dieser Sitzung zu laden, oder lassen Sie sie für das nächste Mal, wenn Sie Claude Code starten. Wenn Sie ein Plugin auf claude.ai aktivieren, während eine Sitzung läuft, lädt Claude Code es beim nächsten Start herunter.

~~464~~

465Die Plugin-Synchronisierung in Terminal-Sitzungen wird unter den gleichen Anmeldebedingungen ausgeführt wie [Skills, die von claude.ai synchronisiert werden](/docs/de/skills#where-synced-skills-load). Sie benötigt auch eine Anmeldung, die Claude Code Zugriff auf die Plugins Ihres Kontos gewährt.

~~466~~

467Eine Anmeldung aus einer früheren Version von Claude Code erhält Plugin-Zugriff beim nächsten Mal, wenn Claude Code diese Anmeldung im Hintergrund erneuert, innerhalb weniger Stunden, oder sofort, wenn Sie `/login` erneut ausführen. Die Plugin-Synchronisierung startet beim nächsten Mal, wenn Sie Claude Code danach starten.

~~468~~

469`claude plugin list` zeigt synchronisierte Plugins unter einer `Synced from claude.ai`-Überschrift an, und die `/plugin` **Installed**-Registerkarte listet sie mit `synced` als Quelle auf. Verwalten Sie ein synchronisiertes Plugin über die `<name>@synced`-ID, die `claude plugin list` ausgibt:

~~470~~

471* **Eines ausschalten**: Führen Sie `claude plugin disable <name>@synced` aus, oder deaktivieren Sie es über die `/plugin` **Installed**-Registerkarte. Claude Code speichert die Auswahl als `"<name>@synced": false` in Ihren Benutzer-Level-[`enabledPlugins`](/docs/de/settings-reference#enabledplugins). Um das Plugin wieder einzuschalten, führen Sie `claude plugin enable <name>@synced` aus.

472* **Eines überall heraushalten**: [schalten Sie das Plugin für Ihr claude.ai-Konto aus](/docs/de/desktop#extend-claude-code). Um es aus einem Projekt in jeder Umgebung herauszuhalten, setzen Sie `"<name>@synced": false` unter `enabledPlugins` in der committed `.claude/settings.json` dieses Projekts.

473* **Verwalten Sie das Plugin selbst auf claude.ai**: `claude plugin install`, `update` und `uninstall` gelten nicht für ein synchronisiertes Plugin. Claude Code lädt die Updates eines Plugins bei der nächsten Synchronisierung herunter. Um eines zu entfernen, schalten Sie das Plugin für Ihr claude.ai-Konto aus, und Claude Code entfernt es bei der nächsten Synchronisierung.

474* **Synchronisierung auf einem Computer stoppen**: setzen Sie [`syncClaudeAiPlugins`](/docs/de/settings-reference#syncclaudeaiplugins) in Ihren Benutzereinstellungen auf `false`. Claude Code stoppt das Herunterladen, und beim nächsten Start verschiebt es die Plugins, die es bereits synchronisiert hat, in `~/.claude/plugins/.trash/` und lädt sie nicht mehr. Ihre Organisation kann denselben Schlüssel in [verwalteten Einstellungen](/docs/de/managed-settings) setzen oder Skills auf claude.ai ausschalten, was auch verhindert, dass Plugins synchronisiert werden.

~~475~~

476Sie können ein Plugin nicht ausschalten, das Ihre Organisation auf claude.ai als erforderlich markiert. Claude Code lädt es auch dann, wenn Sie es zuvor deaktiviert haben, und `claude plugin disable` weigert sich mit `Plugin "<name>@synced" is required by your organization and can't be disabled here. Contact your admin to change it.` In `claude plugin list` sind diese Plugins mit `required by your org` gekennzeichnet.

~~477~~

478Wenn ein aktiviertes Plugin aus einer anderen Quelle den Namen eines synchronisierten Plugins entspricht, lädt Claude Code dieses Plugin und meldet die synchronisierte Kopie als nicht geladen. Andere Quellen umfassen Marketplace-Installationen, [Skills-Directory-Plugins](#skills-directory-plugins), `--plugin-dir`-Plugins und in Claude Code integrierte Plugins. Um stattdessen die claude.ai-Kopie zu verwenden, deaktivieren Sie Ihre eigene Kopie. Vor v2.1.239 lud Claude Code die synchronisierte Kopie statt einer gleichnamigen Marketplace-Installation.

~~479~~

480***

~~481~~

482<h2 id="plugin-manifest-schema">

483 Plugin-Manifest-Schema

484</h2>

~~485~~

486Die Datei `.claude-plugin/plugin.json` definiert die Metadaten und Konfiguration Ihres Plugins.

~~487~~

488Das Manifest ist optional. Falls weggelassen, erkennt Claude Code Komponenten automatisch an [Standardorten](#file-locations-reference) und leitet den Plugin-Namen vom Verzeichnisnamen ab. Verwenden Sie ein Manifest, wenn Sie Metadaten oder benutzerdefinierte Komponentenpfade bereitstellen müssen.

~~489~~

490<h3 id="complete-schema">

491 Vollständiges Schema

492</h3>

~~493~~

494```json theme={null}

495{

496 "name": "plugin-name",

497 "displayName": "Plugin Name",

498 "version": "1.2.0",

499 "description": "Brief plugin description",

500 "author": {

501 "name": "Author Name",

502 "email": "author@example.com",

503 "url": "https://github.com/author"

504 },

505 "homepage": "https://docs.example.com/plugin",

506 "repository": "https://github.com/author/plugin",

507 "license": "MIT",

508 "keywords": ["keyword1", "keyword2"],

509 "metadata": { "catalogId": "cat-123", "tier": "pro" },

510 "skills": "./custom/skills/",

511 "commands": ["./custom/commands/special.md"],

512 "agents": ["./custom/agents/reviewer.md"],

513 "hooks": "./config/hooks.json",

514 "mcpServers": "./mcp-config.json",

515 "outputStyles": "./styles/",

516 "lspServers": "./.lsp.json",

517 "experimental": {

518 "themes": "./themes/",

519 "monitors": "./monitors.json",

520 "evals": "quality/evals"

521 },

522 "dependencies": [

523 "helper-lib",

524 { "name": "secrets-vault", "version": "~2.1.0" }

525 ]

526}

527```

~~528~~

529<h3 id="required-fields">

530 Erforderliche Felder

531</h3>

~~532~~

533Wenn Sie ein Manifest einbeziehen, ist `name` das einzige erforderliche Feld.

~~534~~

535| Feld | Typ | Beschreibung | Beispiel |

536| :----- | :----- | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :------------------- |

537| `name` | string | Eindeutiger Bezeichner in Kebab-Case, ohne Leerzeichen, Steuerzeichen oder bidirektionale Formatierungszeichen. Wenn ein [Marketplace-Eintrag](/docs/de/plugin-marketplaces#plugin-entries) das Plugin unter einem anderen Namen auflistet, ist der Name des Marketplace-Eintrags das, was `enabledPlugins`-Schlüssel und `/plugin` verwenden | `"deployment-tools"` |

~~538~~

539Dieser Name wird für die Namensgebung von Komponenten verwendet. Beispielsweise wird der Agent `agent-creator` für das Plugin mit dem Namen `plugin-dev` in der Benutzeroberfläche als `plugin-dev:agent-creator` angezeigt.

~~540~~

541<h3 id="unrecognized-fields">

542 Nicht erkannte Felder

543</h3>

~~544~~

545Claude Code ignoriert Felder auf oberster Ebene, die nicht erkannt werden. Sie können Metadaten aus einem anderen Ökosystem in `plugin.json` behalten und das Plugin wird trotzdem geladen. Dies macht es praktisch, ein Manifest zu verwalten, das gleichzeitig als VS Code- oder Cursor-Erweiterungsmanifest, eine npm-`package.json` oder ein MCPB/DXT-Bundle-Manifest dient.

~~546~~

547`claude plugin validate` meldet nicht erkannte Felder als Warnungen, nicht als Fehler. Wenn ein Feld ein oder zwei Zeichen von einem erkannten Feld entfernt ist, schlägt die Warnung den wahrscheinlich beabsichtigten Namen vor. Ein Plugin mit nur Warnungen zu nicht erkannten Feldern besteht die Validierung und wird zur Laufzeit geladen.

~~548~~

549Wie Claude Code ein erkanntes Feld behandelt, dessen Wert den falschen Typ hat, hängt vom Feld ab:

~~550~~

551* **Die meisten Felder**: Das Plugin kann nicht geladen werden. Beispielsweise ist ein `keywords`-Wert, der ein String statt eines Arrays ist, ein Ladefehler, und `claude plugin validate` meldet ihn als solchen.

552* **`experimental` und `metadata`**: Claude Code ignoriert einen Nicht-Objekt-Wert, und `claude plugin validate` meldet eine Warnung.

~~553~~

554Übergeben Sie `--strict`, um Warnungen als Fehler zu behandeln. Verwenden Sie es in CI, um einen falsch geschriebenen Feldnamen oder ein Feld, das von einem anderen Tool-Manifest übrig bleibt, vor der Veröffentlichung zu erfassen, obwohl das Plugin zur Laufzeit geladen würde.

~~555~~

556```bash theme={null}

557claude plugin validate ./my-plugin --strict

558```

~~559~~

560<h3 id="metadata-fields">

561 Metadatenfelder

562</h3>

~~563~~

565| :--------------- | :------ | :-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :---------------------------------------------------------------- |

567| `displayName` | string | Benutzerfreundlicher Name, der in der `/plugin`-Auswahl und anderen UI-Oberflächen angezeigt wird. Für ein auf dem Marketplace installiertes Plugin hat ein `displayName` im [Marketplace-Eintrag](/docs/de/plugin-marketplaces#optional-plugin-fields) Vorrang vor diesem Wert. Wenn an keiner Stelle ein Anzeigename festgelegt ist, sehen Benutzer `name`. Im Gegensatz zu `name` kann es Leerzeichen und beliebige Groß-/Kleinschreibung enthalten. Wird nicht für Namensgebung oder Suche verwendet. | `"Deployment Tools"` |

568| `version` | string | Optional. Semantische Version. Das Festlegen dieser Version bindet das Plugin an diese Versionsnummer, sodass Benutzer nur Updates erhalten, wenn Sie diese erhöhen, außer für eine [`command`-Quelle](/docs/de/plugin-marketplaces#command-sources) oder ein Plugin [das an Ort und Stelle geladen wird](#plugin-caching-and-file-resolution); siehe [Versionsverwaltung](#version-management). Falls auch im Marketplace-Eintrag festgelegt, gewinnt `plugin.json`. Falls weggelassen, kommt die Version aus der nächsten Quelle in [Versionsverwaltung](#version-management). | `"2.1.0"` |

570| `author` | object | Autoreninformationen | `{"name": "Dev Team", "email": "dev@company.com"}` |

575| `metadata` | object | Freiformes Objekt für Ihre eigenen Daten, wie Berechtigungs- oder Katalogfelder. Claude Code liest es nicht, daher beeinflussen die Werte niemals das Plugin-Verhalten. Claude Code ignoriert einen Nicht-Objekt-Wert, und `claude plugin validate` meldet ihn als Warnung. Vor v2.1.222 behandelte Claude Code den Schlüssel als [nicht erkanntes Feld](#unrecognized-fields). | `{"catalogId": "cat-123"}` |

~~577~~

578<h3 id="default-enablement">

579 Standardaktivierung

580</h3>

~~581~~

582Setzen Sie `defaultEnabled: false` in `plugin.json`, um ein Plugin zu versenden, das deaktiviert installiert wird. Der Benutzer aktiviert es mit `claude plugin enable <plugin>` oder der `/plugin`-Schnittstelle. Verwenden Sie dies für Plugins, die Kosten hinzufügen oder einen Umfang haben, den ein Benutzer akzeptieren sollte, wie eines, das sich mit einem externen Service verbindet.

~~583~~

584`defaultEnabled` ist der Fallback, wenn nichts anderes den Zustand des Plugins entschieden hat. Die Einstellung des Benutzers und eine Abhängigkeitsanforderung haben Vorrang vor ihr:

~~585~~

586* **Die Einstellung des Benutzers**: ein Eintrag für das Plugin in `enabledPlugins` in jedem Einstellungsbereich. Nach dem Schreiben bleibt es über Plugin-Updates und Neuinstallationen hinweg bestehen, daher ändert das Ändern von `defaultEnabled` in einer späteren Version nicht den Zustand eines bestehenden Benutzers.

587* **Eine Abhängigkeitsanforderung**: Wenn ein Plugin von einem anderen erforderlich ist, das aktiv ist, schreibt Claude Code `true` dafür zur Installations- oder Aktivierungszeit. Das gibt ihm eine explizite Einstellung, daher gilt sein eigener Standard nicht mehr. Siehe [Plugin mit Abhängigkeiten aktivieren oder deaktivieren](/docs/de/plugin-dependencies#enable-or-disable-a-plugin-with-dependencies).

~~588~~

589Das gleiche Feld kann im Marketplace-Eintrag eines Plugins erscheinen, wo es Vorrang vor dem Wert in `plugin.json` hat. Siehe [Optionale Plugin-Felder](/docs/de/plugin-marketplaces#optional-plugin-fields).

~~590~~

591<h3 id="component-path-fields">

592 Komponentenpfad-Felder

593</h3>

~~594~~

595| Feld | Typ | Beschreibung | Beispiel |

596| :---------------------- | :-------------------- | :-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :--------------------------------------------------- |

607| `experimental.evals` | string\|array | Verzeichnis unterhalb des Plugin-Roots, das die [Eval-Fälle](/docs/de/plugin-evals#use-a-different-eval-directory) des Plugins enthält, wenn es nicht das Standard-`evals/` ist. `claude plugin eval --eval-dir` überschreibt es | `"quality/evals"` |

610| `dependencies` | array | Andere Plugins, die dieses Plugin benötigt, optional mit Semver-Versionsbeschränkungen. Siehe [Plugin-Abhängigkeitsversionen einschränken](/docs/de/plugin-dependencies) | `[{ "name": "secrets-vault", "version": "~2.1.0" }]` |

~~611~~

612<h3 id="experimental-components">

613 Experimentelle Komponenten

614</h3>

~~615~~

616Komponenten unter dem `experimental`-Schlüssel, `themes` und `monitors`, haben ein Manifest-Schema, das sich zwischen Releases ändern kann, während sie stabilisieren. Wo Sie sie deklarieren, ist eine separate Migration: Die oberste Ebene funktioniert immer noch, `claude plugin validate` warnt, und eine zukünftige Version wird `experimental.*` erfordern.

~~617~~

618<h3 id="user-configuration">

619 Benutzerkonfiguration

620</h3>

~~621~~

622Das Feld `userConfig` deklariert Werte, die Claude Code den Benutzer auffordert, wenn das Plugin aktiviert wird. Verwenden Sie dies, anstatt Benutzer zu zwingen, `settings.json` manuell zu bearbeiten.

~~623~~

624```json theme={null}

625{

626 "userConfig": {

627 "api_endpoint": {

628 "type": "string",

629 "title": "API endpoint",

630 "description": "Your team's API endpoint"

631 },

632 "api_token": {

633 "type": "string",

634 "title": "API token",

635 "description": "API authentication token",

636 "sensitive": true

637 }

638 }

639}

640```

~~641~~

642Schlüssel müssen gültige Bezeichner sein. Jede Option unterstützt diese Felder:

~~643~~

644| Feld | Erforderlich | Beschreibung |

645| :------------ | :----------- | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |

646| `type` | Ja | Einer von `string`, `number`, `boolean`, `directory` oder `file` |

647| `title` | Ja | Beschriftung, die im Konfigurationsdialog angezeigt wird |

648| `description` | Ja | Hilfetext, der unter dem Feld angezeigt wird |

649| `sensitive` | Nein | Falls `true`, maskiert die Eingabe und speichert den Wert im sicheren Speicher statt in `settings.json` |

650| `required` | Nein | Falls `true`, schlägt die Validierung fehl, wenn das Feld leer ist |

651| `default` | Nein | Wert, der verwendet wird, wenn der Benutzer nichts bereitstellt |

652| `options` | Nein | Für `string`-Typ die Werte, die das Feld akzeptiert, angezeigt in `/config` als Auswahl über ihnen. Siehe [Feld auf feste Optionen beschränken](#limit-a-field-to-fixed-options). Erfordert Claude Code v2.1.271 oder später |

653| `multiple` | Nein | Für `string`-Typ, erlauben Sie ein Array von Strings |

654| `min` / `max` | Nein | Grenzen für `number`-Typ |

~~655~~

656Außer `sensitive`-Feldern und `multiple`-Listen erscheint jedes Feld jedes aktivierten Plugins auch als Zeile im `/config`-Panel. Die Zeilen erfordern Claude Code v2.1.269 oder später.

~~657~~

658Jeder Wert ist für die Substitution als `${user_config.KEY}` in MCP- und LSP-Server-Konfigurationen und Hook-Befehlen verfügbar. Nicht-sensitive Werte können auch in Skill- und Agent-Inhalten ersetzt werden. Alle Werte werden an Hook-Prozesse als `CLAUDE_PLUGIN_OPTION_<KEY>`-Umgebungsvariablen exportiert, wobei `<KEY>` der Optionsschlüssel in Großbuchstaben ist.

~~659~~

660Felder, die in einer Shell ausgeführt werden, lehnen `${user_config.*}` ab: Das Ersetzen eines konfigurierten Werts in einem Shell-Befehl würde der Shell ermöglichen, alles auszuführen, was dieser Wert enthält, daher schlägt die Komponente mit einem [Fehler](/docs/de/errors#plugin-command-references-user-config) fehl. Jedes abgelehnte Feld hat eine alternative Möglichkeit, den Wert zu übergeben:

~~661~~

662| Abgelehntes Feld | Wie man den Wert übergibt |

663| :--------------------------------------------------------------------------- | :----------------------------------------------------------------------------------------------------------------------------------------- |

664| Shell-Form-Hook-Befehle | Verwenden Sie [Exec-Form](/docs/de/hooks#exec-form-and-shell-form) mit `args` oder lesen Sie `CLAUDE_PLUGIN_OPTION_<KEY>` aus der Hook-Umgebung |

665| [Monitor](#monitors)-Befehle | Lesen Sie den Wert aus einer Konfigurationsdatei im Skript |

666| MCP [`headersHelper`](/docs/de/mcp#use-dynamic-headers-for-custom-authentication) | Lesen Sie den Wert aus einer Konfigurationsdatei im Skript |

~~667~~

668Vor v2.1.207 ersetzten diese Felder `${user_config.KEY}`-Werte; aktualisieren Sie Plugins, die sich darauf verlassen haben.

~~669~~

670Nicht-sensitive Werte werden unter dem [`pluginConfigs`](/docs/de/settings-reference#pluginconfigs)-Schlüssel in Ihrer Benutzer-`settings.json` als `pluginConfigs[<plugin-id>].options` gespeichert.

~~671~~

672Auf macOS speichert Claude Code sensitive Werte in der macOS Keychain und fällt auf `~/.claude/.credentials.json` zurück, wenn die Keychain den Schreibvorgang ablehnt. Auf Plattformen ohne unterstützte Keychain speichert es sie in `~/.claude/.credentials.json`. Keychain-Speicher wird mit OAuth-Tokens geteilt und hat eine ungefähre Gesamtgrenze von 2 KB, daher halten Sie sensitive Werte klein.

~~673~~

674Claude Code liest alle `pluginConfigs`-Werte nur aus drei Einstellungsquellen:

~~675~~

676* **Benutzereinstellungen**: `~/.claude/settings.json`, die Datei, in die die Aktivierungsaufforderung schreibt

677* **`--settings`**: das CLI-Flag oder SDK-Inline-Einstellungen

678* **Verwaltete Einstellungen**: [organisationskontrollierte Richtlinie](/docs/de/permissions#managed-settings)

~~679~~

680Wenn mehr als eine Quelle denselben Schlüssel setzt, haben verwaltete Einstellungen Vorrang, dann `--settings`, dann Benutzereinstellungen. Die einzige Quelle, die Sie aus dieser Liste entfernen können, sind Benutzereinstellungen: Übergeben Sie [`--setting-sources`](/docs/de/cli-reference#cli-flags) ohne `user` und Claude Code überspringt sie. Verwaltete Einstellungen und `--settings` bleiben, was Sie übergeben. Die SDK-Option [`settingSources`](/docs/de/agent-sdk/claude-code-features#what-settingsources-does-not-control) setzt die gleiche Liste.

~~681~~

682Einträge in einer Projekt-`.claude/settings.json` oder `.claude/settings.local.json` werden ignoriert. Beide Dateien befinden sich im Workspace, daher könnte ein geklontes Repository Werte dort bereitstellen, und diese Werte würden in Plugin-Hook-Befehle, MCP-Server-Konfigurationen, LSP-Befehle und Monitor-Befehle fließen. Vor v2.1.207 wurden diese Einträge gelesen. Die Einschränkung ist spezifisch für `pluginConfigs`: [`enabledPlugins`](/docs/de/settings-reference#enabledplugins) berücksichtigt immer noch Projekt- und lokale Einstellungen.

~~683~~

684<h4 id="limit-a-field-to-fixed-options">

685 Feld auf feste Optionen beschränken

686</h4>

~~687~~

688Setzen Sie `options` auf ein `userConfig`-Feld, um Benutzer zu zwingen, seinen Wert aus einer festen Liste auszuwählen.

~~689~~

690Um ein `tone`-Feld auf drei Optionen zu beschränken, listen Sie sie in `options` auf und setzen Sie `default` auf eine davon:

~~691~~

692```json theme={null}

693{

694 "userConfig": {

695 "tone": {

696 "type": "string",

697 "title": "Tone",

698 "description": "Voice for generated replies",

699 "options": ["neutral", "warm", "formal"],

700 "default": "neutral"

701 }

702 }

703}

704```

~~705~~

706Wenn Sie `options` auf ein beliebiges Feld deklarieren, können Benutzer auf Claude Code-Versionen vor v2.1.271 das Plugin nicht laden.

~~707~~

708Wenn Sie `options` auf ein Feld setzen, befolgen Sie diese Regeln:

~~709~~

710* Setzen Sie `type` auf `string`

711* Setzen Sie `multiple` oder `sensitive` nicht auf `true`

712* Setzen Sie `default` auf eine der Optionen

713* Wenn Sie `default` nicht setzen, setzen Sie `required` auf `true`

714* Listen Sie mindestens eine Option auf, jede 1 bis 64 Zeichen lang

715* Beginnen oder enden Sie eine Option nicht mit einem Leerzeichen

716* Verwenden Sie keine Steuerzeichen, unsichtbaren Zeichen, Zeichen, die die Textrichtung ändern, oder andere Leerzeichen als ein normales Leerzeichen in einer Option

717* Listen Sie nicht die gleiche Option zweimal auf, auch nicht in einer anderen Schreibweise

~~718~~

719Wenn Sie eine dieser Regeln brechen, kann das Plugin nicht geladen werden. Führen Sie `claude plugin validate` aus, um zu sehen, welches Feld welche Regel bricht.

~~720~~

721<h3 id="channels">

722 Kanäle

723</h3>

~~724~~

725Das Feld `channels` ermöglicht es einem Plugin, einen oder mehrere Nachrichtenkanäle zu deklarieren, die Inhalte in die Konversation einspritzen. Jeder Kanal bindet sich an einen MCP-Server, den das Plugin bereitstellt.

~~726~~

727```json theme={null}

728{

729 "channels": [

730 {

731 "server": "telegram",

732 "userConfig": {

733 "bot_token": {

734 "type": "string",

735 "title": "Bot token",

736 "description": "Telegram bot token",

737 "sensitive": true

738 },

739 "owner_id": {

740 "type": "string",

741 "title": "Owner ID",

742 "description": "Your Telegram user ID"

743 }

744 }

745 }

746 ]

747}

748```

~~749~~

750Das Feld `server` ist erforderlich und muss einem Schlüssel in den `mcpServers` des Plugins entsprechen. Das optionale Pro-Kanal-`userConfig` verwendet das gleiche Schema wie das Feld auf oberster Ebene, wodurch das Plugin Bot-Tokens oder Owner-IDs abfragen kann, wenn das Plugin aktiviert wird.

~~751~~

752<h3 id="path-behavior-rules">

753 Pfadverhaltenregeln

754</h3>

~~755~~

756Ob ein benutzerdefinierter Pfad das Standard-Verzeichnis des Plugins ersetzt oder erweitert, hängt vom Feld ab:

~~757~~

758* **Ersetzt den Standard**: `commands`, `agents`, `workflows`, `outputStyles`, `experimental.themes`, `experimental.monitors`. Beispielsweise wird das Standard-`commands/`-Verzeichnis nicht gescannt, wenn das Manifest `commands` angibt. Um den Standard zu behalten und mehr hinzuzufügen, listen Sie ihn explizit auf: `"commands": ["./commands/", "./extras/"]`

759* **Ergänzt den Standard**: `skills`. Das Standard-`skills/`-Verzeichnis wird immer gescannt, und Verzeichnisse, die in `skills` aufgelistet sind, werden zusammen mit ihm geladen. Ausnahme: Für einen [Marketplace-Eintrag, dessen `source` zum Marketplace-Root aufgelöst wird](/docs/de/plugin-marketplaces#advanced-plugin-entries), ersetzt das Deklarieren spezifischer Unterverzeichnisse den Standard-`skills/`-Scan

760* **Eigene Merge-Regeln**: [hooks](#hooks), [MCP-Server](#mcp-servers) und [LSP-Server](#lsp-servers). Siehe jeden Abschnitt, wie mehrere Quellen kombiniert werden

~~761~~

762Wenn ein Plugin sowohl einen Standard-Ordner als auch den entsprechenden Manifest-Schlüssel hat, warnt Claude Code vor dem ignorierten Ordner in `claude plugin list` und der `/plugin`-Detailansicht. Das Plugin wird immer noch mit den Manifest-Pfaden geladen. Claude Code warnt nicht, wenn der Manifest-Schlüssel in den Standard-Ordner zeigt, beispielsweise `"commands": ["./commands/deploy.md"]`, da dieser Pfad den Ordner explizit benennt.

~~763~~

764Für alle Pfadfelder:

~~765~~

766* Alle Pfade müssen relativ zum Plugin-Root sein und mit `./` beginnen, außer dass das Feld `skills` auch `"."` akzeptiert

767 * Sowohl `"."` als auch `"./"` bezeichnen den Plugin-Root selbst

768 * Vor v2.1.221 schlug `"."` bei der Manifest-Validierung fehl und das Plugin wurde nicht geladen, daher verwenden Sie `"./"`, um frühere Versionen zu unterstützen

769* Komponenten aus benutzerdefinierten Pfaden verwenden die gleichen Benennungs- und Namensgebungsregeln, außer Agent-Dateien. Siehe [Agents](#agents), wie Agent-Namen funktionieren

770* Mehrere Pfade können als Arrays angegeben werden

771* Ein Skill-Pfad kann auf ein Verzeichnis zeigen, das direkt eine `SKILL.md` enthält, beispielsweise `"skills": ["."]` für den Plugin-Root

772 * Claude Code nimmt den Invokationsnamen des Skills aus dem Frontmatter-Feld `name` in `SKILL.md`, daher bleibt der Name stabil, egal wie das Installationsverzeichnis benannt ist

773 * Wenn `name` nicht im Frontmatter festgelegt ist, fällt Claude Code auf den Verzeichnis-Basename zurück

~~774~~

775Ein Plugin, das eine `SKILL.md` an seinem Root hat, kein `skills/`-Unterverzeichnis und kein `skills`-Manifest-Feld hat, wird automatisch als Single-Skill-Plugin geladen. Sie müssen `"skills": ["./"]` in `plugin.json` für dieses Layout nicht setzen.

~~776~~

777**Pfadbeispiele**:

~~778~~

779```json theme={null}

780{

781 "commands": [

782 "./specialized/deploy.md",

783 "./utilities/batch-process.md"

784 ],

785 "agents": [

786 "./custom-agents/reviewer.md",

787 "./custom-agents/tester.md"

788 ]

789}

790```

~~791~~

792<h3 id="environment-variables">

793 Umgebungsvariablen

794</h3>

~~795~~

796Claude Code stellt drei Variablen zum Referenzieren von Pfaden bereit:

~~797~~

798| Variable | Wird aufgelöst zu | Verwenden Sie es für |

799| :---------------------- | :---------------------------------------------------------------------------------------------------------------- | :-------------------------------------------------------------------------------------------------------- |

800| `${CLAUDE_PLUGIN_ROOT}` | Absoluter Pfad zum Installationsverzeichnis des Plugins | Skripte, Binärdateien und Konfigurationsdateien, die mit dem Plugin gebündelt sind |

801| `${CLAUDE_PLUGIN_DATA}` | [Persistentes Verzeichnis](#persistent-data-directory), das Plugin-Updates überlebt, beim ersten Zugriff erstellt | Installierte Abhängigkeiten wie `node_modules` oder Python-Virtualumgebungen, generierter Code und Caches |

802| `${CLAUDE_PROJECT_DIR}` | Das Projekt-Root | Projektlokale Skripte und Konfigurationsdateien |

~~803~~

804Alle drei werden als Umgebungsvariablen an Hook-Prozesse und an MCP- und LSP-Server-Subprozesse exportiert. Sie sind nicht in der Umgebung von Befehlen vorhanden, die Claude durch das Bash-Tool ausführt, in der Hauptsitzung oder in einem Sub-Agent. Schreiben Sie in Plugin-Inhalten stattdessen den Platzhalter, und Claude Code ersetzt den Pfad inline, wenn es den Inhalt lädt. Welche Felder sie inline ersetzen, hängt von der Plugin-Komponente ab:

~~805~~

806| Plugin-Komponente | Felder, in denen Platzhalter aufgelöst werden |

807| :----------------------------- | :-------------------------------------------- |

808| Skill- und Agent-Inhalte | Überall dort, wo der Platzhalter erscheint |

809| Hook- und Monitor-Befehle | Überall dort, wo der Platzhalter erscheint |

810| MCP `stdio`-Server | `command`, `args`, `env` |

811| MCP `http`, `sse`, `ws`-Server | `url`, `headers`, `headersHelper` |

812| LSP-Server | `command`, `args`, `env`, `workspaceFolder` |

~~813~~

814Verwenden Sie in Hook-Befehlen [Exec-Form](/docs/de/hooks#exec-form-and-shell-form) mit `args`, damit jeder Pfad als ein Argument ohne Anführungszeichen übergeben wird. Wickeln Sie in Shell-Form-Hooks und Monitor-Befehlen die Variablen in doppelte Anführungszeichen ein, wie in `"${CLAUDE_PROJECT_DIR}/scripts/server.sh"`. Dieser Shell-Form-Hook führt ein mit einem Plugin gebündeltes Skript aus:

~~815~~

816```json theme={null}

817{

818 "hooks": {

819 "PostToolUse": [

820 {

821 "hooks": [

822 {

823 "type": "command",

824 "command": "\"${CLAUDE_PLUGIN_ROOT}\"/scripts/process.sh"

825 }

826 ]

827 }

828 ]

829 }

830}

831```

~~832~~

833Für ein kopiertes Plugin ändert sich `${CLAUDE_PLUGIN_ROOT}`, wenn das Plugin aktualisiert wird. Das Verzeichnis der vorherigen Version bleibt nach einem Update für einen Übergangszeitraum auf der Festplatte, aber behandeln Sie es als kurzlebig und schreiben Sie keinen Zustand dort. Für ein Plugin, das an Ort und Stelle aus einem lokalen Verzeichnis-Marketplace geladen wird, zeigt die Variable auf das stabile Quellverzeichnis. Siehe [Plugin-Caching](#plugin-caching-and-file-resolution), welche Plugins kopiert werden und für Cleanup-Semantik.

~~834~~

835Wenn ein kopiertes Plugin während einer Sitzung aktualisiert wird, verwenden Hook-Befehle, Monitors, MCP-Server und LSP-Server weiterhin den Pfad der vorherigen Version. Führen Sie `/reload-plugins` aus, um Hooks, MCP-Server und LSP-Server zum neuen Pfad zu wechseln; Monitors erfordern einen Sitzungsneustart. In einer Sitzung ohne interaktives Terminal lässt das Reload Plugin-MCP-Server auf dem alten Pfad, bis die nächste Sitzung.

~~836~~

837Für ein Plugin mit einer `command`-Quelle kann Claude Code [das Plugin selbst neu laden](/docs/de/plugin-marketplaces#when-claude-code-re-runs-the-command).

~~838~~

839MCP-Server können auch die `roots/list`-Anfrage aufrufen, um die Arbeitsverzeichnisse der Sitzung zur Laufzeit zu lesen. Siehe [was `roots/list` zurückgibt und wann Claude Code den Server über Änderungen benachrichtigt](/docs/de/mcp#option-3-add-a-local-stdio-server).

~~840~~

841<h4 id="persistent-data-directory">

842 Persistentes Datenverzeichnis

843</h4>

~~844~~

845Das Verzeichnis `${CLAUDE_PLUGIN_DATA}` wird zu `~/.claude/plugins/data/{id}/` aufgelöst, wobei `{id}` der Plugin-Bezeichner mit Zeichen außerhalb von `a-z`, `A-Z`, `0-9`, `_` und `-` ist, die durch `-` ersetzt werden. Für ein Plugin, das als `formatter@my-marketplace` installiert ist, ist das Verzeichnis `~/.claude/plugins/data/formatter-my-marketplace/`.

~~846~~

847Eine häufige Verwendung ist die einmalige Installation von Sprachabhängigkeiten und deren Wiederverwendung über Sitzungen und Plugin-Updates hinweg. Verwenden Sie es für Python-Abhängigkeiten, Abhängigkeiten, die mit Yarn oder pnpm gesperrt sind, und Pakete, deren Lifecycle-Skripte ausgeführt werden müssen. Für ein auf dem Marketplace installiertes Plugin benötigen Sie es möglicherweise überhaupt nicht: Claude Code installiert automatisch berechtigte [Node.js-Paketabhängigkeiten](#node-js-package-dependencies), wenn es das Plugin zwischenspeichert.

~~848~~

849Da das Datenverzeichnis länger lebt als jede einzelne Plugin-Version, kann eine Überprüfung auf Verzeichnisexistenz allein nicht erkennen, wenn ein Update die Abhängigkeitsmanifest des Plugins ändert. Das empfohlene Muster vergleicht das gebündelte Manifest mit einer Kopie im Datenverzeichnis und installiert neu, wenn sie sich unterscheiden.

~~850~~

851Dieser `SessionStart`-Hook installiert `node_modules` beim ersten Lauf und erneut, wenn ein Plugin-Update eine geänderte `package.json` enthält:

~~852~~

853```json theme={null}

854{

855 "hooks": {

856 "SessionStart": [

857 {

858 "hooks": [

859 {

860 "type": "command",

861 "command": "diff -q \"${CLAUDE_PLUGIN_ROOT}/package.json\" \"${CLAUDE_PLUGIN_DATA}/package.json\" >/dev/null 2>&1 || (cd \"${CLAUDE_PLUGIN_DATA}\" && cp \"${CLAUDE_PLUGIN_ROOT}/package.json\" . && npm install) || rm -f \"${CLAUDE_PLUGIN_DATA}/package.json\""

862 }

863 ]

864 }

865 ]

866 }

867}

868```

~~869~~

870Der `diff` beendet sich mit Nonzero, wenn die gespeicherte Kopie fehlt oder sich von der gebündelten unterscheidet, was sowohl den ersten Lauf als auch abhängigkeitsändernde Updates abdeckt. Wenn `npm install` fehlschlägt, entfernt das nachfolgende `rm` das kopierte Manifest, damit die nächste Sitzung erneut versucht.

~~871~~

872Skripte, die in `${CLAUDE_PLUGIN_ROOT}` gebündelt sind, können dann gegen die persistierten `node_modules` ausgeführt werden:

~~873~~

874```json theme={null}

875{

876 "mcpServers": {

877 "routines": {

878 "command": "node",

879 "args": ["${CLAUDE_PLUGIN_ROOT}/server.js"],

880 "env": {

881 "NODE_PATH": "${CLAUDE_PLUGIN_DATA}/node_modules"

882 }

883 }

884 }

885}

886```

~~887~~

888Das Datenverzeichnis wird automatisch gelöscht, wenn Sie das Plugin aus dem letzten Bereich deinstallieren, in dem es installiert ist. Die `/plugin`-Schnittstelle zeigt die Verzeichnisgröße an und fordert vor dem Löschen auf. Die CLI löscht standardmäßig; übergeben Sie [`--keep-data`](#plugin-uninstall), um es zu behalten.

~~889~~

890***

~~891~~

892<h2 id="plugin-caching-and-file-resolution">

893 Plugin-Caching und Dateiauflösung

894</h2>

~~895~~

896Plugins werden auf eine von drei Arten angegeben:

~~897~~

898* Über `claude --plugin-dir` oder `claude --plugin-url` für die Dauer einer Sitzung.

899* Über einen Marketplace, installiert für zukünftige Sitzungen.

900* Über Ihr claude.ai-Konto, [synchronisiert](#synced-plugins) in `~/.claude/plugins/synced/`.

~~901~~

902Aus Sicherheits- und Verifizierungsgründen kopiert Claude Code *Marketplace*-Plugins in den lokalen **Plugin-Cache** des Benutzers (`~/.claude/plugins/cache`), anstatt sie an Ort und Stelle zu verwenden, es sei denn, das Plugin wird an Ort und Stelle geladen. Eine [`command`-Quelle im Link-Modus](/docs/de/plugin-marketplaces#copy-mode-and-link-mode) wird an Ort und Stelle über Links im Cache-Eintrag geladen. Eine [Quelle mit relativem Pfad](/docs/de/plugin-marketplaces#relative-paths) in einem Marketplace, der aus einem lokalen Verzeichnis hinzugefügt wurde, wird an Ort und Stelle aus dem Marketplace-Ordner geladen.

~~903~~

904Für ein Plugin, das an Ort und Stelle aus einem lokalen Verzeichnis-Marketplace geladen wird, werden Ihre Änderungen am Quellverzeichnis beim nächsten Sitzungsstart oder `/reload-plugins` wirksam. Sie benötigen keine Versionsbumps. Der Hook-Prozess des Plugins und die MCP- und LSP-Server erhalten ein `CLAUDE_PLUGIN_ROOT`, das auf das Quellverzeichnis verweist. Claude Code installiert die [Node.js-Paketabhängigkeiten](#node-js-package-dependencies) des Plugins nicht in das Quellverzeichnis. Installieren Sie diese selbst dort oder von einem Hook aus in das [persistente Datenverzeichnis](#persistent-data-directory).

~~905~~

906Für kopierte Plugins ist jede installierte Version ein separates Verzeichnis im Cache, gruppiert nach Marketplace und Plugin und benannt nach der aufgelösten Version, mit einer eigenen Kopie der Plugin-Dateien und [Node.js-Paketabhängigkeiten](#node-js-package-dependencies). Eine Abhängigkeit, die von einem [Release-Tag](/docs/de/plugin-dependencies#tag-plugin-releases-for-version-resolution) aufgelöst wird, erhält einen Verzeichnisnamen mit einem Commit-SHA-Suffix.

~~907~~

908Wenn Sie ein Plugin aktualisieren oder deinstallieren, markiert Claude Code das vorherige Versionsverzeichnis als verwaist und entfernt es in einem Hintergrund-Sweep ungefähr 14 Tage später. Die Kulanzfrist ermöglicht es gleichzeitigen Claude Code-Sitzungen, die bereits die alte Version geladen haben, ohne Fehler weiter zu laufen. Claude Code führt den Sweep nur aus, wenn mindestens ein Plugin installiert ist; nachdem Sie Ihr letztes Plugin deinstalliert haben, bleiben verwaiste Verzeichnisse auf der Festplatte, bis Sie ein Plugin erneut installieren.

~~909~~

910Claude Code entfernt einen Plugin- oder Marketplace-Ordner aus dem Cache nur, wenn er kein Verzeichnis oder Symlink mehr enthält. Wenn Sie einen Entwicklungs-Checkout als Versionseinträge eines Plugins in den Cache symlinken, markiert Claude Code den Link niemals als verwaist und entfernt ihn oder die Ordner, die ihn enthalten, niemals. Claude Code schreibt auch niemals seine Versions-Tracking-Dateien in den verlinkten Checkout.

~~911~~

912Die Glob- und Grep-Tools von Claude überspringen verwaiste Versionsverzeichnisse während Suchen, sodass Dateiergebnisse keinen veralteten Plugin-Code enthalten.

~~913~~

914<h3 id="node-js-package-dependencies">

915 Node.js-Paketabhängigkeiten

916</h3>

~~917~~

918Wenn Claude Code ein Plugin in den Cache kopiert, installiert es auch die Node.js-Paketabhängigkeiten des Plugins dort, damit die Hooks und MCP-Server des Plugins diese laden können. Dieser Abschnitt behandelt die npm- und Bun-Pakete, die ein Plugin in seiner eigenen `package.json` deklariert. Für Plugins, die von anderen Plugins abhängen, siehe [Plugin-Abhängigkeitsversionen](/docs/de/plugin-dependencies).

~~919~~

920Claude Code führt die Installation im kopierten Versionsverzeichnis jedes Mal aus, wenn es eines erstellt: wenn Sie ein Plugin installieren, wenn Claude Code ein Plugin auf eine neue Version aktualisiert, und beim Sitzungsstart, wenn ein aktiviertes Plugin noch nicht zwischengespeichert ist, z. B. auf einem neuen Computer. Die Installation wird nur ausgeführt, wenn das Plugin-Stammverzeichnis sowohl eine `package.json` als auch eine unterstützte Sperrdatei enthält:

~~921~~

922| Sperrdatei | Befehl |

923| :--------------------------------------------- | :----------------------------------------------- |

924| `bun.lock` oder `bun.lockb` | `bun install --frozen-lockfile --ignore-scripts` |

925| `npm-shrinkwrap.json` oder `package-lock.json` | `npm ci --ignore-scripts` |

~~926~~

927Wenn ein Plugin mehr als eine dieser Sperrdateien enthält, verwendet Claude Code die erste Übereinstimmung und prüft in dieser Reihenfolge: `bun.lock`, `bun.lockb`, `npm-shrinkwrap.json`, `package-lock.json`.

~~928~~

929Claude Code überspringt die Installation in zwei Fällen, jeweils mit einer eigenen Lösung:

~~930~~

931* Wenn Ihr Plugin nur eine `yarn.lock` oder `pnpm-lock.yaml` enthält, ersetzen Sie diese durch eine npm-Sperrdatei.

932* Wenn eine `bunfig.toml` neben der Bun-Sperrdatei liegt, entfernen Sie die `bunfig.toml`, oder ersetzen Sie die Bun-Sperrdatei durch eine npm-Sperrdatei.

~~933~~

934Versenden Sie eine npm-Sperrdatei für die größtmögliche Reichweite. Claude Code führt den Paketmanager der übereinstimmenden Sperrdatei aus dem PATH des Benutzers aus und fällt nicht auf die andere Sperrdatei zurück, wenn sie fehlt. Verwenden Sie für ein Plugin, das über eine npm-Quelle verteilt wird, `npm-shrinkwrap.json`; npm schließt `package-lock.json` aus veröffentlichten Paketen aus.

~~935~~

936Claude Code beschränkt diese Abhängigkeitsinstallation so, dass während der Installation kein Code aus dem Plugin oder seinen Paketen ausgeführt wird, und begrenzt, wie lange sie ausgeführt werden kann:

~~937~~

938* **Gefrorene Auflösung:** Bun und npm installieren genau das, was die Sperrdatei festlegt, und schlagen fehl, anstatt Versionen erneut aufzulösen, wenn `package.json` und die Sperrdatei nicht übereinstimmen.

939* **Keine Lifecycle-Skripte:** `--ignore-scripts` verhindert, dass `preinstall`-, `install`- und `postinstall`-Skripte ausgeführt werden, sodass Abhängigkeiten, die native Module in diesen Skripten erstellen, heruntergeladen, aber während dieser Installation nicht kompiliert werden.

940* **60-Sekunden-Timeout:** Claude Code stoppt eine Installation, die länger läuft, und behandelt sie als fehlgeschlagen.

~~941~~

942Claude Code ruft ein npm-Quellen-Plugin vor dieser Abhängigkeitsinstallation ab, und keines der eigenen Installationsskripte des Pakets wird während des Abrufs ausgeführt. Siehe [npm-Pakete](/docs/de/plugin-marketplaces#npm-packages).

~~943~~

944Eine fehlgeschlagene oder übersprungene Installation blockiert das Plugin niemals. Wenn die Installation fehlschlägt oder Claude Code sie überspringt, weil eine yarn- oder pnpm-Sperrdatei vorhanden ist oder eine `bunfig.toml` daneben liegt, wird der Grund als Warnung in der [Debug-Ausgabe](#debugging-commands) aufgezeichnet. Ein Plugin mit einer `package.json` und ohne Sperrdatei wird ohne Logeintrag übersprungen. Eine Timeout-Installation kann einen partiellen `node_modules`-Baum in der zwischengespeicherten Kopie hinterlassen.

~~945~~

946Sie können die automatische Installation nicht ausschalten; keine Einstellung oder Umgebungsvariable deaktiviert sie. In eingeschränkten Netzwerken siehe die [Netzwerkzugriffsanforderungen](/docs/de/network-config#network-access-requirements) für die Hosts, die Sie zulassen müssen.

~~947~~

948Für Abhängigkeiten, die die automatische Installation nicht bereitstellen kann, z. B. Pakete, die ihre Lifecycle-Skripte zum Erstellen benötigen, Python-Abhängigkeiten oder ein Plugin, das mit Yarn oder pnpm gesperrt ist, installieren Sie diese von einem Hook in das [persistente Datenverzeichnis](#persistent-data-directory).

~~949~~

950<h3 id="path-traversal-limitations">

951 Einschränkungen bei der Pfadtraversierung

952</h3>

~~953~~

954Claude Code erlaubt einem Plugin nicht, auf Dateien außerhalb seines eigenen Verzeichnisses zu verweisen. Es lehnt einen Komponentenpfad ab, der außerhalb des Plugin-Stammverzeichnisses aufgelöst wird, unabhängig davon, ob der Pfad in `plugin.json` oder in einem [Marketplace-Eintrag](/docs/de/plugin-marketplaces#plugin-entries) deklariert ist. Dies umfasst einen Pfad, der außerhalb des Plugins verweist, wie geschrieben, z. B. `../shared-utils`, und einen Symlink, der außerhalb des Plugins führt, mit Ausnahme von [Links innerhalb eines Marketplace](#share-files-within-a-marketplace-with-symlinks).

~~955~~

956Auf macOS und Linux lehnt Claude Code auch einen Komponentenpfad ab, der an irgendeiner Stelle einen Backslash enthält, auch wenn der Pfad innerhalb des Plugins bleibt. Komponenten, die mit Backslash-Pfaden deklariert sind, werden daher nur unter Windows geladen. Schreiben Sie Komponentenpfade mit Schrägstrichen, z. B. `./commands/deploy.md`.

~~957~~

958Wenn Claude Code einen Pfad ablehnt, meldet es einen [`path escapes plugin directory`](/docs/de/errors#path-escapes-plugin-directory)-Fehler und lädt das Plugin ohne diese Komponente.

~~959~~

960Claude Code kopiert auch keine Dateien außerhalb des Plugin-Verzeichnisses in den Cache, wenn es das Plugin installiert. Wenn also ein Skript in einem kopierten Plugin einen Pfad über dem Plugin-Stammverzeichnis liest, findet es diese Dateien auch nicht.

~~961~~

962<h3 id="share-files-within-a-marketplace-with-symlinks">

963 Dateien innerhalb eines Marketplace mit Symlinks freigeben

964</h3>

~~965~~

966Wenn Ihr Plugin Dateien mit anderen Teilen desselben Marketplace freigeben muss, können Sie symbolische Links in Ihrem Plugin-Verzeichnis erstellen. Wie ein Symlink behandelt wird, wenn das Plugin in den Cache kopiert wird, hängt davon ab, wo sein Ziel aufgelöst wird:

~~967~~

968* **Innerhalb des eigenen Verzeichnisses des Plugins:** Der Symlink wird als relativer Symlink im Cache beibehalten, sodass er zur Laufzeit weiterhin zum kopierten Ziel aufgelöst wird.

969* **Anderswo innerhalb desselben Marketplace:** Der Symlink wird dereferenziert. Der Inhalt des Ziels wird an seiner Stelle in den Cache kopiert. Dies ermöglicht es dem `skills/`-Verzeichnis eines Meta-Plugins, auf Skills zu verlinken, die von anderen Plugins im Marketplace definiert werden.

970* **Außerhalb des Marketplace:** Der Symlink wird aus Sicherheitsgründen übersprungen. Dies verhindert, dass Plugins beliebige Host-Dateien wie Systempfade in den Cache ziehen.

~~971~~

972Für Plugins, die mit `--plugin-dir` installiert sind, von einem lokalen Pfad oder von einer [`command`-Quelle](/docs/de/plugin-marketplaces#copy-mode-and-link-mode) im Copy-Modus, werden nur Symlinks beibehalten, die innerhalb des eigenen Verzeichnisses des Plugins aufgelöst werden. Alle anderen werden übersprungen.

~~973~~

974Der folgende Befehl erstellt einen Link von innerhalb eines Marketplace-Plugins zu einem gemeinsamen Skill, der von einem Sibling-Plugin definiert wird. Verwenden Sie unter Windows `mklink /D` von einer erhöhten Eingabeaufforderung oder aktivieren Sie den Entwicklermodus:

~~975~~

976```bash theme={null}

977ln -s ../../shared-plugin/skills/foo ./skills/foo

978```

~~979~~

980***

~~981~~

982<h2 id="plugin-directory-structure">

983 Verzeichnisstruktur von Plugins

984</h2>

~~985~~

986<h3 id="standard-plugin-layout">

987 Standard-Plugin-Layout

988</h3>

~~989~~

990Ein vollständiges Plugin folgt dieser Struktur:

~~991~~

992```text theme={null}

993enterprise-plugin/

994├── .claude-plugin/ # Metadaten-Verzeichnis (optional)

995│ └── plugin.json # Plugin-Manifest

996├── skills/ # Skills

997│ ├── code-reviewer/

998│ │ └── SKILL.md

999│ └── pdf-processor/

1000│ ├── SKILL.md

1001│ └── scripts/

1002├── commands/ # Skills als flache .md-Dateien

1003│ ├── status.md

1004│ └── logs.md

1005├── agents/ # Subagent-Definitionen

1006│ ├── security-reviewer.md

1007│ ├── performance-tester.md

1008│ ├── compliance-checker.md

1009│ └── review/ # Agents hier werden als enterprise-plugin:review:<name> geladen

1010│ └── accessibility.md

1011├── workflows/ # Workflow-Skripte

1012│ └── release-audit.js

1013├── output-styles/ # Ausgabestil-Definitionen

1014│ └── terse.md

1015├── themes/ # Farbschema-Definitionen

1016│ └── dracula.json

1017├── monitors/ # Hintergrund-Monitor-Konfigurationen

1018│ └── monitors.json

1019├── hooks/ # Hook-Konfigurationen

1020│ ├── hooks.json # Haupt-Hook-Konfiguration

1021│ └── security-hooks.json # Zusätzliche Hooks

1022├── bin/ # Plugin-Ausführbare Dateien, die zu PATH hinzugefügt werden

1023│ └── my-tool # Aufrufbar als einfacher Befehl im Bash-Tool

1024├── settings.json # Standardeinstellungen für das Plugin

1025├── .mcp.json # MCP-Server-Definitionen

1026├── .lsp.json # LSP-Server-Konfigurationen

1027├── scripts/ # Hook- und Utility-Skripte

1028│ ├── security-scan.sh

1029│ ├── format-code.py

1030│ └── deploy.js

1031├── LICENSE # Lizenzdatei

1032└── CHANGELOG.md # Versionsverlauf

1033```

~~1034~~

1035<Warning>

1036 Das `.claude-plugin/`-Verzeichnis enthält die `plugin.json`-Datei. Alle anderen Verzeichnisse (commands/, agents/, skills/, workflows/, output-styles/, themes/, monitors/, hooks/) müssen sich im Plugin-Stammverzeichnis befinden, nicht innerhalb von `.claude-plugin/`.

1037</Warning>

~~1038~~

1039Eine `CLAUDE.md`-Datei im Plugin-Stammverzeichnis wird nicht als Projektkontext geladen. Plugins tragen Kontext durch Skills, Agents und Hooks bei, nicht durch CLAUDE.md. Um Anweisungen bereitzustellen, die in Claudes Kontext geladen werden, platzieren Sie diese in einem [Skill](#skills).

~~1040~~

1041<h3 id="file-locations-reference">

1042 Dateistandorte-Referenz

1043</h3>

~~1044~~

1045| Komponente | Standardort | Zweck |

1046| :---------------------- | :--------------------------- | :----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |

1047| **Manifest** | `.claude-plugin/plugin.json` | Plugin-Metadaten und Konfiguration (optional) |

1048| **Skills** | `skills/` | Skills mit `<name>/SKILL.md`-Struktur |

1049| **Befehle** | `commands/` | Skills als flache Markdown-Dateien. Verwenden Sie `skills/` für neue Plugins |

1050| **Agents** | `agents/` | Subagent-Markdown-Dateien. Unterordner sind Teil des [Agent-Namens](#agents) |

1051| **Workflows** | `workflows/` | [Workflow](/docs/de/workflows)-Skriptdateien |

1052| **Ausgabestile** | `output-styles/` | Ausgabestil-Definitionen |

1053| **Designs** | `themes/` | Farbschema-Definitionen |

1054| **Hooks** | `hooks/hooks.json` | Hook-Konfiguration |

1055| **MCP-Server** | `.mcp.json` | MCP-Server-Definitionen |

1056| **LSP-Server** | `.lsp.json` | Language-Server-Konfigurationen |

1057| **Monitore** | `monitors/monitors.json` | Hintergrund-Monitor-Konfigurationen |

1058| **Ausführbare Dateien** | `bin/` | Ausführbare Dateien, die zum `PATH` des Bash-Tools hinzugefügt werden und als einfache Befehle aufrufbar sind, während das Plugin aktiviert ist. Sie können dieses Verzeichnis nicht in ein Plugin einbeziehen, das Sie [über die Organisationseinstellungen von claude.ai verteilen](/docs/de/plugin-marketplaces#keep-executables-out-of-the-top-level-bin-directory) |

1059| **Einstellungen** | `settings.json` | Standardkonfiguration, die angewendet wird, wenn das Plugin aktiviert ist. Nur die [`agent`](/docs/de/sub-agents)- und [`subagentStatusLine`](/docs/de/statusline#subagent-status-lines)-Schlüssel werden unterstützt |

~~1060~~

1061***

~~1062~~

1063<h2 id="cli-commands-reference">

1064 CLI-Befehle – Referenz

1065</h2>

~~1066~~

1067Claude Code bietet CLI-Befehle für nicht-interaktive Plugin-Verwaltung, nützlich für Skripte und Automatisierung.

~~1068~~

1069<h3 id="plugin-init">

1070 plugin init

1071</h3>

~~1072~~

1073Gerüst für ein neues Plugin unter `~/.claude/skills/<name>/` erstellen. In der nächsten Claude Code-Sitzung wird es automatisch als `<name>@skills-dir` geladen und erscheint in `/plugin` und `claude plugin list` ohne Installationsschritt.

~~1074~~

1075Siehe [Skills-directory plugins](#skills-directory-plugins) für Umfang und Vertrauensanforderungen.

~~1076~~

1077```bash theme={null}

1078claude plugin init <name> [options]

1079```

~~1080~~

1081Der Befehl nimmt diese Argumente an:

~~1082~~

1083* `<name>`: Plugin-Name. Wird zum Skill-Namespace und zum Verzeichnisnamen unter `~/.claude/skills/`, daher darf er keine Leerzeichen oder Pfad-Trennzeichen enthalten.

~~1084~~

1085Der Befehl akzeptiert diese Optionen:

~~1086~~

1087| Option | Beschreibung | Standard |

1088| :----------------------- | :------------------------------------------------------------------------------------------------------------------- | :---------------------- |

1089| `--description <text>` | Manifest-Beschreibung | |

1090| `--author <name>` | Autorname | `git config user.name` |

1091| `--author-email <email>` | Autor-E-Mail | `git config user.email` |

1092| `--with <components...>` | Auch Komponentenordner gerüsten. Gültige Werte: `skills`, `agents`, `hooks`, `mcp`, `lsp`, `output-style`, `channel` | |

1093| `-f, --force` | Vorhandenes `.claude-plugin/` am Ziel überschreiben | |

1094| `-h, --help` | Hilfe für Befehl anzeigen | |

~~1095~~

1096`claude plugin new` ist ein Alias für diesen Befehl.

~~1097~~

1098Jeder `--with`-Wert fügt eine Starter-Datei für diese Komponente hinzu, bereit zum Bearbeiten:

~~1099~~

1100| Komponente | Was es gerüstet |

1101| :------------- | :------------------------------------------------------------------------------------------------------------------- |

1102| `skills` | Ein zusätzlicher Namespace-Skill `<name>:example` neben dem Standard-Skill |

1103| `agents` | Eine `agents/`-Subagent-Definition |

1104| `hooks` | Eine `hooks/hooks.json` mit einem Beispiel-Event-Handler |

1105| `mcp` | Eine `.mcp.json` mit HTTP- und Stdio-Server-Beispielen |

1106| `lsp` | Ein `.lsp.json`-Language-Server-Beispiel |

1107| `output-style` | Ein `output-styles/<name>.md`, das automatisch angewendet wird, während das Plugin aktiviert ist |

1108| `channel` | Ein MCP-basierter [channel](/docs/de/channels): ein Stdio-Server (`server.ts`), seine `.mcp.json` und eine `package.json` |

~~1109~~

1110Das gerüstete Plugin verwendet die `@skills-dir`-Quelle statt eines Marketplace. Administratoren können diese Quelle mit `strictKnownMarketplaces` blockieren oder indem sie `{"source": "skills-dir"}` zu `blockedMarketplaces` in [managed settings](/docs/de/plugin-marketplaces#managed-marketplace-restrictions) hinzufügen. Wenn blockiert, schlägt `plugin init` fehl, bevor etwas geschrieben wird.

~~1111~~

1112Diese Beispiele zeigen häufige Aufrufe:

~~1113~~

1114```bash theme={null}

1115# Minimales Plugin gerüsten

1116claude plugin init my-helper

~~1117~~

1118# Mit Skill- und Hook-Ordnern gerüsten

1119claude plugin init my-helper --with skills hooks

~~1120~~

1121# Vorhandenes Gerüst überschreiben

1122claude plugin init my-helper --force

1123```

~~1124~~

1125<h3 id="plugin-install">

1126 plugin install

1127</h3>

~~1128~~

1129Ein Plugin aus verfügbaren Marketplaces installieren.

~~1130~~

1131```bash theme={null}

1132claude plugin install <plugin> [options]

1133```

~~1134~~

1135Der Befehl nimmt diese Argumente an:

~~1136~~

1137* `<plugin>`: Plugin-Name oder `plugin-name@marketplace-name` für einen bestimmten Marketplace

~~1138~~

1139Der Befehl akzeptiert diese Optionen:

~~1140~~

1141| Option | Beschreibung | Standard |

1142| :-------------------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | :------- |

1143| `-s, --scope <scope>` | Installationsumfang: `user`, `project` oder `local` | `user` |

1144| `--config <key=value>` | Setzen Sie eine [`userConfig`](#user-configuration)-Option, die im Plugin-Manifest deklariert ist. Wiederholen Sie das Flag, um mehrere Optionen zu setzen | |

1145| `-y, --yes` | Akzeptieren Sie einen Befehl, den der Marketplace des Plugins deklariert, ohne die Bestätigungsaufforderung: den Befehl, der ein Plugin mit einer [`command`-Quelle](/docs/de/plugin-marketplaces#command-sources) erzeugt, oder den [`headersHelper`](/docs/de/plugin-marketplaces#authenticate-archive-downloads), der einen Archiv-Download authentifiziert. Das Akzeptieren eines `headersHelper` erfordert Claude Code v2.1.238 oder später. Claude Code druckt den Befehl trotzdem zuerst. Erforderlich, wenn stdin oder stdout kein TTY ist, es sei denn, Sie übergeben `--accept-command`. Hat keine Auswirkung innerhalb einer Claude Code-Sitzung, daher führen Sie den Befehl von Ihrem eigenen Terminal aus | |

1146| `--accept-command <sha256>` | Akzeptieren Sie den vom Marketplace deklarierten Befehl, dessen `sha256` ein vorheriger [`--json`-Lauf](#plugin-json-result) in `shownCommand` gemeldet hat, anstelle von `-y`. Die Akzeptanz zählt für genau diesen Befehl, dieses Plugin und diesen Marketplace-Katalog. Wenn sich einer von ihnen seit der Anzeige des Befehls geändert hat, einschließlich durch den eigenen Marketplace-Refresh des Laufs, akzeptiert Claude Code den Digest nicht und zeigt den Befehl erneut an. Kann nicht mit `-y` kombiniert werden. Hat keine Auswirkung innerhalb einer Claude Code-Sitzung, daher führen Sie den Befehl von Ihrem eigenen Terminal aus. Erfordert Claude Code v2.1.271 oder später | |

1147| `--json` | Geben Sie das Ergebnis als ein JSON-Objekt in der letzten Zeile von stdout aus, anstelle der benutzerfreundlichen Nachricht, zur Verwendung in Skripten. Siehe [JSON-Ergebnisformat](#plugin-json-result). Erfordert Claude Code v2.1.268 oder später | |

1148| `-h, --help` | Hilfe für Befehl anzeigen | |

~~1149~~

1150Der Umfang bestimmt, welche Einstellungsdatei das installierte Plugin hinzugefügt wird. Beispielsweise schreibt `--scope project` zu `enabledPlugins` in .claude/settings.json, wodurch das Plugin für alle verfügbar wird, die das Projekt-Repository klonen.

~~1151~~

1152<span id="plugin-json-result" />Mit `--json` ist die letzte Zeile von stdout ein JSON-Objekt. Analysieren Sie nur diese Zeile, da Claude Code jeden Befehl, den der Marketplace deklariert, davor druckt. Drei Felder sind immer vorhanden:

~~1153~~

1154* `command`: der Unterbefehl, der ausgeführt wurde, wie `install`

1155* `outcome`: `ok` oder `failed`

1156* `message`: eine benutzerfreundliche Beschreibung des Ergebnisses

~~1157~~

1158Andere Felder, wie `pluginId`, `scope` und `failureCode`, erscheinen nur, wenn sie zutreffen. Die `--json`-Option auf `plugin uninstall`, `plugin update`, `plugin enable` und `plugin disable` druckt das gleiche Objekt mit den eigenen Feldern dieses Unterbefehls. Ein Nutzungsfehler, wie ein ungültiger `--scope`, druckt keine Ergebniszeile und beendet sich mit 1 mit dem Grund auf stderr.

~~1159~~

1160Wenn ein Lauf einen vom Marketplace deklarierten Befehl anzeigt und ihn nicht ausführt, trägt das `failed`-Ergebnis auch ein `shownCommand`-Objekt, dessen Felder den angezeigten Befehl, das Plugin, zu dem er gehört, und den `sha256` des Befehls enthalten. Um genau diesen Befehl zu akzeptieren, führen Sie ihn erneut mit diesem `sha256` als `--accept-command` aus. Erfordert Claude Code v2.1.271 oder später.

~~1161~~

1162Wenn `shownCommand.acceptCommandMatched` `false` ist, stimmt der übergebene Digest nicht mit dem jetzt angezeigten Befehl überein. Zeigen Sie diesen Befehl einer Person, bevor Sie seinen `sha256` übergeben.

~~1163~~

1164Diese Beispiele zeigen häufige Aufrufe:

~~1165~~

1166```bash theme={null}

1167# Im Benutzerumfang installieren (Standard)

1168claude plugin install formatter@my-marketplace

~~1169~~

1170# Im Projektumfang installieren (mit Team geteilt)

1171claude plugin install formatter@my-marketplace --scope project

~~1172~~

1173# Im lokalen Umfang installieren (nicht mit Team geteilt)

1174claude plugin install formatter@my-marketplace --scope local

1175```

~~1176~~

1177<h3 id="plugin-uninstall">

1178 plugin uninstall

1179</h3>

~~1180~~

1181Ein installiertes Plugin entfernen.

~~1182~~

1183```bash theme={null}

1184claude plugin uninstall <plugin> [options]

1185```

~~1186~~

1187Der Befehl nimmt diese Argumente an:

~~1188~~

1189* `<plugin>`: Plugin-Name oder `plugin-name@marketplace-name`

~~1190~~

1191Der Befehl akzeptiert diese Optionen:

~~1192~~

1193| Option | Beschreibung | Standard |

1194| :-------------------- | :-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :------- |

1195| `-s, --scope <scope>` | Aus Umfang deinstallieren: `user`, `project` oder `local` | `user` |

1196| `--keep-data` | Das [persistent data directory](#persistent-data-directory) des Plugins beibehalten | |

1197| `--prune` | Auch automatisch installierte Abhängigkeiten entfernen, die kein anderes Plugin benötigt. Siehe [plugin prune](#plugin-prune) | |

1198| `-y, --yes` | Bestätigungsaufforderung für `--prune` überspringen. Erforderlich, wenn stdin oder stdout kein TTY ist | |

1199| `--json` | Geben Sie 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 später | |

1200| `-h, --help` | Hilfe für Befehl anzeigen | |

~~1201~~

1202`claude plugin remove` und `claude plugin rm` sind Aliase für diesen Befehl.

~~1203~~

1204Standardmäßig werden beim Deinstallieren aus dem letzten verbleibenden Umfang auch das `${CLAUDE_PLUGIN_DATA}`-Verzeichnis des Plugins gelöscht. Verwenden Sie `--keep-data`, um es zu bewahren, beispielsweise beim Neuinstallieren nach dem Testen einer neuen Version.

~~1205~~

1206<Note>

1207 Wenn installierte Plugins aus verschiedenen Marketplaces einen Namen teilen, deinstalliert die `plugin-name@marketplace-name`-Form nur das Plugin aus dem benannten Marketplace. Vor v2.1.212 konnte die qualifizierte Form das gleichnamige Plugin aus einem anderen Marketplace abgleichen und deinstallieren.

1208</Note>

~~1209~~

1210<h3 id="plugin-prune">

1211 plugin prune

1212</h3>

~~1213~~

1214Automatisch installierte Plugin-Abhängigkeiten entfernen, die nicht mehr von einem installierten Plugin benötigt werden. Abhängigkeiten, die Claude Code eingezogen hat, um das [`dependencies`](/docs/de/plugin-dependencies)-Feld eines anderen Plugins zu erfüllen, werden entfernt; Plugins, die Sie direkt installiert haben, werden nie berührt.

~~1215~~

1216```bash theme={null}

1217claude plugin prune [options]

1218```

~~1219~~

1220Der Befehl akzeptiert diese Optionen:

~~1221~~

1222| Option | Beschreibung | Standard |

1223| :-------------------- | :--------------------------------------------------------------------------------------- | :------- |

1224| `-s, --scope <scope>` | Im Umfang bereinigen: `user`, `project` oder `local` | `user` |

1225| `--dry-run` | Auflisten, was entfernt würde, ohne etwas zu entfernen | |

1226| `-y, --yes` | Bestätigungsaufforderung überspringen. Erforderlich, wenn stdin oder stdout kein TTY ist | |

1227| `-h, --help` | Hilfe für Befehl anzeigen | |

~~1228~~

1229`claude plugin autoremove` ist ein Alias für diesen Befehl.

~~1230~~

1231Der Befehl listet verwaiste Abhängigkeiten auf und fragt vor dem Entfernen um Bestätigung. Um ein Plugin zu entfernen und seine Abhängigkeiten in einem Schritt zu bereinigen, führen Sie `claude plugin uninstall <plugin> --prune` aus.

~~1232~~

1233<h3 id="plugin-enable">

1234 plugin enable

1235</h3>

~~1236~~

1237Ein deaktiviertes Plugin aktivieren. Wenn das Ziel aus einem Marketplace installiert ist und [Abhängigkeiten](/docs/de/plugin-dependencies) deklariert, aktiviert Claude Code diese transitiv im gleichen Umfang. Der Befehl schlägt unter den Bedingungen fehl, die [Enable or disable a plugin with dependencies](/docs/de/plugin-dependencies#enable-or-disable-a-plugin-with-dependencies) auflistet.

~~1238~~

1239```bash theme={null}

1240claude plugin enable <plugin> [options]

1241```

~~1242~~

1243Der Befehl nimmt diese Argumente an:

~~1244~~

1245* `<plugin>`: Plugin-Name, `plugin-name@marketplace-name` oder `plugin-name@synced` für ein [Plugin, das von claude.ai synchronisiert wird](#synced-plugins)

~~1246~~

1247Der Befehl akzeptiert diese Optionen:

~~1248~~

1249| Option | Beschreibung | Standard |

1250| :-------------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | :--------------------- |

1251| `-s, --scope <scope>` | Umfang zum Aktivieren: `user`, `project` oder `local`. Wenn weggelassen, erkennt Claude Code den Umfang, in dem das Plugin installiert ist | Automatische Erkennung |

1252| `--json` | Geben Sie 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 später | |

1253| `-h, --help` | Hilfe für Befehl anzeigen | |

~~1254~~

1255<h3 id="plugin-disable">

1256 plugin disable

1257</h3>

~~1258~~

1259Ein Plugin deaktivieren, ohne es zu deinstallieren.

~~1260~~

1261Wenn das Ziel aus einem Marketplace installiert ist, schlägt der Befehl fehl, wenn ein anderes aktiviertes Plugin [davon abhängt](/docs/de/plugin-dependencies#enable-or-disable-a-plugin-with-dependencies). Die Fehlermeldung enthält einen verketteten Befehl, der zuerst alle abhängigen Plugins deaktiviert.

~~1262~~

1263Für ein [synced plugin](#synced-plugins), das Ihre Organisation benötigt, schlägt der Befehl fehl und speichert nichts.

~~1264~~

1265```bash theme={null}

1266claude plugin disable [plugin] [options]

1267```

~~1268~~

1269Der Befehl nimmt diese Argumente an:

~~1270~~

1271* `[plugin]`: Plugin-Name, `plugin-name@marketplace-name` oder `plugin-name@synced` für ein [Plugin, das von claude.ai synchronisiert wird](#synced-plugins). Optional bei Verwendung von `--all`

~~1272~~

1273Der Befehl akzeptiert diese Optionen:

~~1274~~

1275| Option | Beschreibung | Standard |

1276| :-------------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | :--------------------- |

1277| `-a, --all` | Alle aktivierten Plugins deaktivieren. Kann nicht mit `--scope` kombiniert werden | |

1278| `-s, --scope <scope>` | Umfang zum Deaktivieren: `user`, `project` oder `local`. Wenn weggelassen, erkennt Claude Code den Umfang, in dem das Plugin installiert ist | Automatische Erkennung |

1279| `--json` | Geben Sie 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 später | |

1280| `-h, --help` | Hilfe für Befehl anzeigen | |

~~1281~~

1282<h3 id="plugin-update">

1283 plugin update

1284</h3>

~~1285~~

1286Ein Plugin auf die neueste Version aktualisieren.

~~1287~~

1288```bash theme={null}

1289claude plugin update <plugin> [options]

1290```

~~1291~~

1292Der Befehl nimmt diese Argumente an:

~~1293~~

1294* `<plugin>`: Plugin-Name oder `plugin-name@marketplace-name`

~~1295~~

1296Der Befehl akzeptiert diese Optionen:

~~1297~~

1298| Option | Beschreibung | Standard |

1299| :-------------------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | :------- |

1300| `-s, --scope <scope>` | Umfang zum Aktualisieren: `user`, `project`, `local` oder `managed` | `user` |

1301| `-y, --yes` | Akzeptieren Sie einen Befehl, den der Marketplace des Plugins deklariert, ohne die Bestätigungsaufforderung: den Befehl, der ein Plugin mit einer [`command`-Quelle](/docs/de/plugin-marketplaces#command-sources) erzeugt, oder den [`headersHelper`](/docs/de/plugin-marketplaces#authenticate-archive-downloads), der einen Archiv-Download authentifiziert. Das Akzeptieren eines `headersHelper` erfordert Claude Code v2.1.238 oder später. Claude Code druckt den Befehl trotzdem zuerst. Erforderlich, wenn stdin oder stdout kein TTY ist, es sei denn, Sie übergeben `--accept-command`. Hat keine Auswirkung innerhalb einer Claude Code-Sitzung, daher führen Sie den Befehl von Ihrem eigenen Terminal aus | |

1302| `--accept-command <sha256>` | Akzeptieren Sie den vom Marketplace deklarierten Befehl, dessen `sha256` ein vorheriger [`--json`-Lauf](#plugin-json-result) in `shownCommand` gemeldet hat, anstelle von `-y`. Die Akzeptanz zählt für genau diesen Befehl, dieses Plugin und diesen Marketplace-Katalog. Wenn sich einer von ihnen seit der Anzeige des Befehls geändert hat, einschließlich durch den eigenen Marketplace-Refresh des Laufs, akzeptiert Claude Code den Digest nicht und zeigt den Befehl erneut an. Kann nicht mit `-y` kombiniert werden. Hat keine Auswirkung innerhalb einer Claude Code-Sitzung, daher führen Sie den Befehl von Ihrem eigenen Terminal aus. Erfordert Claude Code v2.1.271 oder später | |

1303| `--json` | Geben Sie 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 später | |

1304| `-h, --help` | Hilfe für Befehl anzeigen | |

~~1305~~

1306<Note>

1307 Claude Code löst einen einfachen Plugin-Namen gegen Ihre installierten Plugins auf. Wenn installierte Plugins aus verschiedenen Marketplaces den Namen teilen, weigert sich Claude Code zu aktualisieren und listet stattdessen die qualifizierten `plugin-name@marketplace-name`-Befehle auf, die ausgeführt werden sollen. Vor v2.1.246 akzeptierte Claude Code nur die qualifizierte Form und lehnte einen einfachen Namen als nicht gefunden ab.

1308</Note>

~~1309~~

1310***

~~1311~~

1312<h3 id="plugin-list">

1313 plugin list

1314</h3>

~~1315~~

1316Installierte Plugins mit ihrer Version, Quell-Marketplace und Aktivierungsstatus auflisten.

~~1317~~

1318```bash theme={null}

1319claude plugin list [options]

1320```

~~1321~~

1322Der Befehl akzeptiert diese Optionen:

~~1323~~

1324| Option | Beschreibung | Standard |

1325| :------------ | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :------- |

1326| `--json` | Ausgabe als JSON. Eine Plugin-Zeile mit Ladeproblemen oder Authoring-Warnungen trägt `errors`- oder `notes`-String-Arrays. Auf Claude Code v2.1.268 oder später geben parallele `errorDetails`- und `noteDetails`-Arrays jedem Eintrag seinen diagnostischen `type` und die Namen, auf die er sich bezieht, wie das Plugin, den Marketplace, den Server oder die Datei | |

1327| `--available` | Verfügbare Plugins aus Marketplaces einschließen. Erfordert `--json` | |

1328| `-h, --help` | Hilfe für Befehl anzeigen | |

~~1329~~

1330Innerhalb einer interaktiven Sitzung druckt `/plugin list` eine ähnliche Auflistung inline, aber sie umfasst nur Marketplace-installierte Plugins:

~~1331~~

1332* Plugins, die aus Skills-Verzeichnissen geladen werden, erscheinen in der `/plugin`-Schnittstelle und in `claude plugin list`, aber nicht in der Inline-Ausgabe `/plugin list`.

1333* [Plugins, die von claude.ai synchronisiert werden](#synced-plugins) erscheinen in `claude plugin list` auf Claude Code v2.1.239 oder später und in der `/plugin`-Schnittstelle, aber nicht in der Inline-Ausgabe `/plugin list`.

1334* Plugins, die für die Sitzung mit `--plugin-dir` oder `--plugin-url` geladen werden, erscheinen in der `/plugin`-Schnittstelle und in `claude plugin list` nur, wenn das gleiche Flag dem Unterbefehl vorangeht, wie in `claude --plugin-dir <dir> plugin list`. Nur das Flag benennt ihren Standort, daher kann ein einfaches `claude plugin list` sie nicht finden, anders als synchronisierte Plugins und Skills-Directory-Plugins, deren feste Verzeichnisse Claude Code scannt.

~~1335~~

1336Die interaktive Form akzeptiert `--enabled` oder `--disabled`, um nur Plugins in diesem Zustand anzuzeigen, und `ls` als Kurzform für `list`.

~~1337~~

1338<h3 id="plugin-details">

1339 plugin details

1340</h3>

~~1341~~

1342Zeigen Sie das Komponenten-Inventar eines Plugins und die geschätzte Token-Kosten an. Die Ausgabe listet alle Komponenten auf, die das Plugin beiträgt, gruppiert als Skills, Agents, Hooks, MCP-Server und LSP-Server, zusammen mit einer Schätzung, wie viele Token es jeder Sitzung hinzufügt. Die Skills-Gruppe umfasst sowohl `skills/`- als auch `commands/`-Einträge.

~~1343~~

1344```bash theme={null}

1345claude plugin details <name>

1346```

~~1347~~

1348Der Befehl nimmt diese Argumente an:

~~1349~~

1350* `<name>`: Plugin-Name oder `plugin-name@marketplace-name`

~~1351~~

1352Der Befehl akzeptiert diese Optionen:

~~1353~~

1354| Option | Beschreibung | Standard |

1355| :----------- | :------------------------ | :------- |

1356| `-h, --help` | Hilfe für Befehl anzeigen | |

~~1357~~

1358Die Ausgabe zeigt zwei Kostenzahlen für jede Komponente:

~~1359~~

1360* **Always-on:** Token, die jeder Sitzung durch den Auflistungstext des Plugins hinzugefügt werden, wie Skill-Beschreibungen, Agent-Beschreibungen und Befehlsnamen, unabhängig davon, ob eine Komponente ausgelöst wird.

1361* **On-invoke:** Token, die eine Komponente kostet, wenn sie ausgelöst wird. Wird pro Komponente angezeigt, nicht als Plugin-Gesamtsumme, da eine typische Sitzung nur eine Teilmenge von Komponenten aufruft.

~~1362~~

1363Dieses Beispiel zeigt, wie die Ausgabe für ein Plugin mit zwei Skills aussieht:

~~1364~~

1365```

1366dependency-guard 1.2.0

1367 Dependency analysis for Claude Code sessions

1368 Source: dependency-guard@example-marketplace

~~1369~~

1370Component inventory

1371 Skills (2) scan-dependencies, review-changes

1372 Agents (0)

1373 Hooks (1) SessionStart (harness-only — no model context cost)

1374 MCP servers (0)

1375 LSP servers (0)

~~1376~~

1377Projected token cost

1378 Always-on: ~180 tok added to every session

~~1379~~

1380Per-component (rounded)

1381 component always-on on-invoke

1382 scan-dependencies ~100 ~2400

1383 review-changes ~80 ~1800

~~1384~~

1385 On-invoke cost is paid each time a skill or agent fires.

1386 Token counts are estimates and may differ from actual usage.

1387```

~~1388~~

1389Die Always-on-Gesamtsumme wird über die `count_tokens`-API für Ihr aktives Modell berechnet. Pro-Komponenten-Zahlen werden proportional von dieser Gesamtsumme skaliert. Wenn die API nicht erreichbar ist, greift der Befehl auf eine zeichenbasierte Schätzung zurück.

~~1390~~

1391<h3 id="plugin-validate">

1392 plugin validate

1393</h3>

~~1394~~

1395Überprüfen Sie ein Plugin oder einen Marketplace auf Syntax- und Schema-Fehler, bevor Sie veröffentlichen.

~~1396~~

1397Der Befehl beendet sich mit 0, wenn die Validierung erfolgreich ist, mit 1, wenn sie fehlschlägt, und mit 2, wenn der Validierungslauf selbst fehlschlägt, z. B. wenn der übergebene Pfad nicht lesbar ist.

~~1398~~

1399```bash theme={null}

1400claude plugin validate <path> [options]

1401```

~~1402~~

1403Der Befehl nimmt diese Argumente an:

~~1404~~

1405* `<path>`: Pfad zu einem Plugin-Verzeichnis oder einem Marketplace-Verzeichnis. Siehe [Validate a plugin or a directory without a manifest](/docs/de/plugin-marketplaces#validate-a-plugin-or-a-directory-without-a-manifest) für die Dateien, die ein Plugin-Lauf abdeckt.

~~1406~~

1407Der Befehl akzeptiert diese Optionen:

~~1408~~

1409| Option | Beschreibung | Standard |

1410| :----------- | :-------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :------- |

1411| `--strict` | Warnungen als Fehler behandeln und mit 1 beenden. Verwenden Sie in CI, um Probleme zu erfassen, die die Laufzeit toleriert, wie [unrecognized fields](#unrecognized-fields) | |

1412| `--json` | Geben Sie den Validierungsbericht als ein JSON-Objekt aus mit den gleichen Exit-Codes. Erfordert Claude Code v2.1.259 oder später | |

1413| `-h, --help` | Hilfe für Befehl anzeigen | |

~~1414~~

1415Mit `--json` schreibt Claude Code den Bericht auf stdout als ein JSON-Objekt mit diesen Top-Level-Feldern:

~~1416~~

1417* `success`: das gleiche Urteil, das der Exit-Code gibt

1418* `strict`: ob der Lauf Warnungen als Fehler behandelt hat

1419* `target`: der aufgelöste Pfad, den Claude Code validiert hat

1420* `manifest`: das eigene Ergebnis des Manifests oder `null` für einen [Lauf ohne Manifest](/docs/de/plugin-marketplaces#validate-a-plugin-or-a-directory-without-a-manifest)

1421* `contents`: Pro-Datei-Ergebnisse, jede benannt nach ihrer `file` und mit `errors`-, `warnings`- und `notes`-Arrays

~~1422~~

1423Bei Exit 2 schreibt der Befehl nichts auf stdout; die Fehlermeldung geht auf stderr.

~~1424~~

1425Innerhalb einer interaktiven Sitzung führt `/plugin validate <path>` die gleichen Überprüfungen inline aus.

~~1426~~

1427<h3 id="plugin-eval">

1428 plugin eval

1429</h3>

~~1430~~

1431Führen Sie die [eval cases](/docs/de/plugin-evals) eines Plugins aus und melden Sie bewertete Ergebnisse. Erfordert Claude Code v2.1.269 oder später. Jeder Fall ist ein Prompt plus Bewerter; 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, damit der Bericht den Unterschied zeigt. Siehe [Test plugins with evals](/docs/de/plugin-evals) für das Case-Format, Bewerter, Ergebnisse und CI-Nutzung.

~~1432~~

1433```bash theme={null}

1434claude plugin eval [target] [options]

1435```

~~1436~~

1437Das optionale `target` ist ein Plugin-Verzeichnis, eine einzelne `prompt.md`- oder `case.yaml`-Datei, ein installiertes Plugin als `name` oder `name@marketplace`, oder `name@skills-dir`, und standardmäßig das aktuelle Verzeichnis. Platzieren Sie es vor `--tag`, `--allow-tools` und `--json`.

~~1438~~

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

~~1440~~

1441| Option | Beschreibung | Standard |

1442| :------------------------- | :----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :---------------------------------------------------------------------------------------- |

1443| `--runs <n>` | Läufe pro Fall pro Arm | Jedes Case's `runs`, sonst 3 |

1444| `-j, --concurrency <n>` | Agent-Sitzungen, die gleichzeitig ausgeführt werden, 1 bis 8. Sie teilen Ihr Rate Limit | `1` |

1445| `--model <model>` | Modell für den getesteten Agent | Jedes Case's `model`, sonst `ANTHROPIC_MODEL` falls gesetzt, sonst Claude Code's Standard |

1446| `--judge-model <model>` | Modell für `llm`- und `baseline`-Bewerter | Ein kleines schnelles Modell |

1447| `--ablation <mode>` | `none` oder `with-without`. Siehe [Compare against a no-plugin baseline](/docs/de/plugin-evals#compare-against-a-no-plugin-baseline) | `with-without` wenn ein Plugin aufgelöst wird, sonst `none` |

1448| `--threshold <0..1>` | Beenden Sie mit 1, wenn ein Case unter diesem Wert bewertet wird | `1.0` |

1449| `--max-cost-usd <usd>` | Stoppen Sie vor dem nächsten Lauf, sobald die Ausgaben diesen Betrag erreichen, beenden Sie mit 2 und melden Sie Teilergebnisse | Keine Obergrenze |

1450| `--allow-tools <tools...>` | Gewähren Sie Tools über den schreibgeschützten Satz hinaus, wie `Bash`, `Write`, `Edit` oder `"mcp__plugin_<plugin>_<server>__*"`. Siehe [Grant tools](/docs/de/plugin-evals#grant-tools) | |

1451| `--scaffold` | Führen Sie das [`scaffold_script`](/docs/de/plugin-evals#add-setup-or-history-with-case-yaml) jedes Cases aus | Aus |

1452| `--trust-plugin` | Überspringen Sie die Vertrauensaufforderung beim ersten Lauf, für CI. Siehe [What a run can access](/docs/de/plugin-evals#security) | Aus |

1453| `--mocks <mode>` | `record` oder `off`. Siehe [Mock MCP servers](/docs/de/plugin-evals#mock-mcp-servers) | `record` |

1454| `--eval-dir <dir>` | Verzeichnis unter dem Plugin, das die Cases enthält | Das Manifest's `experimental.evals`, sonst `evals` |

1455| `--json [path]` | Drucken Sie das [result document](/docs/de/plugin-evals#json-result) auf stdout, oder schreiben Sie es in einen `.json`-Pfad | |

1456| `--no-publish` | Halten Sie den HTML-Bericht lokal | |

1457| `-h, --help` | Hilfe für Befehl anzeigen | |

~~1458~~

1459Der Befehl beendet sich mit 0, wenn jeder Fall den Schwellenwert erfüllt, mit 1 bei einem fehlgeschlagenen Fall, einem Ladefehler oder einem nicht vertrauenswürdigen Plugin-Verzeichnis, mit 2 bei einem Teillauf, mit 130 bei Unterbrechung und mit 143 bei Beendigung. Siehe [Run evals in CI](/docs/de/plugin-evals#run-evals-in-ci).

~~1460~~

1461<h3 id="plugin-eval-init">

1462 plugin eval init

1463</h3>

~~1464~~

1465Erstellen Sie eine Eval-Suite für das Plugin im aktuellen Verzeichnis. Erfordert Claude Code v2.1.269 oder später. In einem Terminal startet dies ein Authoring-Interview, das das Plugin liest, Cases und Bewerter vorschlägt, sie pilotiert und die Dateien schreibt. Mit `--bare` oder ohne Terminal schreibt es stattdessen eine leere Single-Case-Vorlage. Wenn Sie von einer interaktiven Claude Code-Sitzung aus ausgeführt werden, druckt es die Interview-Anweisungen für diese Sitzung, um sie zu befolgen, anstatt eine Vorlage zu schreiben. Siehe [Create your first eval suite](/docs/de/plugin-evals#create-your-first-eval-suite).

~~1466~~

1467```bash theme={null}

1468claude plugin eval init [name] [options]

1469```

~~1470~~

1471Das optionale `name` ist ein Case-Name: Das Interview benötigt keinen, während `--bare` und die No-Terminal-Vorlagenpfad ihn benötigen. Es akzeptiert diese Optionen:

~~1472~~

1473| Option | Beschreibung | Standard |

1474| :------------------ | :----------------------------------------------------------------------------------------- | :------------------------------------------------- |

1475| `--bare` | Schreiben Sie stattdessen ein leeres `prompt.md` und `graders/criteria.md` für `<name>` | |

1476| `-i, --interactive` | Erfordern Sie das Interview. Schlägt ohne Terminal fehl, anstatt eine Vorlage zu schreiben | |

1477| `--eval-dir <dir>` | Verzeichnis unter dem aktuellen Verzeichnis, um Cases hineinzuschreiben | Das Manifest's `experimental.evals`, sonst `evals` |

1478| `-h, --help` | Hilfe für Befehl anzeigen | |

~~1479~~

1480<h3 id="plugin-tag">

1481 plugin tag

1482</h3>

~~1483~~

1484Erstellen Sie ein Release-Git-Tag für ein Plugin. Standardmäßig taggt der Befehl das Plugin im aktuellen Verzeichnis; übergeben Sie einen Pfad, um ein Plugin an anderer Stelle zu taggen. Siehe [Tag plugin releases](/docs/de/plugin-dependencies#tag-plugin-releases-for-version-resolution).

~~1485~~

1486```bash theme={null}

1487claude plugin tag [path] [options]

1488```

~~1489~~

1490Der Befehl nimmt diese Argumente an:

~~1491~~

1492* `[path]`: Pfad zum Plugin-Verzeichnis. Standardmäßig das aktuelle Verzeichnis.

~~1493~~

1494Der Befehl akzeptiert diese Optionen:

~~1495~~

1496| Option | Beschreibung | Standard |

1497| :-------------------- | :----------------------------------------------------------------------------------------- | :------- |

1498| `--push` | Das Tag nach dem Erstellen zum Remote pushen | |

1499| `--dry-run` | Drucken Sie, was getaggt würde, ohne das Tag zu erstellen | |

1500| `-f, --force` | Das Tag erstellen, auch wenn der Working Tree schmutzig ist oder das Tag bereits existiert | |

1501| `-m, --message <msg>` | Tag-Anmerkungsnachricht. Verwenden Sie `%s` als Platzhalter für die Version | |

1502| `--remote <name>` | Remote zum Pushen mit `--push` | `origin` |

1503| `-h, --help` | Hilfe für Befehl anzeigen | |

~~1504~~

1505***

~~1506~~

1507<h2 id="debugging-and-development-tools">

1508 Debugging- und Entwicklungstools

1509</h2>

~~1510~~

1511<h3 id="debugging-commands">

1512 Debugging-Befehle

1513</h3>

~~1514~~

1515Verwenden Sie `claude --debug`, um Details zum Laden von Plugins anzuzeigen:

~~1516~~

1517Dies zeigt:

~~1518~~

1519* Welche Plugins geladen werden

1520* Alle Fehler in Plugin-Manifesten

1521* Registrierung von Skills, Agents und Hooks

1522* MCP-Server-Initialisierung

~~1523~~

1524<h3 id="common-issues">

1525 Häufige Probleme

1526</h3>

~~1527~~

1528| Problem | Ursache | Lösung |

1529| :---------------------------------- | :-------------------------------- | :----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |

1530| Plugin wird nicht geladen | Ungültige `plugin.json` | Führen Sie `claude plugin validate ./my-plugin` oder `/plugin validate ./my-plugin` aus, wobei `./my-plugin` Ihr Plugin-Verzeichnis ist, um `plugin.json`, `hooks/hooks.json` und die Frontmatter der Skills, Agents und Commands in den Standard-Verzeichnissen des Plugins auf Syntax- und Schema-Fehler zu überprüfen. Siehe [Plugin oder Verzeichnis ohne Manifest validieren](/docs/de/plugin-marketplaces#validate-a-plugin-or-a-directory-without-a-manifest), um zu erfahren, was eine Ausführung abdeckt |

1531| Skills werden nicht angezeigt | Falsche Verzeichnisstruktur | Stellen Sie sicher, dass `skills/` oder `commands/` sich im Plugin-Root befindet, nicht in `.claude-plugin/` |

1532| Hooks werden nicht ausgelöst | Skript ist nicht ausführbar | Führen Sie `chmod +x script.sh` aus |

1533| MCP-Server schlägt fehl | Fehlende `${CLAUDE_PLUGIN_ROOT}` | Verwenden Sie Variable für alle Plugin-Pfade |

1534| Pfadfehler | Absolute Pfade verwendet | Machen Sie Pfade relativ, beginnend mit `./`; siehe [Pfad-Verhaltensregeln](#path-behavior-rules), die die `"."` Ausnahme des `skills`-Feldes abdecken |

1535| LSP `Executable not found in $PATH` | Language Server nicht installiert | Installieren Sie die Binärdatei (z. B. `npm install -g typescript-language-server typescript`) |

~~1536~~

1537<h3 id="example-error-messages">

1538 Beispiel-Fehlermeldungen

1539</h3>

~~1540~~

1541**Manifest-Validierungsfehler**:

~~1542~~

1543* `Invalid JSON syntax: Unexpected token } in JSON at position 142`: Überprüfen Sie auf fehlende Kommas, zusätzliche Kommas oder nicht in Anführungszeichen gesetzte Strings

1544* `Plugin <name> has an invalid manifest file at .claude-plugin/plugin.json. Validation errors: name: Invalid input: expected string, received undefined`: Ein erforderliches Feld fehlt

1545* `Plugin <name> has a corrupt manifest file at .claude-plugin/plugin.json. JSON parse error: ...`: JSON-Syntaxfehler. Vor v2.1.246 erzeugte Claude Code diesen Fehler auch für eine `plugin.json`, die als UTF-8 mit einer führenden Byte-Order-Mark (BOM) gespeichert wurde, selbst wenn das JSON ansonsten gültig war.

~~1546~~

1547**Plugin-Ladefehler**:

~~1548~~

1549* `Warning: No commands found in plugin my-plugin custom directory: ./cmds. Expected .md files or SKILL.md in subdirectories.`: Befehlspfad existiert, enthält aber keine gültigen Befehlsdateien

1550* `Plugin directory not found at path: ./plugins/my-plugin. Check that the marketplace entry has the correct path.`: Der `source`-Pfad in marketplace.json verweist auf ein nicht vorhandenes Verzeichnis

1551* `Plugin my-plugin has conflicting manifests: both plugin.json and marketplace entry specify components.`: Entfernen Sie doppelte Komponentendefinitionen oder entfernen Sie `strict: false` im Marketplace-Eintrag

~~1552~~

1553<h3 id="hook-troubleshooting">

1554 Hook-Fehlerbehebung

1555</h3>

~~1556~~

1557**Hook-Skript wird nicht ausgeführt**:

~~1558~~

15591. Überprüfen Sie, dass das Skript ausführbar ist: `chmod +x ./scripts/your-script.sh`

15602. Überprüfen Sie die Shebang-Zeile: Die erste Zeile sollte `#!/bin/bash` oder `#!/usr/bin/env bash` sein

15613. Überprüfen Sie, dass der Pfad `${CLAUDE_PLUGIN_ROOT}` verwendet: `"command": "\"${CLAUDE_PLUGIN_ROOT}\"/scripts/your-script.sh"`

15624. Testen Sie das Skript manuell: `./scripts/your-script.sh`

~~1563~~

1564**Hook wird bei erwarteten Ereignissen nicht ausgelöst**:

~~1565~~

15661. Überprüfen Sie, dass der Ereignisname korrekt ist (Groß-/Kleinschreibung beachten): `PostToolUse`, nicht `postToolUse`

15672. Überprüfen Sie, dass das Matcher-Muster Ihre Tools entspricht: `"matcher": "Write|Edit"` für Dateivorgänge

15683. Bestätigen Sie, dass der Hook-Typ gültig ist: `command`, `http`, `mcp_tool`, `prompt` oder `agent`

~~1569~~

1570<h3 id="mcp-server-troubleshooting">

1571 MCP-Server-Fehlerbehebung

1572</h3>

~~1573~~

1574**Server startet nicht**:

~~1575~~

15761. Überprüfen Sie, dass der Befehl existiert und ausführbar ist

15772. Überprüfen Sie, dass alle Pfade die `${CLAUDE_PLUGIN_ROOT}` Variable verwenden

15783. Überprüfen Sie die MCP-Server-Protokolle: `claude --debug` zeigt Initialisierungsfehler

15794. Testen Sie den Server manuell außerhalb von Claude Code

~~1580~~

1581**Server-Tools werden nicht angezeigt**:

~~1582~~

15831. Stellen Sie sicher, dass der Server ordnungsgemäß in `.mcp.json` oder `plugin.json` konfiguriert ist

15842. Überprüfen Sie, dass der Server das MCP-Protokoll korrekt implementiert

15853. Überprüfen Sie auf Verbindungs-Timeouts in der Debug-Ausgabe

~~1586~~

1587<h3 id="directory-structure-mistakes">

1588 Fehler in der Verzeichnisstruktur

1589</h3>

~~1590~~

1591**Symptome**: Plugin wird geladen, aber Komponenten (Skills, Agents, Hooks) fehlen.

~~1592~~

1593**Korrekte Struktur**: Komponenten müssen sich im Plugin-Root befinden, nicht in `.claude-plugin/`. Nur `plugin.json` gehört in `.claude-plugin/`.

~~1594~~

1595**Debug-Checkliste**:

~~1596~~

15971. Führen Sie `claude --debug` aus und suchen Sie nach „loading plugin"-Meldungen

15982. Überprüfen Sie, dass jedes Komponenten-Verzeichnis in der Debug-Ausgabe aufgelistet ist

15993. Überprüfen Sie, dass Dateiberechtigungen das Lesen der Plugin-Dateien ermöglichen

~~1600~~

1601***

~~1602~~

1603<h2 id="distribution-and-versioning-reference">

1604 Verteilungs- und Versionierungsreferenz

1605</h2>

~~1606~~

1607<h3 id="version-management">

1608 Versionsverwaltung

1609</h3>

~~1610~~

1611Claude Code verwendet die Version des Plugins als Cache-Schlüssel, der bestimmt, ob ein Update verfügbar ist. Wenn Sie `/plugin update` ausführen oder Auto-Update aktiviert ist, berechnet Claude Code die aktuelle Version und überspringt das Update, wenn sie mit der bereits installierten Version übereinstimmt. Ein Plugin, das [an Ort und Stelle geladen](#plugin-caching-and-file-resolution) wird, aus einem lokalen Marketplace-Verzeichnis lädt seine aktuellen Quelldateien bei jedem Sitzungsstart, unabhängig davon, was die Versionsnummer sagt.

~~1612~~

1613Für jeden Quellentyp außer `command` löst Claude Code die Version aus dem ersten dieser Punkte auf, der gesetzt ist:

~~1614~~

16151. Das Feld `version` in der `plugin.json` des Plugins

16162. Das Feld `version` im Marketplace-Eintrag des Plugins in `marketplace.json`

16173. Der Git-Commit-SHA des Plugin-Quellcodes für `github`, `url`, `git-subdir` und relative-path-Quellen in einem Git-gehosteten Marketplace

16184. Der SHA-256-Digest für [`archive`-Quellen](/docs/de/plugin-marketplaces#zip-archives): der `sha256`-Pin im Marketplace-Eintrag oder der Digest der heruntergeladenen Datei, wenn Sie keinen Pin setzen. Claude Code kürzt ihn auf die ersten 12 Zeichen

16195. `unknown` für `npm`-Quellen oder lokale Verzeichnisse, die sich nicht in einem Git-Repository befinden. Claude Code nimmt die Version nicht aus einem Repository, das den Installationspfad umschließt, wie ein Git-verwaltetes `~/.claude`

~~1620~~

1621Für eine [`command`-Quelle](/docs/de/plugin-marketplaces#command-sources) leitet Claude Code die Version immer aus dem ab, was der Befehl produziert: einen 12-stelligen Content-Hash allein oder an die `plugin.json`-Version als `<version>-<hash>` angehängt, wenn einer gesetzt ist. Claude Code ignoriert das Feld `version` des Marketplace-Eintrags für Command-Quellen. Ein Befehl, dessen gehashte Ausgabe sich ändert, produziert daher eine neue Version, auch wenn die verfasste Versionsnummer gleich bleibt. Im [Link-Modus](/docs/de/plugin-marketplaces#copy-mode-and-link-mode) deckt der Hash den echten Pfad des gedruckten Verzeichnisses und seine Einträge auf oberster Ebene ab, anstatt der Dateiinhalte.

~~1622~~

1623Für diese Quellentypen gibt es drei Möglichkeiten, ein Plugin zu versionieren:

~~1624~~

1626| :--------------------- | :--------------------------------------------------------------------------------------------------------------------------------------------------------------- | :-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :--------------------------------------------------------------------------------------------------------------- |

1627| **Explizite Version** | Setzen Sie `"version": "2.1.0"` in `plugin.json` | Benutzer erhalten Updates nur, wenn Sie dieses Feld erhöhen. Das Pushen neuer Commits ohne Erhöhung hat keine Auswirkung, und `/plugin update` meldet „bereits auf der neuesten Version". Für ein Plugin, das [an Ort und Stelle geladen](#plugin-caching-and-file-resolution) wird, wird der neue Inhalt trotzdem geladen. | Veröffentlichte Plugins mit stabilen Release-Zyklen |

1628| **Commit-SHA-Version** | Lassen Sie `version` sowohl in `plugin.json` als auch im Marketplace-Eintrag weg | Benutzer erhalten Updates, wenn sich der aufgelöste Commit der Quelle ändert | Interne oder Team-Plugins unter aktiver Entwicklung |

1629| **Digest-Version** | Verwenden Sie eine [`archive`-Quelle](/docs/de/plugin-marketplaces#zip-archives) und lassen Sie `version` sowohl in `plugin.json` als auch im Marketplace-Eintrag weg | Mit einem `sha256`-Pin erhalten Benutzer Updates, wenn Sie den Pin ändern. Ohne einen erhalten Benutzer Updates, wenn sich die Bytes der gehosteten ZIP-Datei ändern | Plugins, die als ZIP-Dateien auf einem statischen Server oder in einem Artefakt-Repository veröffentlicht werden |

~~1630~~

1631Wenn Sie explizite Versionen verwenden, folgen Sie [semantischer Versionierung](https://semver.org) (`MAJOR.MINOR.PATCH`): erhöhen Sie MAJOR für Breaking Changes, MINOR für neue Funktionen, PATCH für Bugfixes. Dokumentieren Sie Änderungen in einer `CHANGELOG.md`.

~~1632~~

1633***

~~1634~~

1635<h2 id="see-also">

1636 Siehe auch

1637</h2>

~~1638~~

1639* [Plugins](/docs/de/plugins) - Tutorials und praktische Verwendung

1640* [Plugin-Marktplätze](/docs/de/plugin-marketplaces) - Erstellen und Verwalten von Marktplätzen

1641* [Skills](/docs/de/skills) - Skill-Entwicklungsdetails

1642* [Subagents](/docs/de/sub-agents) - Agent-Konfiguration und Fähigkeiten

1643* [Hooks](/docs/de/hooks) - Event-Handling und Automatisierung

1644* [MCP](/docs/de/mcp) - Integration externer Tools

1645* [Einstellungen](/docs/de/settings) - Konfigurationsoptionen für Plugins