> ## Documentation Index
> Fetch the complete documentation index at: https://code.claude.com/docs/llms.txt
> Use this file to discover all available pages before exploring further.
# Claude Code-Einstellungen
> Konfigurieren Sie Claude Code mit globalen und projektbezogenen Einstellungen sowie Umgebungsvariablen.
Claude Code bietet eine Vielzahl von Einstellungen, um sein Verhalten an Ihre Anforderungen anzupassen. Sie können Claude Code konfigurieren, indem Sie den Befehl `/config` ausführen, wodurch eine Einstellungsoberfläche mit Registerkarten geöffnet wird, auf der Sie Statusinformationen anzeigen und Konfigurationsoptionen ändern können. {/* min-version: 2.1.181 */}Ab v2.1.181 können Sie eine einzelne Option ändern, ohne die Oberfläche zu öffnen, indem Sie `key=value` an `/config` übergeben, zum Beispiel `/config verbose=true`.
Konfigurationsbereiche
Claude Code verwendet ein Bereichssystem, um zu bestimmen, wo Konfigurationen gelten und wer sie teilt. Das Verständnis von Bereichen hilft Ihnen zu entscheiden, wie Sie Claude Code für persönliche Nutzung, Teamzusammenarbeit oder Unternehmensbereitstellung konfigurieren.
Verfügbare Bereiche
| Bereich | Speicherort | Wer ist betroffen | Mit Team geteilt? |
| :------------ | :---------------------------------------------------------------------------------------- | :-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :------------------------------------------------ |
| **Verwaltet** | Serververwaltete Einstellungen, plist / Registry oder systemweite `managed-settings.json` | Alle Organisationsmitglieder für serververwaltete Bereitstellung; alle Benutzer auf dem Computer für plist, HKLM-Registry und Dateibereitstellung; der aktuelle Benutzer für HKCU-Registry-Bereitstellung | Ja (von IT bereitgestellt) |
| **Benutzer** | `~/.claude/` Verzeichnis | Sie, über alle Projekte hinweg | Nein |
| **Projekt** | `.claude/` im Repository | Alle Mitarbeiter in diesem Repository | Ja (in Git eingecheckt) |
| **Lokal** | `.claude/settings.local.json` | Sie, nur in diesem Repository | Nein (gitignoriert, wenn Claude Code es erstellt) |
Wann sollte jeder Bereich verwendet werden
Der **Verwaltungsbereich** ist für:
* Sicherheitsrichtlinien, die organisationsweit durchgesetzt werden müssen
* Compliance-Anforderungen, die nicht überschrieben werden können
* Standardisierte Konfigurationen, die von IT/DevOps bereitgestellt werden
Der **Benutzerbereich** ist am besten für:
* Persönliche Voreinstellungen, die Sie überall haben möchten (Designs, Editor-Einstellungen)
* Tools und Plugins, die Sie in allen Projekten verwenden
* API-Schlüssel und Authentifizierung (sicher gespeichert)
Der **Projektbereich** ist am besten für:
* Teamübergreifend gemeinsame Einstellungen (Berechtigungen, Hooks, MCP-Server)
* Plugins, die das gesamte Team haben sollte
* Standardisierung von Tools über Mitarbeiter hinweg
Der **lokale Bereich** ist am besten für:
* Persönliche Überschreibungen für ein bestimmtes Projekt
* Testen von Konfigurationen vor dem Teilen mit dem Team
* Maschinenspezifische Einstellungen, die für andere nicht funktionieren
Wie Bereiche interagieren
Wenn die gleiche Einstellung in mehreren Bereichen konfiguriert ist, wendet Claude Code sie in Prioritätsreihenfolge an:
1. **Verwaltet** (höchste): kann von nichts überschrieben werden
2. **Befehlszeilenargumente**: temporäre Sitzungsüberschreibungen
3. **Lokal**: überschreibt Projekt- und Benutzereinstellungen
4. **Projekt**: überschreibt Benutzereinstellungen
5. **Benutzer** (niedrigste): gilt, wenn nichts anderes die Einstellung angibt
Wenn beispielsweise Ihre Benutzereinstellungen `spinnerTipsEnabled` auf `true` setzen und Projekteinstellungen es auf `false` setzen, gilt der Projektwert. Berechtigungsregeln verhalten sich anders, da sie über Bereiche hinweg zusammengeführt werden, anstatt sich zu überschreiben. Siehe [Einstellungspriorität](#settings-precedence).
Was verwendet Bereiche
Bereiche gelten für viele Claude Code-Funktionen:
| Funktion | Benutzerort | Projektort | Lokaler Ort |
| :---------------- | :------------------------ | :----------------------------------- | :----------------------------- |
| **Einstellungen** | `~/.claude/settings.json` | `.claude/settings.json` | `.claude/settings.local.json` |
| **Subagents** | `~/.claude/agents/` | `.claude/agents/` | Keine |
| **MCP-Server** | `~/.claude.json` | `.mcp.json` | `~/.claude.json` (pro Projekt) |
| **Plugins** | `~/.claude/settings.json` | `.claude/settings.json` | `.claude/settings.local.json` |
| **CLAUDE.md** | `~/.claude/CLAUDE.md` | `CLAUDE.md` oder `.claude/CLAUDE.md` | `CLAUDE.local.md` |
Unter Windows werden Pfade, die als `~/.claude` angezeigt werden, zu `%USERPROFILE%\.claude` aufgelöst.
***
Einstellungsdateien
Die Datei `settings.json` ist der offizielle Mechanismus zur Konfiguration von Claude Code durch hierarchische Einstellungen:
* **Benutzereinstellungen** werden in `~/.claude/settings.json` definiert und gelten für alle Projekte.
* **Projekteinstellungen** werden in Ihrem Projektverzeichnis gespeichert:
* `.claude/settings.json` für Einstellungen, die in die Versionskontrolle eingecheckt und mit Ihrem Team geteilt werden
* `.claude/settings.local.json` für Einstellungen, die nicht eingecheckt werden, nützlich für persönliche Voreinstellungen und Experimente. Wenn Claude Code `.claude/settings.local.json` erstellt, konfiguriert es Git so, dass die Datei ignoriert wird. Wenn Sie die Datei selbst erstellen, fügen Sie sie manuell zu Ihrer gitignore hinzu.
Da diese Datei Ihnen gehört und nicht dem Repository, werden ihre Berechtigungsregeln `allow` ohne den [Workspace-Trust](/docs/de/permissions#project-allow-rules-and-workspace-trust)-Schritt wirksam, den `allow`-Regeln in `.claude/settings.json` erfordern. Wenn das Repository die Datei bereitstellt, z. B. durch Committen, gilt Workspace-Trust weiterhin.
* **Verwaltete Einstellungen**: Für Organisationen, die zentrale Kontrolle benötigen, unterstützt Claude Code mehrere Bereitstellungsmechanismen für verwaltete Einstellungen. Alle verwenden das gleiche JSON-Format und können nicht durch Benutzer- oder Projekteinstellungen überschrieben werden:
* **Serververwaltete Einstellungen**: von Anthropics Servern über die Claude.ai-Administratorkonsole bereitgestellt oder von einem selbstgehosteten [Claude-Apps-Gateway](/docs/de/claude-apps-gateway). Siehe [Serververwaltete Einstellungen](/docs/de/server-managed-settings).
* **MDM/OS-Richtlinien**: über native Geräteverwaltung auf macOS und Windows bereitgestellt:
* macOS: `com.anthropic.claudecode` verwaltete Präferenzdomäne. Die Schlüssel der obersten Ebene der plist spiegeln `managed-settings.json` wider, mit verschachtelten Einstellungen als Wörterbücher und Arrays als plist-Arrays. Bereitstellung über Konfigurationsprofile in Jamf, Iru (Kandji) oder ähnlichen MDM-Tools.
* Windows: `HKLM\SOFTWARE\Policies\ClaudeCode` Registrierungsschlüssel mit einem `Settings`-Wert (REG\_SZ oder REG\_EXPAND\_SZ) mit JSON (bereitgestellt über Gruppenrichtlinie oder Intune)
* Windows (Benutzerebene): `HKCU\SOFTWARE\Policies\ClaudeCode` (niedrigste Richtlinienpriorität, wird nur verwendet, wenn keine Admin-Quelle vorhanden ist)
* **Dateibasiert**: `managed-settings.json` und `managed-mcp.json` in Systemverzeichnissen bereitgestellt:
* macOS: `/Library/Application Support/ClaudeCode/`
* Linux und WSL: `/etc/claude-code/`
* Windows: `C:\Program Files\ClaudeCode\`
Der veraltete Windows-Pfad `C:\ProgramData\ClaudeCode\managed-settings.json` wird ab v2.1.75 nicht mehr unterstützt. Administratoren, die Einstellungen an diesem Speicherort bereitgestellt haben, müssen Dateien zu `C:\Program Files\ClaudeCode\managed-settings.json` migrieren.
Dateibasierte verwaltete Einstellungen unterstützen auch ein Drop-in-Verzeichnis unter `managed-settings.d/` im gleichen Systemverzeichnis neben `managed-settings.json`. Dies ermöglicht es separaten Teams, unabhängige Richtlinienfragmente bereitzustellen, ohne Änderungen an einer einzelnen Datei zu koordinieren.
Nach der systemd-Konvention wird `managed-settings.json` zuerst als Basis zusammengeführt, dann werden alle `*.json`-Dateien im Drop-in-Verzeichnis alphabetisch sortiert und oben zusammengeführt. Spätere Dateien überschreiben frühere für Skalarwerte; Arrays werden verkettet und dedupliziert; Objekte werden tiefgreifend zusammengeführt. Versteckte Dateien, die mit `.` beginnen, werden ignoriert.
Verwenden Sie numerische Präfixe, um die Zusammenführungsreihenfolge zu steuern, z. B. `10-telemetry.json` und `20-security.json`.
Siehe [Verwaltete Einstellungen](/docs/de/permissions#managed-only-settings) und [Verwaltete MCP-Konfiguration](/docs/de/managed-mcp) für Details.
Dieses [Repository](https://github.com/anthropics/claude-code/tree/main/examples/mdm) enthält Starter-Bereitstellungsvorlagen für Jamf, Iru (Kandji), Intune und Gruppenrichtlinie. Verwenden Sie diese als Ausgangspunkte und passen Sie sie an Ihre Anforderungen an.
Verwaltete Bereitstellungen können auch **Plugin-Marketplace-Ergänzungen** mit `strictKnownMarketplaces` einschränken. Weitere Informationen finden Sie unter [Verwaltete Marketplace-Einschränkungen](/docs/de/plugin-marketplaces#managed-marketplace-restrictions).
* **Andere Konfiguration** wird in `~/.claude.json` gespeichert. Diese Datei enthält Ihre OAuth-Sitzung, [MCP-Server](/docs/de/mcp)-Konfigurationen für Benutzer- und lokale Bereiche, projektbezogenen Status (zulässige Tools, Vertrauenseinstellungen) und verschiedene Caches. Projektbezogene MCP-Server werden separat in `.mcp.json` gespeichert.
Claude Code erstellt automatisch zeitgestempelte Sicherungen von Konfigurationsdateien und behält die fünf neuesten Sicherungen bei, um Datenverlust zu verhindern.
```JSON Beispiel settings.json theme={null}
{
"$schema": "https://json.schemastore.org/claude-code-settings.json",
"permissions": {
"allow": [
"Bash(npm run lint)",
"Bash(npm run test *)",
"Read(~/.zshrc)"
],
"deny": [
"Bash(curl *)",
"Read(./.env)",
"Read(./.env.*)",
"Read(./secrets/**)"
]
},
"env": {
"CLAUDE_CODE_ENABLE_TELEMETRY": "1",
"OTEL_METRICS_EXPORTER": "otlp"
},
"companyAnnouncements": [
"Welcome to Acme Corp! Review our code guidelines at docs.acme.com",
"Reminder: Code reviews required for all PRs",
"New security policy in effect"
]
}
```
Die Zeile `$schema` im obigen Beispiel verweist auf das [offizielle JSON-Schema](https://json.schemastore.org/claude-code-settings.json) für Claude Code-Einstellungen. Das Hinzufügen zu Ihrer `settings.json` ermöglicht Autovervollständigung und Inline-Validierung in VS Code, Cursor und jedem anderen Editor, der JSON-Schema-Validierung unterstützt.
Das veröffentlichte Schema wird regelmäßig aktualisiert und enthält möglicherweise keine Einstellungen, die in den neuesten CLI-Versionen hinzugefügt wurden. Eine Validierungswarnung zu einem kürzlich dokumentierten Feld bedeutet daher nicht unbedingt, dass Ihre Konfiguration ungültig ist.
Wenn Änderungen wirksam werden
Claude Code überwacht Ihre Einstellungsdateien und lädt sie neu, wenn sie sich ändern, sodass Änderungen an den meisten Schlüsseln ohne Neustart auf die laufende Sitzung angewendet werden. Dies umfasst `permissions`, `hooks` und Anmeldedaten-Helper wie `apiKeyHelper`. Das Neuladen umfasst Benutzer-, Projekt-, lokale und verwaltete Einstellungen, und der [`ConfigChange` Hook](/docs/de/hooks#configchange) wird für jede erkannte Änderung ausgelöst.
Einige wenige Schlüssel werden einmal beim Sitzungsstart gelesen und gelten stattdessen beim nächsten Neustart:
* `model`: Verwenden Sie [`/model`](/docs/de/model-config#setting-your-model), um während der Sitzung zu wechseln
* [`outputStyle`](/docs/de/output-styles): Teil der Systemaufforderung, die beim `/clear` oder Neustart neu erstellt wird
Ungültige Einträge in verwalteten Einstellungen
Verwaltete Einstellungen werden tolerant analysiert. Wenn eine verwaltete Konfiguration einen Eintrag enthält, der die Schema-Validierung nicht besteht, entfernt Claude Code diesen Eintrag, zeichnet eine Warnung auf und erzwingt jede verbleibende gültige Richtlinie. Ein einzelner Tippfehler kann nicht die restliche Organisationsrichtlinie deaktivieren. Führen Sie [`/doctor`](/docs/de/debug-your-config#check-resolved-settings) aus, um entfernte Einträge mit ihrer Quelldatei und ihrem Feld aufzulisten.
Dieses Verhalten ist konsistent über alle drei Bereitstellungsmechanismen: [Serververwaltete Einstellungen](/docs/de/server-managed-settings), plist- und Registry-Richtlinien, die über MDM bereitgestellt werden, und `managed-settings.json`-Dateien. Erfordert Claude Code v2.1.169 oder später.
Sicherheitsdurchsetzungsfelder werden pro Feld behandelt, anstatt vollständig entfernt zu werden, wenn sie vorhanden, aber ungültig sind:
| Feld | Verhalten, wenn vorhanden, aber ungültig |
| :--------------------------- | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `allowedMcpServers` | Erzwungen als leere Allowlist, sodass keine MCP-Server zulässig sind, bis der Wert behoben ist. Ein einzelner ungültiger Eintrag wird entfernt und die gültige Teilmenge wird erzwungen. |
| `allowManagedMcpServersOnly` | Behandelt als `true`. |
| `availableModels` | {/* min-version: 2.1.175 */}Erzwungen als leere Allowlist, sodass nur das Standardmodell verfügbar ist, bis der Wert behoben ist. Ein einzelner Nicht-String-Eintrag wird entfernt und die gültige Teilmenge wird erzwungen. Gilt in v2.1.175 und später. |
| `enforceAvailableModels` | {/* min-version: 2.1.175 */}Behandelt als `true`. Gilt in v2.1.175 und später. |
| `forceLoginOrgUUID` | Keine Organisation darf sich anmelden, bis der Wert behoben ist. |
| `deniedMcpServers` | Ein einzelner ungültiger Eintrag wird entfernt und die gültige Teilmenge wird erzwungen. Ein vollständig ungültiger Wert wird mit einer Warnung verworfen, da das Verweigern aller Server Server blockieren würde, die die Richtlinie nie benannt hat. |
| `sandbox.credentials` | {/* min-version: 2.1.191 */}Ein einzelner ungültiger Eintrag in `files` oder `envVars` wird mit einer Warnung entfernt und die gültige Teilmenge wird erzwungen. Ein vollständig ungültiger `credentials`-Wert wird mit einer Warnung verworfen, während der Rest von `sandbox` weiterhin gilt. Gilt in v2.1.191 und später. |
`requiredMinimumVersion` und `requiredMaximumVersion` schlagen offen fehl: Ein ungültiger Wert wird entfernt, anstatt erzwungen zu werden, sodass ein schlechter Richtlinien-Push Claude Code nicht am Starten hindern kann.
Validierungsfehler werden an drei Stellen angezeigt:
* Interaktive Sitzungen zeigen beim Start einen Dialog mit den ungültigen Einträgen an.
* Headless-Läufe mit `-p` drucken eine Zusammenfassung zu stderr.
* [`claude doctor`](/docs/de/debug-your-config) listet jeden ungültigen Eintrag mit seiner Quelle und seinem Feld auf.
Validieren Sie Richtlinienänderungen, indem Sie `claude doctor` auf einem Test-Computer ausführen, bevor Sie sie unternehmensweite bereitstellen.
Diese Toleranz gilt nur für verwaltete Einstellungen. Benutzer-, Projekt- und lokale Einstellungsdateien bleiben streng: Eine Datei, die die Validierung nicht besteht, wird als Ganzes abgelehnt und gemeldet.
Verfügbare Einstellungen
`settings.json` unterstützt eine Reihe von Optionen:
| Schlüssel | Beschreibung | Beispiel |
| :--------------------------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :------------------------------------------------------------------------------------------------------------------------------- |
| `advisorModel` | Modell für das serverseitige [Advisor-Tool](/docs/de/advisor). Akzeptiert einen Modellalias wie `"opus"`, `"sonnet"` oder `"fable"` ({/* min-version: 2.1.170 */}v2.1.170+) oder eine vollständige Modell-ID. Wird automatisch geschrieben, wenn Sie `/advisor` ausführen. Nicht gesetzt, um den Advisor zu deaktivieren | `"opus"` |
| `agent` | Führen Sie den Haupt-Thread als benannten Subagent aus und legen Sie den Standard-Agent für Sitzungen fest, die von `claude agents` versendet werden. Wendet den Systemaufforderung, die Werkzeugbeschränkungen und das Modell des Subagent an. Siehe [Rufen Sie Subagents explizit auf](/docs/de/sub-agents#invoke-subagents-explicitly) | `"code-reviewer"` |
| `agentPushNotifEnabled` | {/* min-version: 2.1.119 */}**Standard**: `false`. Wenn [Remote Control](/docs/de/remote-control) verbunden ist, erlauben Sie Claude, proaktive Push-Benachrichtigungen an Ihr Telefon zu senden, z. B. wenn eine lange Aufgabe endet. Wird in `/config` als **Push when Claude decides** angezeigt. Siehe [Mobile Push-Benachrichtigungen](/docs/de/remote-control#mobile-push-notifications). Erfordert Claude Code v2.1.119 oder später | `true` |
| `allowAllClaudeAiMcps` | (Nur verwaltete Einstellungen) Laden Sie claude.ai-Konnektoren neben einer bereitgestellten `managed-mcp.json` auf, die ansonsten exklusive Kontrolle übernimmt und diese unterdrückt. Siehe [Verwaltete MCP-Konfiguration](/docs/de/managed-mcp) | `true` |
| `allowedChannelPlugins` | (Nur verwaltete Einstellungen) Allowlist von Channel-Plugins, die Nachrichten pushen dürfen. Ersetzt die Standard-Anthropic-Allowlist, wenn gesetzt. Undefined = auf Standard zurückfallen, leeres Array = alle Channel-Plugins blockieren. Erfordert `channelsEnabled: true`. Siehe [Einschränken Sie, welche Channel-Plugins ausgeführt werden können](/docs/de/channels#restrict-which-channel-plugins-can-run) | `[{ "marketplace": "claude-plugins-official", "plugin": "telegram" }]` |
| `allowedHttpHookUrls` | Allowlist von URL-Mustern, auf die HTTP-Hooks abzielen können. Unterstützt `*` als Platzhalter. Wenn gesetzt, werden Hooks mit nicht übereinstimmenden URLs blockiert. Undefined = keine Einschränkung, leeres Array = alle HTTP-Hooks blockieren. Arrays werden über Einstellungsquellen zusammengeführt. Siehe [Hook-Konfiguration](#hook-configuration) | `["https://hooks.example.com/*"]` |
| `allowedMcpServers` | Wenn in managed-settings.json gesetzt, Allowlist von MCP-Servern, die Benutzer konfigurieren können. Undefined = keine Einschränkungen, leeres Array = Lockdown. Gilt für alle Bereiche. Denylist hat Vorrang. Siehe [Verwaltete MCP-Konfiguration](/docs/de/managed-mcp) | `[{ "serverName": "github" }]` |
| `allowManagedHooksOnly` | (Nur verwaltete Einstellungen) Nur verwaltete Hooks, SDK-Hooks und Hooks von Plugins, die in verwalteten Einstellungen `enabledPlugins` erzwungen aktiviert sind, werden geladen. Benutzer-, Projekt- und alle anderen Plugin-Hooks werden blockiert. Siehe [Hook-Konfiguration](#hook-configuration) | `true` |
| `allowManagedMcpServersOnly` | (Nur verwaltete Einstellungen) Nur `allowedMcpServers` aus verwalteten Einstellungen werden berücksichtigt. `deniedMcpServers` wird weiterhin aus allen Quellen zusammengeführt. Benutzer können weiterhin MCP-Server hinzufügen, aber nur die von Admin definierte Allowlist gilt. Siehe [Verwaltete MCP-Konfiguration](/docs/de/managed-mcp) | `true` |
| `allowManagedPermissionRulesOnly` | (Nur verwaltete Einstellungen) Verhindern Sie, dass Benutzer- und Projekteinstellungen `allow`, `ask` oder `deny` Berechtigungsregeln definieren. Nur Regeln in verwalteten Einstellungen gelten. Siehe [Nur verwaltete Einstellungen](/docs/de/permissions#managed-only-settings) | `true` |
| `alwaysThinkingEnabled` | Aktivieren Sie [erweitertes Denken](/docs/de/model-config#extended-thinking) standardmäßig für alle Sitzungen. Normalerweise über den Befehl `/config` konfiguriert, anstatt direkt zu bearbeiten. Um das Denken unabhängig von dieser Einstellung auszuschalten, setzen Sie [`MAX_THINKING_TOKENS=0`](/docs/de/env-vars) in `env`, was das Denken auf der Anthropic API deaktiviert, außer auf Fable 5, das Denken nicht ausschalten kann. Bei [Drittanbieter-Providern](/docs/de/third-party-integrations) wird stattdessen der `thinking`-Parameter weggelassen, und adaptive-reasoning-Modelle können weiterhin denken | `true` |
| `apiKeyHelper` | Benutzerdefiniertes Skript, das in `/bin/sh` auf macOS und Linux oder `cmd` auf Windows ausgeführt werden soll, um einen Auth-Wert zu generieren. Dieser Wert wird als `X-Api-Key` und `Authorization: Bearer` Header für Modellanfragen gesendet. Setzen Sie das Aktualisierungsintervall mit [`CLAUDE_CODE_API_KEY_HELPER_TTL_MS`](/docs/de/env-vars) | `/bin/generate_temp_api_key.sh` |
| `askUserQuestionTimeout` | {/* min-version: 2.1.200 */}**Standard**: `"never"`. Leerlaufzeit vor einer unbeantworteten [`AskUserQuestion`](/docs/de/tools-reference) Dialog, der automatisch mit den bereits ausgewählten Optionen fortfährt. Akzeptiert `"60s"`, `"5m"`, `"10m"` oder `"never"`. Mit dem Standard warten Fragen, bis Sie sie beantworten. Wird in `/config` als **Question auto-continue timeout** angezeigt, das diesen Schlüssel in Benutzereinstellungen schreibt. Nicht aus Projekt- oder lokalen Einstellungen gelesen. Erfordert Claude Code v2.1.200 oder später | `"5m"` |
| `attribution` | Passen Sie die Zuschreibung für Git-Commits und Pull Requests an. Siehe [Zuschreibungseinstellungen](#attribution-settings) | `{"commit": "🤖 Generated with Claude Code", "pr": ""}` |
| `autoCompactEnabled` | {/* min-version: 2.1.119 */}**Standard**: `true`. Komprimieren Sie das Gespräch automatisch, wenn sich der Kontext dem Limit nähert. Wird in `/config` als **Auto-compact** angezeigt. Um dies über eine Umgebungsvariable zu deaktivieren, setzen Sie [`DISABLE_AUTO_COMPACT`](/docs/de/env-vars) in `env` | `false` |
| `autoMemoryDirectory` | Benutzerdefiniertes Verzeichnis für [automatisches Speichern](/docs/de/memory#storage-location). Akzeptiert einen absoluten Pfad oder einen `~/`-erweiterten Pfad. Aus Projekt- oder lokalen Einstellungen wird dies nur berücksichtigt, nachdem Sie den Workspace-Trust-Dialog akzeptieren, da ein geklontes Repository diese Datei bereitstellen kann | `"~/my-memory-dir"` |
| `autoMemoryEnabled` | **Standard**: `true`. Aktivieren Sie [automatisches Speichern](/docs/de/memory#enable-or-disable-auto-memory). Wenn `false`, liest Claude nicht aus dem oder schreibt nicht in das automatische Speicherverzeichnis. Sie können dies auch während einer Sitzung mit `/memory` umschalten. Um dies über eine Umgebungsvariable zu deaktivieren, setzen Sie [`CLAUDE_CODE_DISABLE_AUTO_MEMORY`](/docs/de/env-vars) in `env` | `false` |
| `autoMode` | Passen Sie an, was der [Auto-Modus](/docs/de/permission-modes#eliminate-prompts-with-auto-mode)-Klassifizierer blockiert und erlaubt. Enthält `environment`, `allow`, `soft_deny` und `hard_deny` Arrays von Prosa-Regeln. Schließen Sie die Literalzeichenkette `"$defaults"` in ein Array ein, um die integrierten Regeln an dieser Position zu erben. Siehe [Konfigurieren Sie den Auto-Modus](/docs/de/auto-mode-config). Nur aus Benutzereinstellungen, dem Flag `--settings` und verwalteten Einstellungen gelesen. Ignoriert in Projekt `.claude/settings.json` und lokal `.claude/settings.local.json`. {/* min-version: 2.1.207 */}Vor v2.1.207 wurde `.claude/settings.local.json` auch gelesen | `{"soft_deny": ["$defaults", "Never run terraform apply"]}` |
| `autoMode.classifyAllShell` | {/* min-version: 2.1.193 */}**Standard**: `false`. Wenn `true`, setzt dies alle Bash- und PowerShell-Allow-Regeln aus, während der Auto-Modus aktiv ist, sodass alle Shell-Befehle durch den Klassifizierer geleitet werden, nicht nur Regeln, die willkürlichen Code-Ausführungsmustern entsprechen. Siehe [Leiten Sie alle Shell-Befehle durch den Klassifizierer](/docs/de/auto-mode-config#route-all-shell-commands-through-the-classifier). Erfordert Claude Code v2.1.193 oder später | `true` |
| `autoScrollEnabled` | **Standard**: `true`. Im [Fullscreen-Rendering](/docs/de/fullscreen) folgen Sie neuer Ausgabe zum unteren Ende des Gesprächs. Wird in `/config` als **Auto-scroll** angezeigt. Berechtigungsaufforderungen scrollen weiterhin in die Ansicht, wenn dies ausgeschaltet ist | `false` |
| `autoUpdatesChannel` | **Standard**: `"latest"`. Release-Kanal zum Folgen von Updates. Verwenden Sie `"stable"` für eine Version, die normalerweise etwa eine Woche alt ist und Versionen mit großen Regressionen überspringt, oder `"latest"` für die neueste Version. Um Auto-Updates vollständig zu deaktivieren, setzen Sie [`DISABLE_AUTOUPDATER`](/docs/de/setup#disable-auto-updates) in `env` | `"stable"` |
| `availableModels` | Beschränken Sie, welche Modelle Benutzer für die Hauptsitzung, [Subagents](/docs/de/sub-agents), [Skills](/docs/de/skills) und den [Advisor](/docs/de/advisor) auswählen können. Beeinflusst nicht die Standardoption, es sei denn, `enforceAvailableModels` ist auch gesetzt. Siehe [Modellauswahl einschränken](/docs/de/model-config#restrict-model-selection) | `["sonnet", "haiku"]` |
| `awaySummaryEnabled` | Zeigen Sie eine einzeilige Sitzungszusammenfassung an, wenn Sie nach einigen Minuten zur Befehlszeile zurückkehren. Setzen Sie auf `false` oder deaktivieren Sie Sitzungszusammenfassung in `/config`, um zu deaktivieren. Gleich wie [`CLAUDE_CODE_ENABLE_AWAY_SUMMARY`](/docs/de/env-vars) | `true` |
| `awsAuthRefresh` | Benutzerdefiniertes Skript, das das `.aws`-Verzeichnis ändert (siehe [erweiterte Anmeldedatenkonfiguration](/docs/de/amazon-bedrock#advanced-credential-configuration)) | `aws sso login --profile myprofile` |
| `awsCredentialExport` | Benutzerdefiniertes Skript, das JSON mit AWS-Anmeldedaten ausgibt (siehe [erweiterte Anmeldedatenkonfiguration](/docs/de/amazon-bedrock#advanced-credential-configuration)) | `/bin/generate_aws_grant.sh` |
| `axScreenReader` | {/* min-version: 2.1.181 */}Rendern Sie bildschirmleserfreundliche Ausgabe: flacher Text ohne dekorative Rahmen oder Animationen. Der Bildschirmleser-Modus verwendet immer den klassischen Renderer, daher hat die `tui`-Einstellung keine Auswirkung, während er aktiv ist. Angehängte [Hintergrund-Sitzungen](/docs/de/agent-view) werden weiterhin im Vollbildmodus gerendert. Die Umgebungsvariable [`CLAUDE_AX_SCREEN_READER`](/docs/de/env-vars) und das Flag [`--ax-screen-reader`](/docs/de/cli-reference#cli-flags) haben Vorrang. Erfordert Claude Code v2.1.181 oder später | `true` |
| `blockedMarketplaces` | (Nur verwaltete Einstellungen) Blocklist von Marketplace-Quellen. Erzwungen bei Marketplace-Hinzufügung und bei Plugin-Installation, Update, Aktualisierung und Auto-Update, sodass ein Marketplace, der vor dem Setzen der Richtlinie hinzugefügt wurde, nicht zum Abrufen von Plugins verwendet werden kann. Blockierte Quellen werden vor dem Download überprüft, sodass sie das Dateisystem nie berühren. Siehe [Verwaltete Marketplace-Einschränkungen](/docs/de/plugin-marketplaces#managed-marketplace-restrictions) | `[{ "source": "github", "repo": "untrusted/plugins" }]` |
| `browserExternalPageTools` | (Nur verwaltete Einstellungen) Setzen Sie auf `"disabled"`, um zu verhindern, dass Claude Tools verwendet, um externe Seiten im [Browser-Bereich](/docs/de/desktop#browse-external-sites) der Desktop-App zu lesen oder zu bearbeiten. Benutzer können weiterhin selbst zu externen Seiten navigieren, und lokale Dev-Server-Vorschau sind nicht betroffen | `"disabled"` |
| `channelsEnabled` | (Nur verwaltete Einstellungen) Erlauben Sie [Kanäle](/docs/de/channels) für die Organisation. Bei Claude.ai Team- und Enterprise-Plänen werden Kanäle blockiert, wenn dies nicht gesetzt oder `false` ist. Für [Anthropic Console](/docs/de/authentication#claude-console-authentication)-Konten mit API-Schlüssel-Authentifizierung sind Kanäle standardmäßig zulässig, es sei denn, Ihre Organisation stellt verwaltete Einstellungen bereit. In diesem Fall muss dieser Schlüssel auf `true` gesetzt werden | `true` |
| `claudeMd` | (Nur verwaltete Einstellungen) CLAUDE.md-ähnliche Anweisungen, die als organisationsverwalteter Speicher eingespritzt werden. Wird nur berücksichtigt, wenn in verwalteten oder Richtlinieneinstellungen gesetzt, und ignoriert in Benutzer-, Projekt- und lokalen Einstellungen. Siehe [organisationsweite CLAUDE.md](/docs/de/memory#deploy-organization-wide-claude-md) | `"Always run make lint before committing."` |
| `claudeMdExcludes` | Glob-Muster oder absolute Pfade von `CLAUDE.md`-Dateien, die beim Laden von [Speicher](/docs/de/memory) übersprungen werden sollen. Muster werden gegen absolute Dateipfade abgeglichen. Gilt nur für Benutzer-, Projekt- und lokalen Speicher; verwaltete Richtliniendateien können nicht ausgeschlossen werden | `["**/vendor/**/CLAUDE.md"]` |
| `cleanupPeriodDays` | **Standard**: `30` Tage, Minimum `1`. Claude Code löscht [Sitzungsdateien und andere Anwendungsdaten](/docs/de/claude-directory#cleaned-up-automatically), die älter als dieser Zeitraum sind, beim Start. Das Setzen auf `0` wird mit einem Validierungsfehler abgelehnt. Der gleiche Altersgrenzwert gilt für die automatische Entfernung von [verwaisten Worktrees](/docs/de/worktrees#clean-up-worktrees) beim Start. {/* min-version: 2.1.203 */}Wenn Claude Code eine Einstellungsdatei nicht lesen oder analysieren kann, pausiert es die Aufbewahrungsbereinigung und zeigt eine Warnung in `/status` an, bis Sie die Datei beheben, es sei denn, [verwaltete Einstellungen](/docs/de/server-managed-settings) stellen `cleanupPeriodDays` bereit. In diesem Fall wird die Bereinigung beim verwalteten Wert ausgeführt. Vor v2.1.203 wurde die Bereinigung beim 30-Tage-Standard ausgeführt und konnte Transkripte löschen, die ein längeres `cleanupPeriodDays` behalten sollte; Dateien, die neuer als 30 Tage waren, wurden nie entfernt. Um Transkriptschreibvorgänge vollständig zu deaktivieren, setzen Sie die Umgebungsvariable [`CLAUDE_CODE_SKIP_PROMPT_HISTORY`](/docs/de/env-vars). Im nicht-interaktiven Modus übergeben Sie `--no-session-persistence` neben `-p` oder setzen Sie `persistSession: false` im Agent SDK. | `20` |
| `companyAnnouncements` | Ankündigung, die Benutzern beim Start angezeigt werden soll. Wenn mehrere Ankündigungen bereitgestellt werden, werden sie zufällig durchlaufen. | `["Welcome to Acme Corp! Review our code guidelines at docs.acme.com"]` |
| `defaultShell` | **Standard**: `"bash"`, oder `"powershell"` unter Windows, wenn Bash nicht verfügbar ist. Standard-Shell für Input-Box `!` Befehle. Akzeptiert `"bash"` oder `"powershell"`. Das Setzen auf `"powershell"` leitet interaktive `!` Befehle über PowerShell unter Windows. Erfordert `CLAUDE_CODE_USE_POWERSHELL_TOOL=1`. Siehe [PowerShell-Tool](/docs/de/tools-reference#powershell-tool) | `"powershell"` |
| `deniedMcpServers` | Wenn in managed-settings.json gesetzt, Denylist von MCP-Servern, die explizit blockiert sind. Gilt für alle Bereiche einschließlich verwalteter Server. Denylist hat Vorrang vor Allowlist. Siehe [Verwaltete MCP-Konfiguration](/docs/de/managed-mcp) | `[{ "serverName": "filesystem" }]` |
| `disableAgentView` | Setzen Sie auf `true`, um [Hintergrund-Agenten und Agent-Ansicht](/docs/de/agent-view) auszuschalten: `claude agents`, `--bg`, `/background` und den On-Demand-Supervisor. Normalerweise in [verwalteten Einstellungen](/docs/de/permissions#managed-settings) gesetzt. Entspricht dem Setzen von `CLAUDE_CODE_DISABLE_AGENT_VIEW` auf `1` | `true` |
| `disableAllHooks` | Deaktivieren Sie alle [Hooks](/docs/de/hooks) und alle benutzerdefinierten [Statuszeilen](/docs/de/statusline) | `true` |
| `disableArtifact` | Setzen Sie auf `true`, um das [Artifact](/docs/de/artifacts)-Tool zu deaktivieren, das Sitzungsausgabe als private Webseite auf claude.ai veröffentlicht. Entspricht dem Setzen von `CLAUDE_CODE_DISABLE_ARTIFACT` auf `1` | `true` |
| `disableAutoMode` | Setzen Sie auf `"disable"`, um zu verhindern, dass der [Auto-Modus](/docs/de/permission-modes#eliminate-prompts-with-auto-mode) aktiviert wird. Entfernt `auto` aus dem `Shift+Tab`-Zyklus und lehnt `--permission-mode auto` beim Start ab. Am nützlichsten in [verwalteten Einstellungen](/docs/de/permissions#managed-settings), wo Benutzer es nicht überschreiben können | `"disable"` |
| `disableBrowserExternalNavigation` | (Nur verwaltete Einstellungen) Setzen Sie auf `true`, um externes Browsen im [Browser-Bereich](/docs/de/desktop#browse-external-sites) der Desktop-App auszuschalten. Weder Benutzer noch Claude können zu externen Seiten navigieren, und localhost Dev-Server-Vorschau sind nicht betroffen. Der Wert muss der JSON-Boolean `true` sein; die Zeichenkette `"true"` wird ignoriert | `true` |
| `disableBundledSkills` | Setzen Sie auf `true`, um die [Skills](/docs/de/skills) und Workflows zu deaktivieren, die mit Claude Code ausgeliefert werden: Gebündelte Skills und Workflows werden vollständig entfernt, während integrierte Slash-Befehle wie `/init` tippbar bleiben, aber vom Modell ausgeblendet werden. `/doctor` bleibt tippbar wie die integrierten Befehle; blenden Sie ihn mit [`DISABLE_DOCTOR_COMMAND`](/docs/de/env-vars) statt aus. Skills von Plugins, `.claude/skills/` und `.claude/commands/` sind nicht betroffen. Entspricht dem Setzen von `CLAUDE_CODE_DISABLE_BUNDLED_SKILLS` auf `1` | `true` |
| `disableClaudeAiConnectors` | {/* min-version: 2.1.182 */}Deaktivieren Sie [claude.ai MCP-Konnektoren](/docs/de/mcp#use-mcp-servers-from-claude-ai), sodass sie nicht automatisch abgerufen oder verbunden werden. Setzen Sie in jedem Einstellungsbereich. `true` in jeder Quelle hat Vorrang, daher kann eine eingecheckte Projekt-`.claude/settings.json` ein Repo aus Cloud-Konnektoren ausschließen, aber ein Projekt-Level `false` kann ein Benutzer- oder Richtlinien-Level `true` nicht überschreiben. Server, die explizit über `--mcp-config` übergeben werden, sind nicht betroffen. Um einzelne Konnektoren statt aller zu verweigern, verwenden Sie [`deniedMcpServers`](/docs/de/managed-mcp). Erfordert Claude Code v2.1.182 oder später | `true` |
| `disableDeepLinkRegistration` | Setzen Sie auf `"disable"`, um zu verhindern, dass Claude Code den `claude-cli://` Protokoll-Handler beim Start mit dem Betriebssystem registriert. [Deep Links](/docs/de/deep-links) ermöglichen es externen Tools, eine Claude Code-Sitzung mit einer vorausgefüllten Aufforderung zu öffnen. Nützlich in Umgebungen, in denen die Protokoll-Handler-Registrierung eingeschränkt oder separat verwaltet wird | `"disable"` |
| `disabledMcpjsonServers` | Liste spezifischer MCP-Server aus `.mcp.json`-Dateien zum Ablehnen | `["filesystem"]` |
| `disableRemoteControl` | {/* min-version: 2.1.128 */}Deaktivieren Sie [Remote Control](/docs/de/remote-control): blockiert `claude remote-control`, das Flag `--remote-control`, Auto-Start und den In-Session-Toggle. Normalerweise in [verwalteten Einstellungen](/docs/de/permissions#managed-settings) für die Pro-Gerät-MDM-Durchsetzung platziert, funktioniert aber aus jedem Bereich. Erfordert Claude Code v2.1.128 oder später | `true` |
| `disableSideloadFlags` | {/* min-version: 2.1.193 */}(Nur verwaltete Einstellungen) Lehnen Sie die Flags `--plugin-dir`, `--plugin-url`, `--agents` und `--mcp-config` beim Start ab, die Benutzer ansonsten übergeben könnten, um [`strictKnownMarketplaces`](#strictknownmarketplaces) für einen einzelnen Lauf zu umgehen. Lehnt auch diese Flags von jeder Oberfläche ab, die die CLI intern mit ihnen startet, derzeit [Cowork](/docs/de/desktop) lokale Sitzungen in der Desktop-App. Ein `--mcp-config`, dessen Server alle In-Process-`type: "sdk"`-Einträge sind, wird weiterhin akzeptiert, sodass das Agent SDK und die VS Code-Erweiterung weiterhin funktionieren. Blockiert nicht `claude mcp add`, `.mcp.json` oder SDK `setMcpServers()`; kombinieren Sie mit [`allowedMcpServers`](/docs/de/managed-mcp) für Pro-Server-MCP-Kontrolle. Erfordert Claude Code v2.1.193 oder später | `true` |
| `disableSkillShellExecution` | Deaktivieren Sie die Inline-Shell-Ausführung für `` !`...` `` und ` ```! ` Blöcke in [Skills](/de/skills) und benutzerdefinierten Befehlen aus Benutzer-, Projekt-, Plugin- oder zusätzlichen Verzeichnisquellen. Befehle werden durch `[shell command execution disabled by policy]` ersetzt, anstatt ausgeführt zu werden. Gebündelte und verwaltete Skills sind nicht betroffen. Am nützlichsten in [verwalteten Einstellungen](/de/permissions#managed-settings), wo Benutzer es nicht überschreiben können | `true` |
| `disableWorkflows` | **Standard**: `false`. Deaktivieren Sie [dynamische Workflows](/docs/de/workflows#turn-workflows-off) und die gebündelten Workflow-Befehle. Entspricht dem Setzen von `CLAUDE_CODE_DISABLE_WORKFLOWS` auf `1` | `true` |
| `editorMode` | **Standard**: `"normal"`. Tastaturkürzel-Modus für die Eingabeaufforderung: `"normal"` oder `"vim"`. Wird in `/config` als **Editor mode** angezeigt | `"vim"` |
| `effortLevel` | Persistieren Sie die [Anstrengungsstufe](/docs/de/model-config#adjust-effort-level) über Sitzungen hinweg. Akzeptiert `"low"`, `"medium"`, `"high"` oder `"xhigh"`. Wird automatisch geschrieben, wenn Sie `/effort` mit einem dieser Werte ausführen. `--effort` und [`CLAUDE_CODE_EFFORT_LEVEL`](/docs/de/env-vars) überschreiben dies für eine Sitzung. Siehe [Anstrengungsstufe anpassen](/docs/de/model-config#adjust-effort-level) für unterstützte Modelle | `"xhigh"` |
| `enableAllProjectMcpServers` | Genehmigen Sie automatisch alle MCP-Server, die in Projekt-`.mcp.json`-Dateien definiert sind. {/* min-version: 2.1.196 */}Ab v2.1.196 berücksichtigen `claude mcp list` und `claude mcp get` diesen Schlüssel in einem nicht vertrauenswürdigen Ordner nur aus [Einstellungsdateien, die nicht in das Repository eingecheckt sind](/docs/de/mcp#managing-your-servers) | `true` |
| `enableArtifact` | {/* min-version: 2.1.196 */}Aktivieren oder deaktivieren Sie das [Artifact](/docs/de/artifacts)-Tool für diesen Benutzer. Wenn nicht gesetzt, folgt der Standard der [Verfügbarkeit](/docs/de/artifacts#availability) der Funktion für Ihr Konto. Die Zeile **Artifacts** in `/config` schreibt diesen Schlüssel. Ein verwaltetes `disableArtifact` und die [Admin-Einstellung](/docs/de/artifacts#manage-artifacts-for-your-organization) Ihrer Organisation haben Vorrang, und der Schlüssel wird in Projekt- und lokalen Einstellungen (`.claude/settings.json`, `.claude/settings.local.json`) ignoriert, die ein Repository ansonsten committen könnte. Erfordert Claude Code v2.1.196 oder später | `true` |
| `enabledMcpjsonServers` | Liste spezifischer MCP-Server aus `.mcp.json`-Dateien zum Genehmigen. {/* min-version: 2.1.196 */}Ab v2.1.196 berücksichtigen `claude mcp list` und `claude mcp get` diesen Schlüssel in einem nicht vertrauenswürdigen Ordner nur aus [Einstellungsdateien, die nicht in das Repository eingecheckt sind](/docs/de/mcp#managing-your-servers) | `["memory", "github"]` |
| `enforceAvailableModels` | {/* min-version: 2.1.175 */}Erweitern Sie die `availableModels` Allowlist auf das Standardmodell. Wenn `true` in verwalteten Einstellungen und `availableModels` ist ein nicht leeres Array, fällt die Standardoption auf den ersten zulässigen Eintrag zurück, der verfügbar ist, aber nur wenn das Modell, auf das Standard zurückfallen würde (die [Organisationsstandardeinstellung](/docs/de/model-config#organization-default-model), wenn eine gilt, ansonsten die Kontotyp-Standard), nicht in der Allowlist ist; ein zulässiger Standard wird wie es ist beibehalten. Hat keine Auswirkung, wenn `availableModels` nicht gesetzt oder leer ist. Siehe [Erzwingen Sie die Allowlist für das Standardmodell](/docs/de/model-config#enforce-the-allowlist-for-the-default-model). Erfordert Claude Code v2.1.175 oder später | `true` |
| `env` | Umgebungsvariablen, die auf jede Sitzung und auf Subprozesse angewendet werden, die Claude Code von ihr aus startet. Setzen Sie eine Variable auf `""`, um einen Shell-Export mit einer leeren Zeichenkette zu überschreiben, die Claude Code als nicht gesetzt behandelt. Subprozesse erben weiterhin den leeren Wert. `NO_COLOR` und `FORCE_COLOR`, die hier gesetzt sind, erreichen nur Subprozesse; um die Farben der Claude Code-Oberfläche selbst zu ändern, setzen Sie sie in Ihrer Shell, bevor Sie `claude` starten. {/* min-version: 2.1.195 */}Ab v2.1.195 werden Identitätsvariablen, die Claude Code's Hosting-Umgebungen setzen, z. B. `CLAUDE_CODE_REMOTE` und `CLAUDE_CODE_ACCOUNT_UUID`, ignoriert, wenn sie hier gesetzt sind | `{"FOO": "bar"}` |
| `fallbackModel` | Fallback-Modell(e) zum Ausprobieren in der Reihenfolge, wenn das primäre Modell überlastet oder nicht verfügbar ist. Claude Code wechselt für den Rest der Runde zum nächsten verfügbaren Modell in der Kette und zeigt einen Hinweis an. `"default"` wird zum Standardmodell erweitert. Ketten sind auf drei Modelle begrenzt; zusätzliche Einträge werden ignoriert. Im Gegensatz zu den meisten Array-Einstellungen wird dieser Schlüssel nicht über Einstellungsdateien zusammengeführt: Die Datei mit der höchsten Priorität, die ihn definiert, liefert die gesamte Kette. Das Flag [`--fallback-model`](/docs/de/cli-reference#cli-flags) überschreibt dies für eine Sitzung. Siehe [Fallback-Modellketten](/docs/de/model-config#fallback-model-chains) | `["claude-sonnet-5", "claude-haiku-4-5"]` |
| `fastMode` | Aktivieren Sie [schnellen Modus](/docs/de/fast-mode) für Sitzungen, in denen er verfügbar ist. Das Umschalten mit `/fast` schreibt `true` hier in Benutzereinstellungen und entfernt den Schlüssel, wenn Sie den schnellen Modus ausschalten | `true` |
| `fastModePerSessionOptIn` | Wenn `true`, bleibt der schnelle Modus nicht über Sitzungen hinweg bestehen. Jede Sitzung startet mit ausgeschaltetem schnellen Modus und erfordert, dass Benutzer ihn mit `/fast` aktivieren. Die Voreinstellung des Benutzers für den schnellen Modus wird weiterhin gespeichert. Siehe [Opt-in pro Sitzung erforderlich](/docs/de/fast-mode#require-per-session-opt-in) | `true` |
| `feedbackSurveyRate` | Wahrscheinlichkeit (0–1), dass die [Sitzungsqualitätsumfrage](/docs/de/data-usage#session-quality-surveys) angezeigt wird, wenn berechtigt. Setzen Sie auf `0`, um vollständig zu unterdrücken, oder setzen Sie [`CLAUDE_CODE_DISABLE_FEEDBACK_SURVEY`](/docs/de/env-vars) in `env`. Nützlich bei Verwendung von Amazon Bedrock, Google Cloud's Agent Platform oder Microsoft Foundry, wo die Standard-Stichprobenquote nicht gilt | `0.05` |
| `fileCheckpointingEnabled` | {/* min-version: 2.1.119 */}**Standard**: `true`. Erstellen Sie Snapshots von Dateien vor jeder Bearbeitung, damit [`/rewind`](/docs/de/checkpointing) sie wiederherstellen kann. Wird in `/config` als **Rewind code (checkpoints)** angezeigt. Um dies über eine Umgebungsvariable zu deaktivieren, setzen Sie [`CLAUDE_CODE_DISABLE_FILE_CHECKPOINTING`](/docs/de/env-vars) in `env` | `false` |
| `fileSuggestion` | Konfigurieren Sie ein benutzerdefiniertes Skript für `@` Datei-Autovervollständigung. Siehe [Dateivorschlag-Einstellungen](#file-suggestion-settings) | `{"type": "command", "command": "~/.claude/file-suggestion.sh"}` |
| `footerLinksRegexes` | {/* min-version: 2.1.176 */}Rendern Sie zusätzliche anklickbare Badges in der Fußzeile, wenn ein Regex die Ausgabe der Runde abgleicht. Jeder Eintrag hat ein `pattern`, eine URL-Vorlage mit `{name}` Platzhaltern, die aus benannten Erfassungsgruppen gefüllt werden, und ein optionales `label`. Nur aus Benutzereinstellungen, dem Flag `--settings` und verwalteten Einstellungen gelesen. Siehe [Footer-Link-Badges](#footer-link-badges) für URL-Einschränkungen, Scheme-Allowlist und Limits. Erfordert Claude Code v2.1.176 oder später | `[{"type": "regex", "pattern": "\\b(?PROJ-\\d+)\\b", "url": "https://issues.example.com/browse/{key}", "label": "{key}"}]` |
| `forceLoginMethod` | Verwenden Sie `claudeai`, um die Anmeldung auf Claude.ai-Konten zu beschränken, `console`, um die Anmeldung auf Claude Console-Konten zu beschränken, oder `gateway`, um die Anmeldung auf ein Cloud-Gateway zu beschränken; siehe [Claude-Apps-Gateway](/docs/de/claude-apps-gateway). Wenn in verwalteten Einstellungen gesetzt, werden Sitzungen, die durch `ANTHROPIC_API_KEY`, `ANTHROPIC_AUTH_TOKEN` oder `apiKeyHelper` authentifiziert sind, beim Start blockiert, da eine Umgebungsanmeldedaten die erforderliche Anmeldungsmethode nicht erfüllen kann. Drittanbieter-Provider-Sitzungen wie Amazon Bedrock, Google Cloud's Agent Platform und Microsoft Foundry werden nicht blockiert: Sie authentifizieren sich gegen Ihren Cloud-Provider statt gegen Anthropic | `claudeai` |
| `forceLoginGatewayUrl` | Füllt den Gateway-URL auf dem `/login` Cloud-Gateway-Bildschirm aus und sperrt ihn. Entweder dieser Schlüssel oder `forceLoginMethod: "gateway"` zeigt diesen Bildschirm an; setzen Sie beide, damit die URL ausgefüllt ist. Wird nur auf der verwalteten Richtlinienebene berücksichtigt; ignoriert in Benutzer- und Projekteinstellungen. Siehe [Claude-Apps-Gateway](/docs/de/claude-apps-gateway#set-the-gateway-url) | `"https://claude-gateway.example.com"` |
| `forceLoginOrgUUID` | Geben Sie die UUID einer Organisation an, um sie während der Anmeldung automatisch auszuwählen und den Organisationsauswahlschritt zu umgehen, oder akzeptieren Sie ein Array von UUIDs, wobei jede aufgelistete Organisation ohne Vorauswahl akzeptiert wird. Wenn in verwalteten Einstellungen gesetzt, schlägt die Anmeldung fehl, wenn das authentifizierte Konto nicht zu einer aufgelisteten Organisation gehört, und Sitzungen, die durch `ANTHROPIC_API_KEY`, `ANTHROPIC_AUTH_TOKEN` oder `apiKeyHelper` authentifiziert sind, werden beim Start blockiert, da die Organisationszugehörigkeit für sie nicht überprüft werden kann. Drittanbieter-Provider-Sitzungen wie Amazon Bedrock, Google Cloud's Agent Platform und Microsoft Foundry werden nicht blockiert: Verwenden Sie Ihre Cloud-IAM, um einzuschränken, welche Cloud-Konten verwendet werden können. Ein leeres Array schlägt geschlossen fehl und blockiert die Anmeldung mit einer Fehlkonfigurationsmeldung | `"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"` oder `["xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx", "yyyyyyyy-yyyy-yyyy-yyyy-yyyyyyyyyyyy"]` |
| `forceRemoteSettingsRefresh` | (Nur verwaltete Einstellungen) Blockieren Sie den CLI-Start, bis verwaltete Einstellungen aus der Ferne vom Server abgerufen werden. Wenn der Abruf fehlschlägt, wird die CLI beendet, anstatt mit zwischengespeicherten oder keinen Einstellungen fortzufahren. Wenn nicht gesetzt, wird der Start ohne Warten auf Remote-Einstellungen fortgesetzt. Siehe [Fail-Closed-Durchsetzung](/docs/de/server-managed-settings#enforce-fail-closed-startup) | `true` |
| `gcpAuthRefresh` | Benutzerdefiniertes Skript, das GCP Application Default Credentials aktualisiert, wenn sie ablaufen oder nicht geladen werden können. Siehe [erweiterte Anmeldedatenkonfiguration](/docs/de/google-vertex-ai#advanced-credential-configuration) | `gcloud auth application-default login` |
| `hooks` | Konfigurieren Sie benutzerdefinierte Befehle, die bei Lebenszyklusereignissen ausgeführt werden. Siehe [Hooks-Dokumentation](/docs/de/hooks) für das Format | Siehe [Hooks](/docs/de/hooks) |
| `httpHookAllowedEnvVars` | Allowlist von Umgebungsvariablennamen, die HTTP-Hooks in Header interpolieren können. Wenn gesetzt, ist die effektive `allowedEnvVars` jedes Hooks der Schnittpunkt mit dieser Liste. Undefined = keine Einschränkung. Arrays werden über Einstellungsquellen zusammengeführt. Siehe [Hook-Konfiguration](#hook-configuration) | `["MY_TOKEN", "HOOK_SECRET"]` |
| `includeGitInstructions` | **Standard**: `true`. Integrierte Commit- und PR-Workflow-Anweisungen und den Git-Status-Snapshot in Claudes Systemaufforderung einbeziehen. Setzen Sie auf `false`, um beide zu entfernen, z. B. wenn Sie Ihre eigenen Git-Workflow-Skills verwenden. Die Umgebungsvariable `CLAUDE_CODE_DISABLE_GIT_INSTRUCTIONS` hat Vorrang vor dieser Einstellung, wenn sie gesetzt ist | `false` |
| `inputNeededNotifEnabled` | {/* min-version: 2.1.119 */}**Standard**: `false`. Wenn [Remote Control](/docs/de/remote-control) verbunden ist, senden Sie eine Push-Benachrichtigung an Ihr Telefon, wenn eine Berechtigungsaufforderung oder Frage auf Ihre Eingabe wartet. Wird in `/config` als **Push when actions required** angezeigt. Siehe [Mobile Push-Benachrichtigungen](/docs/de/remote-control#mobile-push-notifications). Erfordert Claude Code v2.1.119 oder später | `true` |
| `language` | Konfigurieren Sie Claudes bevorzugte Antwortsprache (z. B. `"japanese"`, `"spanish"`, `"french"`). Claude wird standardmäßig in dieser Sprache antworten. Legt auch die Sprache für [Sprachdiktieren](/docs/de/voice-dictation#change-the-dictation-language) und automatisch generierte Sitzungstitel fest. {/* min-version: 2.1.176 */}Ab v2.1.176 entsprechen Sitzungstitel, wenn nicht gesetzt, der Sprache Ihres Gesprächs | `"japanese"` |
| `minimumVersion` | Verhindern Sie, dass der Auto-Updater und `claude update` eine Version unter dieser installieren. Das Wechseln vom `"latest"`-Kanal zu `"stable"` über `/config` fordert Sie auf, auf der aktuellen Version zu bleiben oder das Downgrade zu erlauben. Wenn Sie sich entscheiden zu bleiben, wird dieser Wert gesetzt. Auch nützlich in [verwalteten Einstellungen](/docs/de/permissions#managed-settings) um eine organisationsweite Mindestversion festzulegen. Für einen Hard Floor, der den Start vollständig blockiert, siehe `requiredMinimumVersion` | `"2.1.100"` |
| `model` | Überschreiben Sie das Standardmodell für Claude Code. `--model` und [`ANTHROPIC_MODEL`](/docs/de/model-config#environment-variables) überschreiben dies für eine Sitzung | `"claude-sonnet-5"` |
| `modelOverrides` | Ordnen Sie Anthropic-Modell-IDs Anbieter-spezifischen Modell-IDs wie Amazon Bedrock-Inferenzprofil-ARNs zu. Jeder Modellwähler-Eintrag verwendet seinen zugeordneten Wert beim Aufrufen der Anbieter-API. Siehe [Modell-IDs pro Version überschreiben](/docs/de/model-config#override-model-ids-per-version) | `{"claude-opus-4-6": "arn:aws:bedrock:..."}` |
| `otelHeadersHelper` | Skript zum Generieren dynamischer OpenTelemetry-Header. Wird beim Start und regelmäßig ausgeführt. Setzen Sie das Aktualisierungsintervall mit [`CLAUDE_CODE_OTEL_HEADERS_HELPER_DEBOUNCE_MS`](/docs/de/env-vars). Siehe [Dynamische Header](/docs/de/monitoring-usage#dynamic-headers) | `/bin/generate_otel_headers.sh` |
| `outputStyle` | Konfigurieren Sie einen Ausgabestil, um die Systemaufforderung anzupassen. Siehe [Ausgabestil-Dokumentation](/docs/de/output-styles) | `"Explanatory"` |
| `parentSettingsBehavior` | {/* min-version: 2.1.133 */}(Nur verwaltete Einstellungen) **Standard**: `"first-wins"`. Steuert, ob verwaltete Einstellungen, die programmgesteuert von einem eingebetteten Host-Prozess wie dem Agent SDK oder einer IDE-Erweiterung bereitgestellt werden, gelten, wenn auch eine von Admin bereitgestellte verwaltete Ebene vorhanden ist. `"first-wins"`: die von Parent bereitgestellten Einstellungen werden verworfen und nur die Admin-Ebene gilt. `"merge"`: die von Parent bereitgestellten Einstellungen gelten unter der Admin-Ebene, gefiltert, sodass sie die Richtlinie verschärfen, aber nicht lockern können. Hat keine Auswirkung, wenn keine Admin-Ebene bereitgestellt wird. Erfordert Claude Code v2.1.133 oder später | `"merge"` |
| `permissions` | Siehe Tabelle unten für die Struktur der Berechtigungen. | |
| `plansDirectory` | **Standard**: `~/.claude/plans`. Passen Sie an, wo Plandateien gespeichert werden. Der Pfad ist relativ zum Projektstamm. | `"./plans"` |
| `pluginSuggestionMarketplaces` | (Nur verwaltete Einstellungen) Marketplace-Namen, deren Plugins als kontextuelle Installationsvorschläge angezeigt werden können. Keine Marketplace-deklarierten Vorschläge werden ohne diese Allowlist angezeigt; der integrierte First-Party-Frontend-Design-Tipp ist nicht betroffen. Vorschläge stammen aus der `relevance`-Deklaration jedes Plugins in seinem Marketplace-Eintrag. Ein Name wird nur wirksam, wenn der Marketplace auf der Maschine registriert ist und seine registrierte Quelle auch in verwalteten Einstellungen deklariert ist, entweder als `extraKnownMarketplaces`-Eintrag für diesen Namen oder als Eintrag von `strictKnownMarketplaces`. Ein Marketplace, der unter einem zulässigen Namen aus einer anderen Quelle registriert ist, wird ignoriert. Der offizielle Marketplace ist von der Quellanforderung befreit: Das Zulassen seines Namens allein genügt, da dieser Name nur von der offiziellen Anthropic-Quelle registriert werden kann. | `["acme-corp-plugins"]` |
| `pluginTrustMessage` | (Nur verwaltete Einstellungen) Benutzerdefinierte Nachricht, die der vor der Installation angezeigten Plugin-Vertrauenswarnung angehängt wird. Verwenden Sie dies, um organisationsspezifischen Kontext hinzuzufügen, z. B. um zu bestätigen, dass Plugins aus Ihrem internen Marketplace überprüft sind. | `"All plugins from our marketplace are approved by IT"` |
| `policyHelper` | {/* min-version: 2.1.136 */}Von Admin bereitgestellte ausführbare Datei, die verwaltete Einstellungen dynamisch beim Start berechnet. Wird nur von MDM oder einer System-`managed-settings.json`-Datei berücksichtigt. Siehe [Berechnen Sie verwaltete Einstellungen mit einem Policy Helper](#compute-managed-settings-with-a-policy-helper). Erfordert Claude Code v2.1.136 oder später | `{"path": "/usr/local/bin/claude-policy"}` |
| `preferredNotifChannel` | **Standard**: `"auto"`. Methode für Task-Complete- und Berechtigungsaufforderungs-Benachrichtigungen: `"auto"`, `"terminal_bell"`, `"iterm2"`, `"iterm2_with_bell"`, `"kitty"`, `"ghostty"` oder `"notifications_disabled"`. `"auto"` sendet eine Desktop-Benachrichtigung in iTerm2, Ghostty und Kitty und tut nichts in anderen Terminals. Setzen Sie `"terminal_bell"`, um das Glockenzeichen in jedem Terminal zu klingeln. Wird in `/config` als **Notifications** angezeigt. Siehe [Erhalten Sie einen Terminal-Glockenzeichen oder eine Benachrichtigung](/docs/de/terminal-config#get-a-terminal-bell-or-notification) | `"terminal_bell"` |
| `prefersReducedMotion` | Reduzieren oder deaktivieren Sie UI-Animationen (Spinner, Shimmer, Flash-Effekte) für Barrierefreiheit | `true` |
| `prUrlTemplate` | URL-Vorlage für das PR-Badge, das in der Fußzeile und in Tool-Ergebnis-Zusammenfassungen angezeigt wird. Ersetzt `{host}`, `{owner}`, `{repo}`, `{number}` und `{url}` aus der von `gh` gemeldeten PR-URL. Verwenden Sie dies, um PR-Links auf ein internes Code-Review-Tool statt auf `github.com` zu verweisen. Beeinflusst nicht `#123` Autolinks in Claudes Prosa | `"https://reviews.example.com/{owner}/{repo}/pull/{number}"` |
| `remoteControlAtStartup` | {/* min-version: 2.1.119 */}Verbinden Sie [Remote Control](/docs/de/remote-control) automatisch, wenn jede interaktive Sitzung startet, anstatt auf `/remote-control` zu warten. Setzen Sie auf `true`, um immer automatisch zu verbinden, `false`, um nie automatisch zu verbinden, oder lassen Sie es ungesetzt, um dem Standard Ihrer Organisation zu folgen. Wird in `/config` als **Enable Remote Control for all sessions** angezeigt. Siehe [Enable Remote Control for all sessions](/docs/de/remote-control#enable-remote-control-for-all-sessions) | `false` |
| `requiredMaximumVersion` | Nur verwaltete Einstellungen. Maximale Claude Code-Version, die gestartet werden darf. Wenn die laufende Version neuer ist, wird Claude Code beim Start beendet und der Benutzer wird angewiesen, eine genehmigte Version durch die Methode der Organisation zu installieren; `claude install ` kann auch funktionieren. Hintergrund-Auto-Updates und `claude update` überspringen Versionen über der Obergrenze, sodass eine In-Range-Installation in Range bleibt. `claude update`, `claude install` und `claude doctor` funktionieren weiterhin über der Obergrenze, damit Benutzer sich erholen können. Versionen, die diesem Setting vorausgehen, ignorieren es | `"2.1.150"` |
| `requiredMinimumVersion` | Nur verwaltete Einstellungen. Minimale Claude Code-Version, die zum Start erforderlich ist. Wenn die laufende Version älter ist, wird Claude Code beim Start beendet und der Benutzer wird angewiesen, durch die Methode der Organisation zu aktualisieren. `claude update`, `claude install` und `claude doctor` funktionieren weiterhin unter der Untergrenze, damit Benutzer sich erholen können. Unterscheidet sich von `minimumVersion`, das Downgrades verhindert, aber den Start nie blockiert. Versionen, die diesem Setting vorausgehen, ignorieren es | `"2.1.150"` |
| `respectGitignore` | **Standard**: `true`. Steuern Sie, ob der `@` Datei-Picker `.gitignore`-Muster respektiert. Wenn `true`, werden Dateien, die `.gitignore`-Mustern entsprechen, aus Vorschlägen ausgeschlossen | `false` |
| `respondToBashCommands` | {/* min-version: 2.1.186 */}**Standard**: `true`. Ob Claude nach einem Input-Box `!` Shell-Befehl antwortet. Setzen Sie auf `false`, um die Befehlsausgabe zum Kontext hinzuzufügen, ohne eine Antwort zu geben. Siehe [Shell-Modus mit `!` Präfix](/docs/de/interactive-mode#shell-mode-with-prefix). Erfordert Claude Code v2.1.186 oder später | `false` |
| `showClearContextOnPlanAccept` | **Standard**: `false`. Zeigen Sie die Option "Kontext löschen" auf dem Plan-Akzeptanz-Bildschirm an. Setzen Sie auf `true`, um die Option wiederherzustellen | `true` |
| `showThinkingSummaries` | **Standard**: `false`. Zeigen Sie [erweitertes Denken](/docs/de/model-config#extended-thinking) Zusammenfassungen in interaktiven Sitzungen an. Wenn nicht gesetzt oder `false`, werden Denk-Blöcke von der API redigiert und als zusammengeklappter Stub angezeigt. Redaktion ändert nur, was Sie sehen, nicht was das Modell generiert: Um Denk-Ausgaben zu reduzieren, [senken Sie das Budget oder deaktivieren Sie das Denken](/docs/de/model-config#extended-thinking) stattdessen. Dieser Einstellung hat keine Auswirkung im nicht-interaktiven Modus (`-p`), dem Agent SDK oder IDE-Erweiterungen wie VS Code | `true` |
| `showTurnDuration` | **Standard**: `true`. Zeigen Sie Nachrichten zur Dauer der Runde nach Antworten an, z. B. "Cooked for 1m 6s". Wird in `/config` als **Show turn duration** angezeigt | `false` |
| `skillListingBudgetFraction` | **Standard**: `0.01`. Anteil des Kontextfensters des Modells, das für die [Skill-Auflistung](/docs/de/skills#skill-descriptions-are-cut-short) reserviert ist, die Claude jede Runde sieht. Wenn die Auflistung das Budget überschreitet, werden Beschreibungen für die am wenigsten verwendeten Skills auf bloße Namen reduziert, sodass Claude sie weiterhin aufrufen kann, aber nicht sieht, warum. Erhöhen Sie, um mehr Beschreibungen sichtbar zu halten, auf Kosten von mehr Kontext pro Runde. `/doctor` zeigt die Auflistungskosten gegen das Budget | `0.02` |
| `skillListingMaxDescChars` | **Standard**: `1536`. Pro-Skill-Zeichenbegrenzung für den kombinierten `description` und `when_to_use` Text in der [Skill-Auflistung](/docs/de/skills#skill-descriptions-are-cut-short), die Claude jede Runde sieht. Text, der länger als dies ist, wird gekürzt. Erhöhen Sie, um lange Beschreibungen intakt zu halten, auf Kosten von mehr Kontext pro Runde; senken Sie, um mehr Skills unter [`skillListingBudgetFraction`](#available-settings) zu passen. | `2048` |
| `skillOverrides` | {/* min-version: 2.1.129 */}Pro-Skill-Sichtbarkeitsüberschreibungen, die nach Skill-Name verschlüsselt sind. Der Wert ist `"on"`, `"name-only"`, `"user-invocable-only"` oder `"off"`. Ermöglicht es Ihnen, einen Skill auszublenden oder zu reduzieren, ohne seine SKILL.md zu bearbeiten. Gilt nicht für Plugin-Skills, die über `/plugin` verwaltet werden. Das Menü `/skills` schreibt diese in `.claude/settings.local.json`. Siehe [Skill-Sichtbarkeit aus Einstellungen überschreiben](/docs/de/skills#override-skill-visibility-from-settings). Erfordert Claude Code v2.1.129 oder später | `{"legacy-context": "name-only", "deploy": "off"}` |
| `skipWebFetchPreflight` | Überspringen Sie die [WebFetch-Domänensicherheitsprüfung](/docs/de/data-usage#webfetch-domain-safety-check), die jeden angeforderten Hostnamen an `api.anthropic.com` sendet, bevor Sie abrufen. Setzen Sie auf `true` in Umgebungen, die den Datenverkehr zu Anthropic blockieren, wie Amazon Bedrock, Google Cloud's Agent Platform oder Microsoft Foundry-Bereitstellungen mit restriktivem Ausgang. Wenn übersprungen, versucht WebFetch jede URL, ohne die Blocklist zu konsultieren | `true` |
| `spinnerTipsEnabled` | **Standard**: `true`. Zeigen Sie Tipps im Spinner an, während Claude arbeitet. Setzen Sie auf `false`, um Tipps zu deaktivieren | `false` |
| `spinnerTipsOverride` | Überschreiben Sie Spinner-Tipps mit benutzerdefinierten Zeichenketten. `tips`: Array von Tipp-Zeichenketten. `excludeDefault`: wenn `true`, nur benutzerdefinierte Tipps anzeigen; wenn `false` oder nicht vorhanden, werden benutzerdefinierte Tipps mit integrierten Tipps zusammengeführt | `{ "excludeDefault": true, "tips": ["Use our internal tool X"] }` |
| `spinnerVerbs` | Passen Sie die Aktionsverben an, die im Spinner angezeigt werden, während eine Runde läuft. Setzen Sie `mode` auf `"replace"`, um nur Ihre Verben zu verwenden, oder `"append"`, um sie zu den Standardwerten hinzuzufügen | `{"mode": "append", "verbs": ["Pondering", "Crafting"]}` |
| `sshConfigs` | SSH-Verbindungen, die in der [Desktop](/docs/de/desktop#pre-configure-ssh-connections-for-your-team)-Umgebungs-Dropdown angezeigt werden. Jeder Eintrag erfordert `id`, `name` und `sshHost`; `sshPort`, `sshIdentityFile` und `startDirectory` sind optional. Wenn in verwalteten Einstellungen gesetzt, sind Verbindungen für Benutzer schreibgeschützt. Nur aus verwalteten und Benutzereinstellungen gelesen | `[{"id": "dev-vm", "name": "Dev VM", "sshHost": "user@dev.example.com"}]` |
| `statusLine` | Konfigurieren Sie eine benutzerdefinierte Statuszeile zur Anzeige von Kontext. Das Objekt's optionale Felder `padding`, `refreshInterval` und `hideVimModeIndicator` steuern Abstände, periodische Neuläufe und ob der integrierte Vim-Modus-Indikator unter der Aufforderung ausgeblendet wird. Siehe [`statusLine`-Dokumentation](/docs/de/statusline#manually-configure-a-status-line) | `{"type": "command", "command": "~/.claude/statusline.sh"}` |
| `strictKnownMarketplaces` | (Nur verwaltete Einstellungen) Allowlist von Plugin-Marketplace-Quellen. Undefined = keine Einschränkungen, leeres Array = Lockdown. Erzwungen bei Marketplace-Hinzufügung und bei Plugin-Installation, Update, Aktualisierung und Auto-Update, sodass ein Marketplace, der vor dem Setzen der Richtlinie hinzugefügt wurde, nicht zum Abrufen von Plugins verwendet werden kann. Siehe [Verwaltete Marketplace-Einschränkungen](/docs/de/plugin-marketplaces#managed-marketplace-restrictions) | `[{ "source": "github", "repo": "acme-corp/plugins" }]` |
| `strictPluginOnlyCustomization` | (Nur verwaltete Einstellungen) Block Skills, Agenten, Hooks und MCP-Server aus Benutzer- und Projektquellen, sodass sie nur von Plugins oder verwalteten Einstellungen stammen können. `true` sperrt alle vier Oberflächen; ein Array sperrt nur die benannten. Siehe [`strictPluginOnlyCustomization`](#strictpluginonlycustomization) | `["skills", "hooks"]` |
| `syntaxHighlightingDisabled` | Deaktivieren Sie Syntax-Hervorhebung in Diffs, Code-Blöcken und Dateivorschau | `true` |
| `teammateMode` | **Standard**: `in-process`. Wie [Agent-Team](/docs/de/agent-teams) Teamkollegen angezeigt werden: `in-process`, `auto` (geteilte Bereiche in tmux oder iTerm2, ansonsten In-Process), `tmux` (geteilte Bereiche mit tmux oder iTerm2, erkannt von Ihrem Terminal) oder {/* min-version: 2.1.186 */}}`iterm2` (iTerm2 native Split Panes über die `it2` CLI, hinzugefügt in v2.1.186). Der Standard hat sich in v2.1.179 von `auto` geändert. `--teammate-mode` überschreibt dies für eine Sitzung. Siehe [Wählen Sie einen Anzeigemodus](/docs/de/agent-teams#choose-a-display-mode) | `"auto"` |
| `terminalProgressBarEnabled` | **Standard**: `true`. Zeigen Sie die Terminal-Fortschrittsleiste in unterstützten Terminals an: ConEmu, Ghostty 1.2.0+ und iTerm2 3.6.6+. Wird in `/config` als **Terminal progress bar** angezeigt | `false` |
| `theme` | {/* min-version: 2.1.119 */}**Standard**: `"dark"`. Farbschema für die Oberfläche: `"auto"`, `"dark"`, `"light"`, `"dark-daltonized"`, `"light-daltonized"`, `"dark-ansi"`, `"light-ansi"` oder eine benutzerdefinierte Theme-Referenz wie `"custom:"` oder `"custom::"`. Siehe [Erstellen Sie ein benutzerdefiniertes Theme](/docs/de/terminal-config#create-a-custom-theme). Wird in `/config` als **Theme** angezeigt | `"dark"` |
| `tui` | Terminal-UI-Renderer. Verwenden Sie `"fullscreen"` für den flimmerfreien [Alt-Screen-Renderer](/docs/de/fullscreen) mit virtualisiertem Scrollback. Verwenden Sie `"default"` für den klassischen Main-Screen-Renderer. Setzen Sie über `/tui`. Sie können auch die Umgebungsvariable [`CLAUDE_CODE_NO_FLICKER`](/docs/de/env-vars) setzen. Hintergrund-Sitzungen, die von [Agent-Ansicht](/docs/de/agent-view) geöffnet werden, verwenden immer den Fullscreen-Renderer, unabhängig von dieser Einstellung | `"fullscreen"` |
| `ultracode` | Aktivieren Sie [ultracode](/docs/de/workflows#let-claude-decide-with-ultracode) für die Sitzung. Dieser Schlüssel wird nicht aus `settings.json` gelesen. Setzen Sie über `/effort ultracode`, `--settings` oder eine Agent SDK-Steueranforderung. {/* min-version: 2.1.203 */}Um eine Sitzung mit ultracode bereits aktiviert zu starten, starten Sie mit `claude --effort ultracode`, was Claude Code v2.1.203 oder später erfordert | `true` |
| `useAutoModeDuringPlan` | **Standard**: `true`. Ob Plan Mode Auto-Mode-Semantik verwendet, wenn Auto Mode verfügbar ist. Nicht aus gemeinsamen Projekteinstellungen gelesen. Wird in `/config` als "Use auto mode during plan" angezeigt | `false` |
| `verbose` | {/* min-version: 2.1.119 */}**Standard**: `false`. Zeigen Sie vollständige Werkzeugausgabe statt gekürzte Zusammenfassungen an. Wird in `/config` als **Verbose output** angezeigt. Das Flag `--verbose` überschreibt dies für eine Sitzung | `true` |
| `viewMode` | Standard-Transkript-Ansichtsmodus beim Start: `"default"`, `"verbose"` oder `"focus"`. Überschreibt die klebrige `/focus`-Auswahl, wenn gesetzt. Das Flag `--verbose` überschreibt dies für eine Sitzung | `"verbose"` |
| `vimInsertModeRemaps` | {/* min-version: 2.1.208 */}Ordnen Sie zwei-Tasten-INSERT-Modus-Sequenzen Escape in [vim Editor-Modus](/docs/de/interactive-mode#vim-editor-mode) zu. Jeder Schlüssel ist genau zwei druckbare Zeichen, die nacheinander eingegeben werden, und `""` ist das einzige unterstützte Ziel; andere Einträge werden ignoriert. Nur aus Benutzereinstellungen, dem Flag `--settings` und verwalteten Einstellungen gelesen, sodass die eingecheckte Einstellung eines Repositorys Ihre Tastenanschläge nicht neu zuordnen kann. Hat keine Auswirkung, es sei denn, `editorMode` ist `"vim"`. Siehe [Ordnen Sie INSERT-Modus-Tastatursequenzen neu zu](/docs/de/interactive-mode#remap-insert-mode-key-sequences). Erfordert Claude Code v2.1.208 oder später | `{"jj": ""}` |
| `voice` | [Sprachdiktier](/docs/de/voice-dictation)-Einstellungen: `enabled` aktiviert Diktieren, `mode` wählt `"hold"` oder `"tap"`, und `autoSubmit` sendet die Aufforderung bei Tastenfreigabe im Hold-Modus. Wird automatisch geschrieben, wenn Sie `/voice` ausführen. Erfordert ein Claude.ai-Konto | `{ "enabled": true, "mode": "tap" }` |
| `voiceEnabled` | Veralteter Alias für `voice.enabled`. Bevorzugen Sie das `voice`-Objekt | `true` |
| `wheelScrollAccelerationEnabled` | {/* min-version: 2.1.174 */}**Standard**: `true`. Im [Fullscreen-Rendering](/docs/de/fullscreen#mouse-wheel-scrolling) beschleunigen Sie die Mausrad-Scroll-Geschwindigkeit während schneller Scrolls. Setzen Sie auf `false` für eine konstante Scroll-Rate pro Rad-Kerbe. Erfordert Claude Code v2.1.174 oder später | `false` |
| `workflowKeywordTriggerEnabled` | {/* min-version: 2.1.157 */}**Standard**: `true`. Ob das Wort `ultracode` in einer Aufforderung einen [dynamischen Workflow](/docs/de/workflows#ask-for-a-workflow-in-your-prompt) auslöst. Setzen Sie auf `false`, um das Wort zu tippen, ohne einen auszulösen. Ultracode, `/workflows` und gespeicherte Workflow-Befehle sind nicht betroffen. Wird in `/config` als **Ultracode keyword trigger** angezeigt. Hinzugefügt in v2.1.157; vor v2.1.160 war das Trigger-Wort `workflow` | `false` |
| `wslInheritsWindowsSettings` | (Nur Windows verwaltete Einstellungen) Wenn `true`, liest Claude Code auf WSL verwaltete Einstellungen aus der Windows-Richtlinienkette zusätzlich zu `/etc/claude-code`, wobei Windows-Quellen Vorrang haben. Wird nur berücksichtigt, wenn in der HKLM-Registrierungsschlüssel oder `C:\Program Files\ClaudeCode\managed-settings.json` gesetzt, beide erfordern Windows-Admin zum Schreiben. Damit die HKCU-Richtlinie auch auf WSL gilt, muss das Flag zusätzlich in HKCU selbst gesetzt werden. Hat keine Auswirkung auf natives Windows | `true` |
Globale Konfigurationseinstellungen
Diese Einstellungen werden in `~/.claude.json` statt in `settings.json` gespeichert. Das Hinzufügen zu `settings.json` löst einen Schema-Validierungsfehler aus.
Versionen vor v2.1.119 speichern auch eine Reihe von `/config` Voreinstellungsschlüsseln hier statt in `settings.json`, einschließlich `theme`, `verbose`, `editorMode`, `autoCompactEnabled` und `preferredNotifChannel`.
| Schlüssel | Beschreibung | Beispiel |
| :--------------------------- | :---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :--------- |
| `autoConnectIde` | **Standard**: `false`. Verbinden Sie sich automatisch mit einer laufenden IDE, wenn Claude Code von einem externen Terminal aus startet. Wird in `/config` als **Auto-connect to IDE (external terminal)** angezeigt, wenn außerhalb eines VS Code oder JetBrains-Terminals ausgeführt wird. Die Umgebungsvariable [`CLAUDE_CODE_AUTO_CONNECT_IDE`](/docs/de/env-vars) überschreibt dies, wenn gesetzt | `true` |
| `autoInstallIdeExtension` | **Standard**: `true`. Installieren Sie die Claude Code IDE-Erweiterung automatisch, wenn Sie von einem VS Code-Terminal aus ausgeführt werden. Wird in `/config` als **Auto-install IDE extension** angezeigt, wenn Sie in einem VS Code oder JetBrains-Terminal ausgeführt werden. Sie können auch die Umgebungsvariable [`CLAUDE_CODE_IDE_SKIP_AUTO_INSTALL`](/docs/de/env-vars) auf `1` setzen | `false` |
| `externalEditorContext` | **Standard**: `false`. Stellen Sie Claudes vorherige Antwort als `#`-kommentierter Kontext voran, wenn Sie den externen Editor mit `Ctrl+G` öffnen. Wird in `/config` als **Show last response in external editor** angezeigt | `true` |
| `permissionExplainerEnabled` | **Standard**: `true`. Zeigen Sie eine vom Modell generierte [Erklärung des Befehls](/docs/de/permissions#permission-system), wenn Sie `Ctrl+E` auf einer Bash- oder PowerShell-Berechtigungsaufforderung drücken. Setzen Sie auf `false`, um die Verknüpfung auszuschalten | `false` |
| `teammateDefaultModel` | Standardmodell für [Agent-Team](/docs/de/agent-teams) Teamkollegen, wenn die Spawn-Aufforderung keinen angibt. Setzen Sie auf einen Modellalias wie `"sonnet"` oder `null`, um das aktuelle `/model`-Modell des Leads zu erben. Wird in `/config` als **Default teammate model** angezeigt | `"sonnet"` |
| `workflowSizeGuideline` | {/* min-version: 2.1.202 */}**Standard**: `unrestricted`, das keinen Leitfaden sendet. Legt die [Agent-Anzahl fest, auf die Claude abzielt](/docs/de/workflows#set-a-size-guideline) in den dynamischen Workflows, die es schreibt. Claude Code sendet den Wert an Claude als Ratschlag, nicht als erzwungene Obergrenze. Akzeptiert `unrestricted`, `small`, `medium` oder `large`. Wird in `/config` als **Dynamic workflow size** angezeigt. Sie können es auch direkt mit `/config workflowSizeGuideline=small` setzen. Erfordert Claude Code v2.1.202 oder später. {/* min-version: 2.1.203 */}Der Leitfaden der Agent-Anzahl ersetzt auch den Standard-Schwellenwert für die [`Large workflow` Warnung](/docs/de/workflows#cost); dieses Verhalten erfordert Claude Code v2.1.203 oder später | `"small"` |
Worktree-Einstellungen
Konfigurieren Sie, wie `--worktree` Git-Worktrees erstellt und verwaltet.
| Schlüssel | Beschreibung | Beispiel |
| :---------------------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :------------------------------------ |
| `worktree.baseRef` | Welcher Ref neue Worktrees branchen von. `"fresh"` (Standard) brancht von `origin/` für einen sauberen Baum, der dem Remote entspricht. `"head"` brancht von Ihrem aktuellen lokalen `HEAD`, sodass nicht gepushte Commits und Feature-Branch-Status im Worktree vorhanden sind. Innerhalb eines verknüpften Worktrees wird `"head"` zu diesem Worktree's `HEAD` aufgelöst, nicht zum Haupt-Checkout's. Gilt für `--worktree`, das `EnterWorktree`-Tool und die Subagent-Isolation | `"head"` |
| `worktree.symlinkDirectories` | Verzeichnisse, die vom Haupt-Repository in jeden Worktree symlinkt werden, um große Verzeichnisse auf der Festplatte zu duplizieren. Standardmäßig werden keine Verzeichnisse symlinkt | `["node_modules", ".cache"]` |
| `worktree.sparsePaths` | Verzeichnisse, die in jedem Worktree über Git Sparse-Checkout ausgecheckt werden. Nur die aufgelisteten Verzeichnisse plus Root-Level-Dateien werden auf die Festplatte geschrieben, was in großen Monorepos schneller ist. Während ein spärlicher Worktree existiert, aktiviert Git `extensions.worktreeConfig` in der gemeinsamen `.git/config` des Repositorys; siehe [Checken Sie nur die Verzeichnisse aus, die Sie benötigen](/docs/de/large-codebases#check-out-only-the-directories-you-need) | `["packages/my-app", "shared/utils"]` |
| `worktree.bgIsolation` | {/* min-version: 2.1.143 */}Isolationsmodus für [Hintergrund-Sitzungen](/docs/de/agent-view#how-file-edits-are-isolated). `"worktree"` (Standard) blockiert `Edit`/`Write` im Haupt-Checkout, bis `EnterWorktree` aufgerufen wird. {/* min-version: 2.1.203 */}Außerhalb eines Git-Repositorys gibt ein [`WorktreeCreate` Hook](/docs/de/worktrees#non-git-version-control), der fehlschlägt, die Sperre frei, sodass die Sitzung das Arbeitsverzeichnis an Ort und Stelle bearbeiten kann; erfordert Claude Code v2.1.203 oder später. `"none"` ermöglicht es Hintergrund-Jobs, die Arbeitskopie direkt zu bearbeiten. Erfordert Claude Code v2.1.143 oder später | `"none"` |
Um gitignorierte Dateien wie `.env` in neue Worktrees zu kopieren, verwenden Sie stattdessen eine [`.worktreeinclude`-Datei](/docs/de/worktrees#copy-gitignored-files-into-worktrees) in Ihrem Projektstamm.
Berechtigungseinstellungen
| Schlüssel | Beschreibung | Beispiel |
| :---------------------------------- | :---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :--------------------------------------------------------------------- |
| `allow` | Array von Berechtigungsregeln, um die Werkzeugnutzung zu erlauben. Werkzeugname-Globs werden nur in der Werkzeugposition nach einem literalen `mcp____` Präfix unterstützt, z. B. `mcp__github__get_*`; das Server-Segment muss glob-frei sein. Siehe [Berechtigungsregelsyntax](#permission-rule-syntax) unten für Details zur Mustererkennung | `[ "Bash(git diff *)" ]` |
| `ask` | Array von Berechtigungsregeln, um bei der Werkzeugnutzung um Bestätigung zu bitten. Siehe [Berechtigungsregelsyntax](#permission-rule-syntax) unten | `[ "Bash(git push *)" ]` |
| `deny` | Array von Berechtigungsregeln, um die Werkzeugnutzung zu verweigern. Verwenden Sie dies, um sensible Dateien vom Claude Code-Zugriff auszuschließen. Werkzeugnamen akzeptieren Glob-Muster: `"*"` verweigert jedes Werkzeug und `"mcp__*"` verweigert alle MCP-Werkzeuge. Siehe [Berechtigungsregelsyntax](#permission-rule-syntax) und [Bash-Berechtigungsbeschränkungen](/docs/de/permissions#tool-specific-permission-rules) | `[ "WebFetch", "Bash(curl *)", "Read(./.env)", "Read(./secrets/**)" ]` |
| `additionalDirectories` | Zusätzliche [Arbeitsverzeichnisse](/docs/de/permissions#working-directories) für Dateizugriff. Die meisten `.claude/`-Konfigurationen werden [nicht erkannt](/docs/de/permissions#additional-directories-grant-file-access-not-configuration) aus diesen Verzeichnissen | `[ "../docs/" ]` |
| `defaultMode` | Standard-[Berechtigungsmodus](/docs/de/permission-modes) beim Öffnen von Claude Code. Gültige Werte: `default`, `acceptEdits`, `plan`, `auto`, `dontAsk`, `bypassPermissions` und {{/* min-version: 2.1.200 */}}`manual` als Alias für `default`, der Modus mit der Bezeichnung Manual in der CLI und den VS Code- und JetBrains-Erweiterungen. Der Alias `manual` erfordert Claude Code v2.1.200 oder später. {{/* min-version: 2.1.142 */}}`auto` wird ignoriert, wenn es in Projekt- oder lokalen Einstellungen gesetzt ist, sodass ein Repository sich nicht selbst den Auto-Modus gewähren kann; setzen Sie es stattdessen in `~/.claude/settings.json`. Vor v2.1.142 konnten Projekteinstellungen `auto` setzen. Das CLI-Flag `--permission-mode` überschreibt diese Einstellung für eine einzelne Sitzung | `"acceptEdits"` |
| `disableBypassPermissionsMode` | Setzen Sie auf `"disable"`, um zu verhindern, dass der `bypassPermissions`-Modus aktiviert wird. Dies deaktiviert das Befehlszeilenflag `--dangerously-skip-permissions`. Normalerweise in [verwalteten Einstellungen](/docs/de/permissions#managed-settings) platziert, um Organisationsrichtlinien durchzusetzen, funktioniert aber aus jedem Bereich | `"disable"` |
| `skipDangerousModePermissionPrompt` | Überspringen Sie die Bestätigungsaufforderung, die vor dem Betreten des Bypass-Berechtigungsmodus über `--dangerously-skip-permissions` oder `defaultMode: "bypassPermissions"` angezeigt wird. Wird ignoriert, wenn in Projekteinstellungen (`.claude/settings.json`) gesetzt, um zu verhindern, dass nicht vertrauenswürdige Repositories die Aufforderung automatisch umgehen | `true` |
Berechtigungsregelsyntax
Berechtigungsregeln folgen dem Format `Tool` oder `Tool(specifier)`. Regeln werden in der Reihenfolge ausgewertet: zuerst Deny-Regeln, dann Ask, dann Allow. Die erste übereinstimmende Regel bestimmt das Ergebnis, unabhängig von der Regelspezifität. Siehe [Berechtigungsregelbewertungsreihenfolge](/docs/de/permissions#manage-permissions) für Details.
Schnelle Beispiele:
| Regel | Effekt |
| :----------------------------- | :-------------------------------------------- |
| `Bash` | Passt auf alle Bash-Befehle |
| `Bash(npm run *)` | Passt auf Befehle, die mit `npm run` beginnen |
| `Read(./.env)` | Passt auf das Lesen der `.env`-Datei |
| `WebFetch(domain:example.com)` | Passt auf Abrufanfragen an example.com |
Für die vollständige Referenz der Regelsyntax, einschließlich Platzhalterverhalten, werkzeugspezifischer Muster für Read, Edit, WebFetch, MCP und Agent-Regeln sowie Sicherheitsbeschränkungen von Bash-Mustern, siehe [Berechtigungsregelsyntax](/docs/de/permissions#permission-rule-syntax).
Sandbox-Einstellungen
Konfigurieren Sie erweitertes Sandbox-Verhalten. Sandboxing isoliert Bash-Befehle von Ihrem Dateisystem und Netzwerk. Siehe [Sandboxing](/docs/de/sandboxing) für Details.
| Schlüssel | Beschreibung | Beispiel |
| :------------------------------------- | :----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :--------------------------------------------------- |
| `enabled` | Aktivieren Sie Bash-Sandboxing (macOS, Linux und WSL2). Standard: false | `true` |
| `failIfUnavailable` | Beenden Sie mit einem Fehler beim Start, wenn `sandbox.enabled` true ist, aber die Sandbox nicht gestartet werden kann (fehlende Abhängigkeiten oder nicht unterstützte Plattform). Wenn false (Standard), wird eine Warnung angezeigt und Befehle werden unsandboxed ausgeführt. Vorgesehen für verwaltete Einstellungsbereitstellungen, die Sandboxing als Hard Gate erfordern | `true` |
| `autoAllowBashIfSandboxed` | Genehmigen Sie Bash-Befehle automatisch, wenn sie in einer Sandbox ausgeführt werden. Standard: true | `true` |
| `excludedCommands` | Befehle, die außerhalb der Sandbox ausgeführt werden sollten | `["docker *"]` |
| `allowUnsandboxedCommands` | Erlauben Sie Befehlen, außerhalb der Sandbox über den Parameter `dangerouslyDisableSandbox` ausgeführt zu werden. Wenn auf `false` gesetzt, ist die Fluchtluke `dangerouslyDisableSandbox` vollständig deaktiviert und alle Befehle müssen in einer Sandbox ausgeführt werden (oder in `excludedCommands` sein). Nützlich für Unternehmensrichtlinien, die striktes Sandboxing erfordern. Standard: true | `false` |
| `filesystem.allowWrite` | Zusätzliche Pfade, in die Sandbox-Befehle schreiben können. Arrays werden über alle Einstellungsbereiche zusammengeführt: Benutzer-, Projekt- und verwaltete Pfade werden kombiniert, nicht ersetzt. Auch zusammengeführt mit Pfaden aus `Edit(...)` Allow-Berechtigungsregeln. Siehe [Pfadpräfixe](#sandbox-path-prefixes) unten. | `["/tmp/build", "~/.kube"]` |
| `filesystem.denyWrite` | Pfade, in die Sandbox-Befehle nicht schreiben können. Arrays werden über alle Einstellungsbereiche zusammengeführt. Auch zusammengeführt mit Pfaden aus `Edit(...)` Deny-Berechtigungsregeln. | `["/etc", "/usr/local/bin"]` |
| `filesystem.denyRead` | Pfade, aus denen Sandbox-Befehle nicht lesen können. Arrays werden über alle Einstellungsbereiche zusammengeführt. Auch zusammengeführt mit Pfaden aus `Read(...)` Deny-Berechtigungsregeln. | `["~/.aws/credentials"]` |
| `filesystem.allowRead` | Pfade zum erneuten Erlauben des Lesens innerhalb von `denyRead`-Regionen. Ein `allowRead` Pfad öffnet das Lesen innerhalb einer breiteren `denyRead` Region erneut, und ein genauer Pfad in `denyRead` bleibt innerhalb einer breiteren `allowRead` blockiert; siehe die [Überlappungstabelle](/docs/de/sandboxing#configure-sandboxing) für Beispiele. Arrays werden über alle Einstellungsbereiche zusammengeführt. Verwenden Sie dies, um Workspace-only-Lesezugriffsmuster zu erstellen. | `["."]` |
| `filesystem.allowManagedReadPathsOnly` | (Nur verwaltete Einstellungen) Nur `filesystem.allowRead` Pfade aus verwalteten Einstellungen werden berücksichtigt. `denyRead` wird weiterhin aus allen Quellen zusammengeführt. Standard: false | `true` |
| `credentials.files` | {/* min-version: 2.1.187 */}Anmeldedatendateien oder Verzeichnisse, die Sandbox-Befehle nicht lesen können. Wendet die gleiche Lesesperre wie `filesystem.denyRead` an; der separate Schlüssel hält Anmeldedatenpfade gruppiert mit `credentials.envVars` und getrennt von allgemeinen Dateisystemregeln. Jeder Eintrag ist `{ "path": "...", "mode": "deny" }`, und `deny` ist der einzige unterstützte Modus für Dateien. Pfade verwenden die gleichen [Präfixe](#sandbox-path-prefixes) wie `filesystem.*`-Einstellungen. Arrays werden über alle Einstellungsbereiche zusammengeführt. Erfordert Claude Code v2.1.187 oder später. | `[{ "path": "~/.aws/credentials", "mode": "deny" }]` |
| `credentials.envVars` | {/* min-version: 2.1.187 */}Umgebungsvariablen zum [Schutz vor Sandbox-Befehlen](/docs/de/sandboxing#protect-credentials). Jeder Eintrag hat einen `name` und einen `mode`; der Name muss mit einem Buchstaben oder Unterstrich beginnen und darf nur Buchstaben, Ziffern und Unterstriche enthalten. `deny` entfernt die Variable aus der Umgebung von Sandbox-Befehlen. Erfordert Claude Code v2.1.187 oder später. {{/* min-version: 2.1.199 */}}`mask` ersetzt die Variable mit einem Pro-Sitzungs-Sentinel-Wert innerhalb der Sandbox, während der Sandbox-Proxy den echten Wert bei ausgehenden Anfragen an die `injectHosts` dieses Eintrags ersetzt; es erfordert `network.tlsTerminate` und Claude Code v2.1.199 oder später. `mask` Einträge werden nur aus Benutzer-, verwalteten oder CLI-`--settings` Einstellungen berücksichtigt, nicht aus `.claude/settings.json` oder `.claude/settings.local.json`. Arrays werden über alle Einstellungsbereiche zusammengeführt, und `deny` hat Vorrang, wenn die gleiche Variable mit beiden Modi erscheint. | `[{ "name": "GITHUB_TOKEN", "mode": "deny" }]` |
| `credentials.envVars[].injectHosts` | Hosts, wo der Sandbox-Proxy den echten Wert eines `mask` Eintrags ersetzt. Jeder Host muss auch von `network.allowedDomains` abgedeckt sein, entweder genau oder durch einen Platzhalter. Wenn nicht gesetzt, ersetzt der Proxy den Wert bei Anfragen an jeden Host in `network.allowedDomains`. Wird akzeptiert, aber ignoriert, wenn `mode` `deny` ist. Erfordert Claude Code v2.1.199 oder später. {{/* min-version: 2.1.199 */}} | `["api.github.com"]` |
| `credentials.allowPlaintextInject` | Erlauben Sie `mask` Substitution auf Plain-HTTP-Anfragen sowie TLS-terminiertem HTTPS. Bei Plain-HTTP ist die Upstream-Identität nicht überprüft und die Anmeldedaten werden im Klartext übertragen, daher lassen Sie dies außerhalb vertrauenswürdiger Test-Netzwerke aus. Wird nur aus Benutzer-, verwalteten oder CLI-`--settings` Einstellungen berücksichtigt, nicht aus `.claude/settings.json` oder `.claude/settings.local.json`. Standard: false. Erfordert Claude Code v2.1.199 oder später. {{/* min-version: 2.1.199 */}} | `true` |
| `network.allowUnixSockets` | (Nur macOS) Unix-Socket-Pfade, auf die in der Sandbox zugegriffen werden kann. Wird unter Linux und WSL2 ignoriert, wo der Seccomp-Filter `socket(AF_UNIX, ...)` Aufrufe nicht überprüfen kann; verwenden Sie stattdessen `allowAllUnixSockets`. | `["~/.ssh/agent-socket"]` |
| `network.allowAllUnixSockets` | Erlauben Sie alle Unix-Socket-Verbindungen in der Sandbox. Unter Linux und WSL2 ist dies die einzige Möglichkeit, Unix-Sockets zu erlauben, da der Seccomp-Filter übersprungen wird, der ansonsten `socket(AF_UNIX, ...)` Aufrufe blockiert. Standard: false | `true` |
| `network.allowLocalBinding` | Erlauben Sie das Binden an Localhost-Ports (nur macOS). Standard: false | `true` |
| `network.allowMachLookup` | Zusätzliche XPC/Mach-Servicenamen, die die Sandbox nachschlagen darf (nur macOS). Unterstützt ein einzelnes nachfolgendes `*` für Präfix-Abgleich. Erforderlich für Tools, die über XPC kommunizieren, wie der iOS-Simulator oder Playwright. | `["com.apple.coresimulator.*"]` |
| `network.allowedDomains` | Array von Domänen, um ausgehenden Netzwerkverkehr zu erlauben. Unterstützt Platzhalter (z. B. `*.example.com`). | `["github.com", "*.npmjs.org"]` |
| `network.deniedDomains` | Array von Domänen, um ausgehenden Netzwerkverkehr zu blockieren. Unterstützt die gleiche Platzhaltersyntax wie `allowedDomains`. Hat Vorrang vor `allowedDomains`, wenn beide übereinstimmen. Wird aus allen Einstellungsquellen unabhängig von `allowManagedDomainsOnly` zusammengeführt. | `["sensitive.cloud.example.com"]` |
| `network.allowManagedDomainsOnly` | (Nur verwaltete Einstellungen) Nur `allowedDomains` und `WebFetch(domain:...)` Allow-Regeln aus verwalteten Einstellungen werden berücksichtigt. Domänen aus Benutzer-, Projekt- und lokalen Einstellungen werden ignoriert. Nicht zulässige Domänen werden automatisch blockiert, ohne den Benutzer zu fragen. Verweigerte Domänen werden weiterhin aus allen Quellen berücksichtigt. Standard: false | `true` |
| `network.httpProxyPort` | HTTP-Proxy-Port, der verwendet wird, wenn Sie Ihren eigenen Proxy verwenden möchten. Wenn nicht angegeben, führt Claude seinen eigenen Proxy aus. | `8080` |
| `network.socksProxyPort` | SOCKS5-Proxy-Port, der verwendet wird, wenn Sie Ihren eigenen Proxy verwenden möchten. Wenn nicht angegeben, führt Claude seinen eigenen Proxy aus. | `8081` |
| `network.tlsTerminate` | Experimentell. Beenden Sie TLS innerhalb des Sandbox-Proxys, damit er den Inhalt von HTTPS-Anfragen lesen kann. Erforderlich für `mask` [Anmeldedaten-Substitution](/docs/de/sandboxing#protect-credentials). Setzen Sie `{}`, um eine ephemerale Zertifizierungsstelle für die Sitzung zu generieren, oder setzen Sie `caCertPath` und `caKeyPath`, um Ihre eigene zu verwenden. Wird nur aus Benutzer-, verwalteten oder CLI-`--settings` Einstellungen berücksichtigt, nicht aus `.claude/settings.json` oder `.claude/settings.local.json`. Erfordert Claude Code v2.1.199 oder später. {{/* min-version: 2.1.199 */}} | `{}` |
| `enableWeakerNestedSandbox` | Aktivieren Sie schwächere Sandbox für unprivilegierte Docker-Umgebungen (nur Linux und WSL2). **Reduziert die Sicherheit.** Standard: false | `true` |
| `enableWeakerNetworkIsolation` | (Nur macOS) Erlauben Sie den Zugriff auf den System-TLS-Vertrauensdienst (`com.apple.trustd.agent`) in der Sandbox. Erforderlich für Go-basierte Tools wie `gh`, `gcloud` und `terraform`, um TLS-Zertifikate zu überprüfen, wenn `httpProxyPort` mit einem MITM-Proxy und benutzerdefinierter CA verwendet wird. **Reduziert die Sicherheit** durch Öffnen eines möglichen Datenexfiltrationspfads. Standard: false | `true` |
| `allowAppleEvents` | (Nur macOS) Erlauben Sie Sandbox-Befehlen, Apple Events zu senden. Erforderlich für `open`, `osascript` und Tools, die URLs in einem Browser öffnen, die ansonsten mit Fehler `-600` fehlschlagen. **Entfernt Code-Ausführungs-Isolation.** Sandbox-Befehle können andere Anwendungen unsandboxed ohne Benutzer-Aufforderung starten; sie können auch AppleScript-Befehle an laufende Anwendungen wie Terminal senden, unterliegen aber der Pro-App-macOS-Automatisierungs-Zustimmungs-Aufforderung (TCC). Wird nur aus Benutzer-, verwalteten oder CLI-Einstellungen berücksichtigt, nicht aus Projekteinstellungen. Standard: false | `true` |
| `bwrapPath` | (Nur verwaltete Einstellungen, Linux/WSL2) Absoluter Pfad zur bubblewrap (`bwrap`) Binärdatei. Überschreibt automatische Erkennung über `PATH`. Wird nur aus [verwalteten Einstellungen](/docs/de/settings#settings-files) berücksichtigt, nicht aus Benutzer- oder Projekteinstellungen. Nützlich, wenn `bwrap` an einem nicht standardmäßigen Ort in verwalteten Umgebungen installiert ist. | `/opt/admin/bwrap` |
| `socatPath` | (Nur verwaltete Einstellungen, Linux/WSL2) Absoluter Pfad zur `socat` Binärdatei, die für den Sandbox-Netzwerk-Proxy verwendet wird. Überschreibt automatische Erkennung über `PATH`. Wird nur aus verwalteten Einstellungen berücksichtigt. | `/opt/admin/socat` |
Sandbox-Pfadpräfixe
Pfade in `filesystem.allowWrite`, `filesystem.denyWrite`, `filesystem.denyRead`, `filesystem.allowRead` und `credentials.files` unterstützen diese Präfixe:
| Präfix | Bedeutung | Beispiel |
| :-------------------- | :---------------------------------------------------------------------------------------------- | :-------------------------------------------------------------------- |
| `/` | Absoluter Pfad vom Dateisystem-Root | `/tmp/build` bleibt `/tmp/build` |
| `~/` | Relativ zum Home-Verzeichnis | `~/.kube` wird zu `$HOME/.kube` |
| `./` oder kein Präfix | Relativ zum Projektstamm für Projekteinstellungen oder zu `~/.claude` für Benutzereinstellungen | `./output` in `.claude/settings.json` wird zu `/output` |
Das ältere `//path`-Präfix für absolute Pfade funktioniert weiterhin. Wenn Sie zuvor ein einzelnes Schrägstrich `/path` erwartet haben, um projektrelativ aufgelöst zu werden, wechseln Sie zu `./path`. Diese Syntax unterscheidet sich von [Read- und Edit-Berechtigungsregeln](/docs/de/permissions#read-and-edit), die `//path` für absolut und `/path` für projektrelativ verwenden. Sandbox-Dateisystempfade verwenden Standard-Konventionen: `/tmp/build` ist ein absoluter Pfad.
**Konfigurationsbeispiel:**
```json theme={null}
{
"sandbox": {
"enabled": true,
"autoAllowBashIfSandboxed": true,
"excludedCommands": ["docker *"],
"filesystem": {
"allowWrite": ["/tmp/build", "~/.kube"],
"denyRead": ["~/.aws/credentials"]
},
"network": {
"allowedDomains": ["github.com", "*.npmjs.org", "registry.yarnpkg.com"],
"deniedDomains": ["uploads.github.com"],
"allowUnixSockets": [
"/var/run/docker.sock"
],
"allowLocalBinding": true
}
}
}
```
**Dateisystem- und Netzwerkbeschränkungen** können auf zwei Arten konfiguriert werden, die zusammengeführt werden:
* **`sandbox.filesystem`-Einstellungen** (oben gezeigt): Steuern Sie Pfade an der OS-Level-Sandbox-Grenze. Diese Einschränkungen gelten für alle Subprozess-Befehle (z. B. `kubectl`, `terraform`, `npm`), nicht nur für Claudes Datei-Tools.
* **Berechtigungsregeln**: Verwenden Sie `Edit` Allow/Deny-Regeln, um den Zugriff auf Claudes Datei-Tool zu steuern, `Read` Deny-Regeln, um Lesevorgänge zu blockieren, und `WebFetch` Allow/Deny-Regeln, um Netzwerk-Domänen zu steuern. Pfade aus diesen Regeln werden auch in die Sandbox-Konfiguration zusammengeführt.
Zuschreibungseinstellungen
Claude Code fügt Git-Commits und Pull Requests Zuschreibungen hinzu. Diese werden separat konfiguriert:
* Commits verwenden [Git-Trailer](https://git-scm.com/docs/git-interpret-trailers) (wie `Co-Authored-By`) standardmäßig, die angepasst oder deaktiviert werden können
* Pull-Request-Beschreibungen sind Klartext
| Schlüssel | Beschreibung |
| :----------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `commit` | Zuschreibung für Git-Commits, einschließlich aller Trailer. Leere Zeichenkette blendet Commit-Zuschreibung aus |
| `pr` | Zuschreibung für Pull-Request-Beschreibungen. Leere Zeichenkette blendet Pull-Request-Zuschreibung aus |
| `sessionUrl` | Ob die claude.ai-Sitzungsverknüpfung als `Claude-Session` Trailer auf Commits und als Link in Pull-Request-Beschreibungen angehängt werden soll, wenn von einer Web- oder Remote Control-Sitzung aus ausgeführt wird. Standardmäßig `true`. Setzen Sie auf `false`, um den Link wegzulassen |
**Standard-Commit-Zuschreibung:**
```text theme={null}
Co-Authored-By: Claude Sonnet 5
```
Der Modellname im Trailer spiegelt das aktive Modell für die Sitzung wider.
**Standard-Pull-Request-Zuschreibung:**
```text theme={null}
🤖 Generated with [Claude Code](https://claude.com/claude-code)
```
**Beispiel:**
```json theme={null}
{
"attribution": {
"commit": "Generated with AI\n\nCo-Authored-By: AI ",
"pr": ""
}
}
```
Die Einstellung `attribution` hat Vorrang vor der veralteten Einstellung `includeCoAuthoredBy`. Um alle Zuschreibungen auszublenden, setzen Sie `commit` und `pr` auf leere Zeichenketten und `sessionUrl` auf `false`.
Dateivorschlag-Einstellungen
Konfigurieren Sie einen benutzerdefinierten Befehl für `@` Dateipath-Autovervollständigung. Der integrierte Dateivorschlag verwendet schnelle Dateisystem-Durchquerung, aber große Monorepos können von projektspezifischer Indizierung wie einem vorgefertigten Dateiindex oder benutzerdefinierten Tools profitieren.
```json theme={null}
{
"fileSuggestion": {
"type": "command",
"command": "~/.claude/file-suggestion.sh"
}
}
```
Der Befehl wird mit den gleichen Umgebungsvariablen wie [Hooks](/docs/de/hooks) ausgeführt, einschließlich `CLAUDE_PROJECT_DIR`. Er empfängt JSON über stdin mit einem `query`-Feld:
```json theme={null}
{"query": "src/comp"}
```
Geben Sie zeilengetrennte Dateipfade zu stdout aus (derzeit auf 15 begrenzt):
```text theme={null}
src/components/Button.tsx
src/components/Modal.tsx
src/components/Form.tsx
```
**Beispiel:**
```bash theme={null}
#!/bin/bash
query=$(cat | jq -r '.query')
# Replace your-repo-file-index with your own file search command
your-repo-file-index --query "$query" | head -20
```
Die Einstellung `footerLinksRegexes` rendert zusätzliche anklickbare Badges in der Fußzeile unter dem Eingabefeld. Verwenden Sie sie, um IDs, die von Projekt-CLIs gedruckt werden, wie Review-Tools und Issue-Tracker, in Sitzungslinks umzuwandeln.
Jeder Eintrag's `pattern` Regex wird gegen die Ausgabe der Runde abgeglichen: Tool-Ergebnisse, einschließlich Dateiinhalte und abgerufene Seiten, und Claudes eigene Antworten. `{name}` Platzhalter in `url` und `label` werden aus benannten Erfassungsgruppen im Pattern gefüllt.
Das folgende Beispiel rendert ein Badge, wenn eine Issue-Taste wie `PROJ-1234` in der Ausgabe der Runde erscheint. Die `(?...)` benannte Gruppe erfasst den Schlüssel, und `{key}` ersetzt ihn in der URL und dem Label:
```json ~/.claude/settings.json theme={null}
{
"footerLinksRegexes": [
{
"type": "regex",
"pattern": "\\b(?PROJ-\\d+)\\b",
"url": "https://issues.example.com/browse/{key}",
"label": "{key}"
}
]
}
```
Mit dieser Konfiguration wird, wenn `PROJ-1234` in einem Tool-Ergebnis oder in Claudes Antwort erscheint, ein `PROJ-1234` Chip in der Fußzeile angezeigt, der auf `https://issues.example.com/browse/PROJ-1234` verlinkt.
Die folgenden Einschränkungen gelten für jeden Eintrag:
| Einschränkung | Verhalten |
| :------------------ | :----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| URL-Ursprung | Erfasste Werte werden URL-kodiert und die konstruierte URL muss den Literal-Ursprung der Vorlage teilen. Eine Erfassung kann ein Pfad-Segment oder einen Query-Wert ausfüllen, kann aber nicht ändern, wohin der Link verweist |
| URL-Länge | Konstruierte URLs länger als 2048 Zeichen werden verworfen |
| URL-Schema | Muss `https`, `http` oder ein erkanntes Editor- oder Workspace-Deep-Link-Schema sein: `vscode`, `vscode-insiders`, `cursor`, `windsurf`, `zed`, `jetbrains`, `idea`, `slack`, `linear`, `notion`, `figma` |
| Label | Standardmäßig der abgeglichene Text und wird auf 28 Anzeigespalten gekürzt |
| Badge-Anzahl | Maximal 5 Badges werden gerendert. Das älteste wird durch neuere Übereinstimmungen verdrängt und `/clear` entfernt sie |
| Einstellungsbereich | Nur aus Benutzereinstellungen, dem Flag `--settings` und verwalteten Einstellungen gelesen. Ignoriert in Projekt `.claude/settings.json` und lokal `.claude/settings.local.json` |
Wenn eine Runde abgeschlossen ist, gleicht Claude Code jeden Eintrag's `pattern` Regex gegen die Ausgabe der Runde im Haupt-Thread ab, daher blockiert ein langsamer Regex die UI, bis er fertig ist. Verschachtelte Quantoren wie `(a+)+$` können gegen bestimmte Eingaben exponentiell lange dauern und die Sitzung einfrieren, daher halten Sie jeden `pattern` linear und vermeiden Sie Verschachtelung von `+` oder `*`.
Footer-Badges werden neben einer [benutzerdefinierten Statuszeile](/docs/de/statusline) gerendert, wenn eine konfiguriert ist; keiner ersetzt den anderen. Verwenden Sie eine Statuszeile für eine skriptgesteuerte Zeile, die ihren eigenen Inhalt aus Sitzungsdaten berechnet, und Footer-Badges, um IDs aus dem Gespräch in Links umzuwandeln, ohne ein Skript.
Hook-Konfiguration
Diese Einstellungen steuern, welche Hooks ausgeführt werden dürfen und worauf HTTP-Hooks zugreifen können. Die Einstellung `allowManagedHooksOnly` kann nur in [verwalteten Einstellungen](#settings-files) konfiguriert werden. Die URL- und Umgebungsvariablen-Allowlists können auf jeder Einstellungsebene gesetzt werden und werden über Quellen zusammengeführt.
**Verhalten, wenn `allowManagedHooksOnly` `true` ist:**
* Verwaltete Hooks und SDK-Hooks werden geladen
* Hooks von Plugins, die in verwalteten Einstellungen `enabledPlugins` erzwungen aktiviert sind, werden geladen. Dies ermöglicht es Administratoren, überprüfte Hooks über einen Organisations-Marketplace zu verteilen, während alles andere blockiert wird. Vertrauen wird durch vollständige `plugin@marketplace` ID gewährt, daher bleibt ein Plugin mit dem gleichen Namen aus einem anderen Marketplace blockiert
* Benutzer-Hooks, Projekt-Hooks und alle anderen Plugin-Hooks werden blockiert
**HTTP-Hook-URLs einschränken:**
Begrenzen Sie, auf welche URLs HTTP-Hooks abzielen können. Unterstützt `*` als Platzhalter zum Abgleichen. Wenn das Array definiert ist, werden HTTP-Hooks, die auf nicht übereinstimmende URLs abzielen, stillschweigend blockiert. Der Hostname-Abgleich ist case-insensitiv und ignoriert einen nachfolgenden FQDN-Punkt, was DNS-Semantik entspricht.
```json theme={null}
{
"allowedHttpHookUrls": ["https://hooks.example.com/*", "http://localhost:*"]
}
```
**HTTP-Hook-Umgebungsvariablen einschränken:**
Begrenzen Sie, welche Umgebungsvariablennamen HTTP-Hooks in Header-Werte interpolieren können. Die effektive `allowedEnvVars` jedes Hooks ist der Schnittpunkt seiner eigenen Liste und dieser Einstellung.
```json theme={null}
{
"httpHookAllowed EnvVars": ["MY_TOKEN", "HOOK_SECRET"]
}
```
Berechnen Sie verwaltete Einstellungen mit einem Policy Helper
Die Einstellung `policyHelper` verweist auf eine ausführbare Datei, die verwaltete Einstellungen beim Start dynamisch berechnet, sodass Administratoren Richtlinien von Geräteposition, Identität oder einem Remote-Service ableiten können, anstatt eine statische Datei zu verwenden. Konfigurieren Sie sie von MDM oder einer System-`managed-settings.json`-Datei. Claude Code ignoriert `policyHelper`, wenn es in einem anderen Bereich erscheint, einschließlich Benutzereinstellungen, Projekteinstellungen, der HKCU-Registry-Struktur und [Serververwalteten Einstellungen](/docs/de/server-managed-settings).
Die Einstellung akzeptiert diese Schlüssel:
| Schlüssel | Typ | Beschreibung |
| ------------------- | ------ | ------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `path` | string | Absoluter Pfad zur Helper-Ausführungsdatei |
| `timeoutMs` | number | Wie lange auf den Helper gewartet werden soll, bevor die Ausführung als fehlgeschlagen behandelt wird |
| `refreshIntervalMs` | number | Wie oft der Helper im Hintergrund erneut ausgeführt werden soll. Setzen Sie auf `0`, um die Aktualisierung zu deaktivieren, oder auf mindestens `60000` |
Der Helper schreibt eine JSON-Umschlag zu stdout. Setzen Sie die Einstellungen unter einen `managedSettings`-Schlüssel, anstatt auf der obersten Ebene, da ein bloßes Einstellungsobjekt mit `managedSettings` undefined analysiert wird und nichts anwendet:
```json theme={null}
{
"managedSettings": {
"permissions": { "deny": ["Read(//etc/secrets/**)"] }
},
"claudeMd": "# Organization context\n...",
"appendSystemPrompt": "Always cite the internal style guide."
}
```
Wenn der Helper `managedSettings` ausgibt, ersetzt dieses Objekt die dateibasierten verwalteten Einstellungen für die Ausführung. Wenn der Helper beim Start mit einem Fehler beendet wird, druckt Claude Code den Fehler und weigert sich zu starten, daher sollte ein Helper, der Ausfallsicherheit benötigt, aus seinem eigenen Cache bedienen und mit `0` beenden.
Einstellungspriorität
Einstellungen werden in Prioritätsreihenfolge angewendet. Von höchster zu niedrigster:
1. **Verwaltete Einstellungen** ([Serververwaltete](/docs/de/server-managed-settings), [MDM/OS-Richtlinien](#configuration-scopes) oder [Verwaltete Einstellungen](/docs/de/settings#settings-files))
* Richtlinien, die von IT über Server-Bereitstellung, MDM-Konfigurationsprofile, Registry-Richtlinien oder verwaltete Einstellungsdateien bereitgestellt werden
* Können nicht durch andere Ebenen überschrieben werden, einschließlich Befehlszeilenargumenten
* Innerhalb der verwalteten Ebene ist die Priorität: [`policyHelper`](#compute-managed-settings-with-a-policy-helper) Ausgabe, die bei Konfiguration die einzige verwaltete Quelle ist > Remote (claude.ai [Serververwaltete](/docs/de/server-managed-settings) oder [Claude-Apps-Gateway](/docs/de/claude-apps-gateway)-bereitgestellt) > MDM/OS-Richtlinien > dateibasierte (`managed-settings.d/*.json` + `managed-settings.json`) > HKCU-Registry (nur Windows). Nur eine verwaltete Quelle wird verwendet; Quellen werden nicht zusammengeführt, mit einer Ausnahme: die Sandbox-Sperr-Schlüssel `sandbox.network.allowManagedDomainsOnly` und `sandbox.filesystem.allowManagedReadPathsOnly`, mit ihren zugehörigen Allowlists, `allowAllClaudeAiMcps` und die Sandbox-Binär-Pfade `sandbox.bwrapPath` und `sandbox.socatPath` werden berücksichtigt, wenn eine Admin-kontrollierte verwaltete Quelle sie setzt; die benutzerbare HKCU-Ebene ist ausgeschlossen. Innerhalb der dateibasierten Ebene werden Drop-in-Dateien und die Basisdatei zusammengeführt.
* Eingebettete Hosts wie Claude Desktop können Richtlinien über die SDK `managedSettings` Option bereitstellen. Standardmäßig wird dies ignoriert, wenn eine Admin-bereitgestellte verwaltete Quelle vorhanden ist: Serververwaltete Einstellungen, eine MDM- oder OS-Richtlinie oder eine verwaltete Einstellungsdatei. Der benutzerbare HKCU-Registry-Fallback zählt nicht als Admin-bereitgestellte Quelle. Administratoren können sich anmelden, indem sie [`parentSettingsBehavior`](#available-settings) auf `"merge"` setzen. Die Werte des Embedders werden gefiltert, sodass sie verwaltete Richtlinien verschärfen, aber nicht lockern können.
2. **Befehlszeilenargumente**
* Temporäre Überschreibungen für eine bestimmte Sitzung. JSON, das über `--settings ` übergeben wird, wird mit dateibasierten Einstellungen unter Verwendung der gleichen Regeln wie die anderen Ebenen zusammengeführt: Ein hier gesetzter Schlüssel überschreibt den gleichen Schlüssel in lokalen, Projekt- oder Benutzereinstellungen, und das Weglassen eines Schlüssels lässt den Wert der niedrigeren Ebene bestehen
3. **Lokale Projekteinstellungen** (`.claude/settings.local.json`)
* Persönliche projektspezifische Einstellungen
4. **Gemeinsame Projekteinstellungen** (`.claude/settings.json`)
* Teamübergreifend gemeinsame Projekteinstellungen in der Versionskontrolle
5. **Benutzereinstellungen** (`~/.claude/settings.json`)
* Persönliche globale Einstellungen
Diese Hierarchie stellt sicher, dass Organisationsrichtlinien immer durchgesetzt werden, während Teams und Einzelpersonen ihre Erfahrung weiterhin anpassen können. Die gleiche Priorität gilt, ob Sie Claude Code von der CLI, der [VS Code-Erweiterung](/docs/de/vs-code) oder einer [JetBrains IDE](/docs/de/jetbrains) ausführen.
Wenn beispielsweise Ihre Benutzereinstellungen `permissions.defaultMode` auf `acceptEdits` setzen und die gemeinsamen Einstellungen eines Projekts es auf `default` setzen, gilt der Projektwert. Das folgende Beispiel zeigt, wie Array-wertige Einstellungen wie Berechtigungsregeln stattdessen kombiniert werden.
**Array-Einstellungen werden über Bereiche zusammengeführt.** Wenn die gleiche Array-wertige Einstellung (wie `sandbox.filesystem.allowWrite` oder `permissions.allow`) in mehreren Bereichen erscheint, werden die Arrays **verkettet und dedupliziert**, nicht ersetzt. Dies bedeutet, dass Bereiche mit niedrigerer Priorität Einträge hinzufügen können, ohne diejenigen mit höherer Priorität zu überschreiben, und umgekehrt. Wenn beispielsweise verwaltete Einstellungen `allowWrite` auf `["/opt/company-tools"]` setzen und ein Benutzer `["~/.kube"]` hinzufügt, sind beide Pfade in der endgültigen Konfiguration enthalten.
Zwei Array-Einstellungen werden nicht auf diese Weise zusammengeführt:
* [`fallbackModel`](#available-settings) ist eine geordnete Kette, bei der Position Bedeutung hat: Die Datei mit der höchsten Priorität, die sie definiert, liefert den gesamten Wert.
* [`availableModels`](#available-settings): {/* min-version: 2.1.175 */}Wenn die [höchste Priorität verwaltete Quelle](/docs/de/server-managed-settings#settings-precedence) sie definiert, wird diese Liste wie sie ist angewendet und Benutzer-, Projekt- und lokale Einträge können sie nicht erweitern. Über nicht verwaltete Bereiche werden die Arrays wie üblich zusammengeführt. Siehe [Zusammenführungsverhalten](/docs/de/model-config#merge-behavior).
Aktive Einstellungen überprüfen
Führen Sie `/status` aus und überprüfen Sie die Zeile `Setting sources` auf der Registerkarte **Status**. Sie listet jede Einstellungsebene auf, die Claude Code für diese Sitzung geladen hat:
* Wenn eine Ebene wie `User settings` oder `Project local settings` angezeigt wird, wird diese Datei gelesen.
* Wenn eine Ebene fehlt, wurde diese Datei nicht gefunden oder enthält keine Schlüssel.
Wenn [verwaltete Einstellungen](/docs/de/admin-setup#decide-how-settings-reach-devices) wirksam sind, zeigt der Eintrag den Bereitstellungskanal in Klammern an, z. B. `Enterprise managed settings (remote)`, `(plist)`, `(HKLM)`, `(HKCU)` oder `(file)`. Der `remote` Kanal deckt sowohl claude.ai Serververwaltete Einstellungen als auch [Claude-Apps-Gateway](/docs/de/claude-apps-gateway)-bereitgestellte Richtlinien ab.
Die Zeile bestätigt, welche Dateien gelesen werden, nicht welche Ebene jeden einzelnen Schlüssel bereitgestellt hat. Die Registerkarte **Config** im gleichen Dialog bearbeitet integrierte Umschalter wie Thema und ausführliche Ausgabe, nicht Ihre `settings.json`-Inhalte.
Wenn eine Einstellungsdatei Fehler enthält, wie ungültiges JSON oder einen Wert, der die Validierung nicht besteht, zeigt Claude Code beim Start einen Setup-Probleme-Hinweis an und `/status` listet die betroffenen Dateien auf. Führen Sie `/doctor` aus, um die Details für jeden Fehler zu sehen.
Wichtige Punkte zum Konfigurationssystem
* **Speicherdateien (`CLAUDE.md`)**: Enthalten Anweisungen und Kontext, die Claude beim Start lädt
* **Einstellungsdateien (JSON)**: Konfigurieren Sie Berechtigungen, Umgebungsvariablen und Werkzeugverhalten
* **Skills**: Benutzerdefinierte Aufforderungen, die mit `/skill-name` aufgerufen oder von Claude automatisch geladen werden können
* **MCP-Server**: Erweitern Sie Claude Code mit zusätzlichen Tools und Integrationen
* **Priorität**: Höherrangige Konfigurationen (Verwaltet) überschreiben niedrigere (Benutzer/Projekt)
* **Vererbung**: Einstellungen werden zusammengeführt; Skalarwerte aus höherer Priorität überschreiben, und Arrays werden verkettet, mit zwei Ausnahmen, die in der [Array-Merge-Notiz](#settings-precedence) beschrieben sind
Systemaufforderung
Claudes interne Systemaufforderung wird nicht veröffentlicht. Um benutzerdefinierte Anweisungen hinzuzufügen, verwenden Sie `CLAUDE.md`-Dateien oder das Flag `--append-system-prompt`.
Ausschließen sensibler Dateien
Um zu verhindern, dass Claude Code auf Dateien mit sensiblen Informationen wie API-Schlüsseln, Geheimnissen und Umgebungsdateien zugreift, verwenden Sie die Einstellung `permissions.deny` in Ihrer `.claude/settings.json`-Datei:
```json theme={null}
{
"permissions": {
"deny": [
"Read(./.env)",
"Read(./.env.*)",
"Read(./secrets/**)",
"Read(./config/credentials.json)",
"Read(./build)"
]
}
}
```
Dies ersetzt die veraltete Konfiguration `ignorePatterns`. Dateien, die diesen Mustern entsprechen, werden von der Dateiermittlung und Suchergebnissen ausgeschlossen, und Lesevorgänge auf diesen Dateien werden verweigert.
Subagent-Konfiguration
Claude Code unterstützt benutzerdefinierte KI-Subagents, die auf Benutzer- und Projektebene konfiguriert werden können. Diese Subagents werden als Markdown-Dateien mit YAML-Frontmatter gespeichert:
* **Benutzer-Subagents**: `~/.claude/agents/`, verfügbar über alle Ihre Projekte
* **Projekt-Subagents**: `.claude/agents/`, spezifisch für Ihr Projekt und teilbar mit Ihrem Team
Subagent-Dateien definieren spezialisierte KI-Assistenten mit benutzerdefinierten Aufforderungen und Werkzeugberechtigungen. Erfahren Sie mehr über das Erstellen und Verwenden von Subagents in der [Subagents-Dokumentation](/docs/de/sub-agents).
Plugin-Konfiguration
Claude Code unterstützt ein Plugin-System, mit dem Sie die Funktionalität mit Skills, Agents, Hooks und MCP-Servern erweitern können. Plugins werden über Marketplaces verteilt und können auf Benutzer- und Repository-Ebene konfiguriert werden.
Plugin-Einstellungen
Plugin-bezogene Einstellungen in `settings.json`:
```json theme={null}
{
"enabledPlugins": {
"formatter@acme-tools": true,
"deployer@acme-tools": true,
"analyzer@security-plugins": false
},
"extraKnownMarketplaces": {
"acme-tools": {
"source": {
"source": "github",
"repo": "acme-corp/claude-plugins"
}
}
}
}
```
`enabledPlugins`
Steuert, welche Plugins aktiviert sind. Format: `"plugin-name@marketplace-name": true/false`. Ein Plugin ohne Eintrag in einem beliebigen Bereich fällt auf seinen [`defaultEnabled`](/docs/de/plugins-reference#default-enablement) Wert zurück.
**Bereiche**:
* **Benutzereinstellungen** (`~/.claude/settings.json`): Persönliche Plugin-Voreinstellungen
* **Projekteinstellungen** (`.claude/settings.json`): Projektspezifische Plugins, die mit dem Team geteilt werden
* **Lokale Einstellungen** (`.claude/settings.local.json`): Pro-Maschinen-Überschreibungen, gitignored wenn Claude Code es erstellt
* **Verwaltete Einstellungen** (`managed-settings.json`): Organisationsweite Richtlinien-Überschreibungen, die die Installation auf allen Ebenen blockieren und das Plugin aus dem Marketplace ausblenden
Projekteinstellungen haben Vorrang vor Benutzereinstellungen, daher führt das Setzen eines Plugins auf `false` in `~/.claude/settings.json` nicht dazu, dass ein Plugin deaktiviert wird, das die `.claude/settings.json` des Projekts aktiviert. Um sich von einem projektaktivierten Plugin auf Ihrem Computer abzumelden, setzen Sie es stattdessen auf `false` in `.claude/settings.local.json`.
Plugins, die durch verwaltete Einstellungen erzwungen aktiviert sind, können auf diese Weise nicht deaktiviert werden, da verwaltete Einstellungen lokale Einstellungen überschreiben.
Das Aktivieren eines Plugins aus einer externen Quelle wie einem GitHub-Repository oder npm-Paket in der `.claude/settings.json` eines Projekts installiert es nicht für andere Personen. Ab Claude Code v2.1.195 fragt jeder Pfad, der Plugins lädt, jeden Benutzer auf, [das Plugin zu installieren und zu vertrauen](/docs/de/discover-plugins#configure-team-marketplaces), bevor es ausgeführt wird.
**Beispiel**:
```json theme={null}
{
"enabledPlugins": {
"code-formatter@team-tools": true,
"deployment-tools@team-tools": true,
"experimental-features@personal": false
}
}
```
`pluginConfigs`
Speichert die nicht-sensiblen Optionswerte, die die [`userConfig`](/docs/de/plugins-reference#user-configuration) Eingabeaufforderung eines Plugins sammelt, indiziert nach Plugin-ID. Claude Code schreibt diesen Schlüssel in Benutzereinstellungen, wenn Sie das Konfigurationsdialogfeld des Plugins ausfüllen, sodass Sie ihn nicht manuell bearbeiten müssen. Sensible Optionen werden stattdessen im macOS Keychain gespeichert oder in `~/.claude/.credentials.json` auf Plattformen ohne unterstützten Keychain.
Dieses Beispiel speichert eine Option für ein Plugin, das vom `acme-tools` Marketplace installiert wurde:
```json theme={null}
{
"pluginConfigs": {
"deployer@acme-tools": {
"options": {
"api_endpoint": "https://api.example.com"
}
}
}
}
```
`pluginConfigs` wird nur aus Benutzereinstellungen, dem `--settings` Flag und verwalteten Einstellungen gelesen. Einträge in der `.claude/settings.json` oder `.claude/settings.local.json` eines Projekts werden ignoriert, da diese Werte in Plugin-Hook-, MCP- und LSP-Konfigurationen ersetzt werden, und ein geklontes Repository darf sie nicht bereitstellen. Vor v2.1.207 wurden auch Projekt- und lokale Einstellungen gelesen.
Definiert zusätzliche Marketplaces, die für das Repository verfügbar gemacht werden sollten. Normalerweise in Repository-Ebenen-Einstellungen verwendet, um sicherzustellen, dass Teamkollegen Zugriff auf erforderliche Plugin-Quellen haben.
**Wenn ein Repository `extraKnownMarketplaces` enthält**:
1. Teamkollegen werden aufgefordert, den Marketplace zu installieren, wenn sie dem Ordner vertrauen
2. Teamkollegen werden dann aufgefordert, Plugins aus diesem Marketplace zu installieren
3. Benutzer können unerwünschte Marketplaces oder Plugins überspringen (in Benutzereinstellungen gespeichert)
4. Die Installation respektiert Vertrauensgrenzen und erfordert explizite Zustimmung
**Beispiel**:
```json theme={null}
{
"extraKnownMarketplaces": {
"acme-tools": {
"source": {
"source": "github",
"repo": "acme-corp/claude-plugins"
}
},
"security-plugins": {
"source": {
"source": "git",
"url": "https://git.example.com/security/plugins.git"
}
}
}
}
```
**Marketplace-Quellentypen**:
* `github`: GitHub-Repository (verwendet `repo`)
* `git`: Beliebige Git-URL (verwendet `url`)
* `directory`: Lokaler Dateisystem-Pfad (verwendet `path`, nur für Entwicklung)
* `hostPattern`: Regex-Muster zum Abgleichen von Marketplace-Hosts (verwendet `hostPattern`)
* `settings`: Inline-Marketplace, der direkt in settings.json deklariert wird, ohne ein separates gehostetes Repository (verwendet `name` und `plugins`)
Der `git` Quellentyp funktioniert mit jedem Git-Hosting-Service, einschließlich selbstgehosteter GitLab und Bitbucket. Claude Code klont das Repository mit der gleichen Authentifizierung, die `git clone` auf dieser Maschine verwenden würde: konfigurierte Credential Helper oder SSH-Schlüssel. Ein Provider-Token wie `GITHUB_TOKEN` wird nur durch einen Credential Helper wirksam, der ihn liest. Siehe [Private Repositories](/docs/de/plugin-marketplaces#private-repositories) für Setup-Details.
Für `github` und `git` Quellen setzen Sie `"skipLfs": true` innerhalb des `source` Objekts (neben `repo` oder `url`), um Git LFS-Downloads zu überspringen, wenn Claude Code das Marketplace-Repository klont oder aktualisiert. LFS-Zeigerdateien bleiben als Zeiger erhalten, anstatt ihren Inhalt herunterzuladen. Verwenden Sie dies, wenn das Repository große LFS-Objekte enthält, die nicht mit Plugin-Inhalten zusammenhängen. {/* min-version: 2.1.153 */}Erfordert Claude Code v2.1.153 oder später.
Jeder Marketplace-Eintrag akzeptiert auch einen optionalen `autoUpdate` Boolean. Setzen Sie `"autoUpdate": true` neben `source`, um Claude Code zu veranlassen, diesen Marketplace zu aktualisieren und seine installierten Plugins im Hintergrund nach dem Start zu aktualisieren. Wenn nicht angegeben, verwenden offizielle Anthropic-Marketplaces standardmäßig `true` und alle anderen Marketplaces standardmäßig `false`. Siehe [Automatische Aktualisierungen konfigurieren](/docs/de/discover-plugins#configure-auto-updates).
Verwenden Sie `source: 'settings'`, um einen kleinen Satz von Plugins inline zu deklarieren, ohne ein gehostetes Marketplace-Repository einzurichten. Plugins, die hier aufgelistet sind, müssen externe Quellen wie GitHub oder npm referenzieren. Sie müssen weiterhin jedes Plugin separat in `enabledPlugins` aktivieren.
```json theme={null}
{
"extraKnownMarketplaces": {
"team-tools": {
"source": {
"source": "settings",
"name": "team-tools",
"plugins": [
{
"name": "code-formatter",
"source": {
"source": "github",
"repo": "acme-corp/code-formatter"
}
}
]
}
}
}
}
```
`strictKnownMarketplaces`
**Nur verwaltete Einstellungen**: Steuert, welche Plugin-Marketplaces Benutzer hinzufügen und Plugins installieren dürfen. Diese Einstellung kann nur in [verwalteten Einstellungen](/docs/de/settings#settings-files) konfiguriert werden und bietet Administratoren strikte Kontrolle über Marketplace-Quellen.
**Verwaltete Einstellungsdatei-Speicherorte**:
* **macOS**: `/Library/Application Support/ClaudeCode/managed-settings.json`
* **Linux und WSL**: `/etc/claude-code/managed-settings.json`
* **Windows**: `C:\Program Files\ClaudeCode\managed-settings.json`
**Wichtige Merkmale**:
* Nur in verwalteten Einstellungen verfügbar (`managed-settings.json`)
* Kann nicht durch Benutzer- oder Projekteinstellungen überschrieben werden (höchste Priorität)
* Durchgesetzt VOR Netzwerk-/Dateisystem-Operationen, sodass blockierte Quellen nie ausgeführt werden
* Verwendet exakte Übereinstimmung für Quellspezifikationen (einschließlich `ref`, `path` für Git-Quellen), außer `hostPattern` und `pathPattern`, die Regex-Abgleich verwenden
**Allowlist-Verhalten**:
* `undefined` (Standard): Keine Einschränkungen, sodass Benutzer jeden Marketplace hinzufügen können
* Leeres Array `[]`: Vollständiger Lockdown, sodass Benutzer keine neuen Marketplaces hinzufügen können
* Liste von Quellen: Benutzer können nur Marketplaces hinzufügen, die genau übereinstimmen
**Alle unterstützten Quellentypen**:
Die Allowlist unterstützt mehrere Marketplace-Quellentypen. Die meisten Quellen verwenden exakte Übereinstimmung, während `hostPattern` und `pathPattern` Regex-Abgleich gegen den Marketplace-Host und den Dateisystem-Pfad verwenden.
1. **GitHub-Repositories**:
```json theme={null}
{ "source": "github", "repo": "acme-corp/approved-plugins" }
{ "source": "github", "repo": "acme-corp/security-tools", "ref": "v2.0" }
{ "source": "github", "repo": "acme-corp/plugins", "ref": "main", "path": "marketplace" }
```
Felder: `repo` (erforderlich), `ref` (optional: Branch oder Tag), `path` (optional: Unterverzeichnis)
2. **Git-Repositories**:
```json theme={null}
{ "source": "git", "url": "https://gitlab.example.com/tools/plugins.git" }
{ "source": "git", "url": "https://bitbucket.org/acme-corp/plugins.git", "ref": "production" }
{ "source": "git", "url": "ssh://git@git.example.com/plugins.git", "ref": "v3.1", "path": "approved" }
```
Felder: `url` (erforderlich), `ref` (optional: Branch oder Tag), `path` (optional: Unterverzeichnis)
3. **URL-basierte Marketplaces**:
```json theme={null}
{ "source": "url", "url": "https://plugins.example.com/marketplace.json" }
{ "source": "url", "url": "https://cdn.example.com/marketplace.json", "headers": { "Authorization": "Bearer ${TOKEN}" } }
```
Felder: `url` (erforderlich), `headers` (optional: HTTP-Header für authentifizierten Zugriff)
URL-basierte Marketplaces laden nur die `marketplace.json`-Datei herunter. Sie laden keine Plugin-Dateien vom Server herunter. Plugins in URL-basierten Marketplaces müssen externe Quellen (GitHub, npm oder Git-URLs) verwenden, anstatt relative Pfade. Für Plugins mit relativen Pfaden verwenden Sie stattdessen einen Git-basierten Marketplace. Siehe [Troubleshooting](/docs/de/plugin-marketplaces#plugins-with-relative-paths-fail-in-url-based-marketplaces) für Details.
4. **NPM-Pakete**:
```json theme={null}
{ "source": "npm", "package": "@acme-corp/claude-plugins" }
{ "source": "npm", "package": "@acme-corp/approved-marketplace" }
```
Felder: `package` (erforderlich, unterstützt scoped Pakete)
5. **Dateipfade**:
```json theme={null}
{ "source": "file", "path": "/usr/local/share/claude/acme-marketplace.json" }
{ "source": "file", "path": "/opt/acme-corp/plugins/marketplace.json" }
```
Felder: `path` (erforderlich: absoluter Pfad zur marketplace.json-Datei)
6. **Verzeichnispfade**:
```json theme={null}
{ "source": "directory", "path": "/usr/local/share/claude/acme-plugins" }
{ "source": "directory", "path": "/opt/acme-corp/approved-marketplaces" }
```
Felder: `path` (erforderlich: absoluter Pfad zum Verzeichnis mit `.claude-plugin/marketplace.json`)
7. **Host-Muster-Abgleich**:
```json theme={null}
{ "source": "hostPattern", "hostPattern": "^github\\.example\\.com$" }
{ "source": "hostPattern", "hostPattern": "^gitlab\\.internal\\.example\\.com$" }
```
Felder: `hostPattern` (erforderlich: Regex-Muster zum Abgleich gegen den Marketplace-Host)
Verwenden Sie Host-Muster-Abgleich, wenn Sie alle Marketplaces von einem bestimmten Host erlauben möchten, ohne jedes Repository einzeln aufzuzählen. Dies ist nützlich für Organisationen mit internen GitHub Enterprise oder GitLab-Servern, auf denen Entwickler ihre eigenen Marketplaces erstellen.
Host-Extraktion nach Quellentyp:
* `github`: passt immer gegen `github.com`
* `git`: extrahiert Hostname aus der URL (unterstützt sowohl HTTPS als auch SSH-Formate)
* `url`: extrahiert Hostname aus der URL
* `npm`, `file`, `directory`: nicht unterstützt für Host-Muster-Abgleich
8. **Pfad-Muster-Abgleich**:
```json theme={null}
{ "source": "pathPattern", "pathPattern": "^/opt/approved/" }
{ "source": "pathPattern", "pathPattern": ".*" }
```
Felder: `pathPattern` (erforderlich: Regex-Muster, das gegen das `path`-Feld von `file` und `directory`-Quellen abgeglichen wird)
Verwenden Sie Pfad-Muster-Abgleich, um dateisystem-basierte Marketplaces neben `hostPattern`-Einschränkungen für Netzwerk-Quellen zu erlauben. Setzen Sie `".*"` auf alle lokalen Pfade, oder ein engeres Muster, um auf bestimmte Verzeichnisse zu beschränken.
**Konfigurationsbeispiele**:
Beispiel: Nur bestimmte Marketplaces erlauben:
```json theme={null}
{
"strictKnownMarketplaces": [
{
"source": "github",
"repo": "acme-corp/approved-plugins"
},
{
"source": "github",
"repo": "acme-corp/security-tools",
"ref": "v2.0"
},
{
"source": "url",
"url": "https://plugins.example.com/marketplace.json"
},
{
"source": "npm",
"package": "@acme-corp/compliance-plugins"
}
]
}
```
Beispiel: Alle Marketplace-Ergänzungen deaktivieren:
```json theme={null}
{
"strictKnownMarketplaces": []
}
```
Beispiel: Alle Marketplaces von einem internen Git-Server erlauben:
```json theme={null}
{
"strictKnownMarketplaces": [
{
"source": "hostPattern",
"hostPattern": "^github\\.example\\.com$"
}
]
}
```
**Anforderungen für exakte Übereinstimmung**:
Marketplace-Quellen müssen genau übereinstimmen, damit eine Benutzer-Ergänzung erlaubt wird. Für Git-basierte Quellen (`github` und `git`) umfasst dies alle optionalen Felder:
* Das `repo` oder `url` muss genau übereinstimmen
* Das `ref`-Feld muss genau übereinstimmen (oder beide sind undefined)
* Das `path`-Feld muss genau übereinstimmen (oder beide sind undefined)
Beispiele von Quellen, die nicht übereinstimmen:
```json theme={null}
// Diese sind UNTERSCHIEDLICHE Quellen:
{ "source": "github", "repo": "acme-corp/plugins" }
{ "source": "github", "repo": "acme-corp/plugins", "ref": "main" }
// Diese sind auch UNTERSCHIEDLICH:
{ "source": "github", "repo": "acme-corp/plugins", "path": "marketplace" }
{ "source": "github", "repo": "acme-corp/plugins" }
```
**Vergleich mit `extraKnownMarketplaces`**:
| Aspekt | `strictKnownMarketplaces` | `extraKnownMarketplaces` |
| ----------------------------- | ----------------------------------------- | ------------------------------------------------ |
| **Zweck** | Durchsetzung von Organisationsrichtlinien | Team-Komfort |
| **Einstellungsdatei** | Nur `managed-settings.json` | Beliebige Einstellungsdatei |
| **Verhalten** | Blockiert nicht-allowlisted Ergänzungen | Auto-installiert fehlende Marketplaces |
| **Wann durchgesetzt** | Vor Netzwerk-/Dateisystem-Operationen | Nach Benutzer-Vertrauensaufforderung |
| **Kann überschrieben werden** | Nein (höchste Priorität) | Ja (durch höherrangige Einstellungen) |
| **Quellenformat** | Direktes Quellobjekt | Benannter Marketplace mit verschachtelter Quelle |
| **Anwendungsfall** | Compliance, Sicherheitsbeschränkungen | Onboarding, Standardisierung |
**Formatunterschied**:
`strictKnownMarketplaces` verwendet direkte Quellobjekte:
```json theme={null}
{
"strictKnownMarketplaces": [
{ "source": "github", "repo": "acme-corp/plugins" }
]
}
```
`extraKnownMarketplaces` erfordert benannte Marketplaces:
```json theme={null}
{
"extraKnownMarketplaces": {
"acme-tools": {
"source": { "source": "github", "repo": "acme-corp/plugins" }
}
}
}
```
**Beide zusammen verwenden**:
`strictKnownMarketplaces` ist ein Richtlinien-Gate: Es steuert, was Benutzer hinzufügen dürfen, registriert aber keine Marketplaces. Um einen Marketplace sowohl einzuschränken als auch für alle Benutzer vorzuregistrieren, setzen Sie beide in `managed-settings.json`:
```json theme={null}
{
"strictKnownMarketplaces": [
{ "source": "github", "repo": "acme-corp/plugins" }
],
"extraKnownMarketplaces": {
"acme-tools": {
"source": { "source": "github", "repo": "acme-corp/plugins" }
}
}
}
```
Mit nur `strictKnownMarketplaces` gesetzt, können Benutzer den erlaubten Marketplace weiterhin manuell über `/plugin marketplace add` hinzufügen, aber er ist nicht automatisch verfügbar.
**Wichtige Hinweise**:
* Einschränkungen werden VOR Netzwerkanfragen oder Dateisystem-Operationen überprüft
* Wenn blockiert, sehen Benutzer klare Fehlermeldungen, die angeben, dass die Quelle durch verwaltete Richtlinie blockiert ist
* Die Einschränkung wird beim Hinzufügen und beim Installieren, Aktualisieren, Aktualisieren und automatischen Aktualisieren von Plugins durchgesetzt. Ein Marketplace, der vor dem Festlegen der Richtlinie hinzugefügt wurde, kann nicht mehr zum Installieren oder Aktualisieren von Plugins verwendet werden, sobald seine Quelle nicht mehr mit der Allowlist übereinstimmt
* Verwaltete Einstellungen haben die höchste Priorität und können nicht überschrieben werden
Siehe [Verwaltete Marketplace-Einschränkungen](/docs/de/plugin-marketplaces#managed-marketplace-restrictions) für Dokumentation für Benutzer.
`strictPluginOnlyCustomization`
**Nur verwaltete Einstellungen**: blockiert Skills, Agents, Hooks und MCP-Server aus Benutzer- und Projektquellen, sodass sie nur aus Plugins oder verwalteten Einstellungen stammen können. Kombinieren Sie es mit `strictKnownMarketplaces`, um die vollständige Anpassungs-Lieferkette zu steuern: Die Marketplace-Allowlist steuert, welche Plugins Benutzer installieren können, und diese Einstellung blockiert alles, das nicht aus einem Plugin oder aus verwalteten Einstellungen stammt.
Der Wert ist entweder `true`, um alle vier Oberflächen zu sperren, oder ein Array, das die zu sperrenden Oberflächen benennt:
```json theme={null}
{
"strictPluginOnlyCustomization": ["skills", "hooks"]
}
```
Für jede gesperrte Oberfläche überspringt Claude Code Benutzer- und Projektquellen und lädt nur Plugin-bereitgestellte und verwaltete Quellen:
| Oberfläche | Blockiert wenn gesperrt | Lädt weiterhin |
| :--------- | :------------------------------------------------------- | :------------------------------------------------------------------------------ |
| `skills` | `~/.claude/skills/`, `.claude/skills/` | Plugin-Skills, gebündelte Skills, Skills im verwalteten Richtlinienverzeichnis |
| `agents` | `~/.claude/agents/`, `.claude/agents/` | Plugin-Agents, integrierte Agents, Agents im verwalteten Richtlinienverzeichnis |
| `hooks` | Hooks in Benutzer-, Projekt- und lokalen `settings.json` | Plugin-Hooks, Hooks in verwalteten Einstellungen |
| `mcp` | Server in `~/.claude.json` und `.mcp.json` | Plugin-MCP-Server, [`managed-mcp.json`](/docs/de/managed-mcp) Server |
Oberflächennamen, die eine Claude Code-Version nicht erkennt, werden ignoriert, anstatt die Einstellungsdatei fehlschlagen zu lassen, sodass Sie neue Oberflächennamen hinzufügen können, bevor alle Clients aktualisiert wurden.
Verwalten von Plugins
Verwenden Sie den Befehl `/plugin`, um Plugins interaktiv zu verwalten:
* Durchsuchen Sie verfügbare Plugins aus Marketplaces
* Installieren/Deinstallieren Sie Plugins
* Aktivieren/Deaktivieren Sie Plugins
* Zeigen Sie Plugin-Details an (bereitgestellte Skills, Agents, Hooks)
* Fügen Sie Marketplaces hinzu/entfernen Sie sie
Erfahren Sie mehr über das Plugin-System in der [Plugins-Dokumentation](/docs/de/plugins).
Umgebungsvariablen
Umgebungsvariablen ermöglichen es Ihnen, das Verhalten von Claude Code zu steuern, ohne Einstellungsdateien zu bearbeiten. Jede Variable kann auch in [`settings.json`](#available-settings) unter dem Schlüssel `env` konfiguriert werden, um sie auf jede Sitzung anzuwenden oder für Ihr Team bereitzustellen.
Siehe die [Umgebungsvariablen-Referenz](/docs/de/env-vars) für die vollständige Liste.
Claude Code hat Zugriff auf eine Reihe von Tools zum Lesen, Bearbeiten, Suchen, Ausführen von Befehlen und Orchestrieren von Subagents. Tool-Namen sind die genauen Zeichenketten, die Sie in Berechtigungsregeln und Hook-Matchern verwenden.
Siehe die [Tools-Referenz](/docs/de/tools-reference) für die vollständige Liste und Details zum Bash-Tool-Verhalten.
Siehe auch
* [Berechtigungen](/docs/de/permissions): Berechtigungssystem, Regelsyntax, werkzeugspezifische Muster und verwaltete Richtlinien
* [Authentifizierung](/docs/de/authentication): Richten Sie Benutzerzugriff auf Claude Code ein
* [Konfiguration debuggen](/docs/de/debug-your-config): Diagnostizieren Sie, warum eine Einstellung, ein Hook oder ein MCP-Server nicht wirksam wird
* [Troubleshooting bei Installation und Anmeldung](/docs/de/troubleshoot-install): Installations-, Authentifizierungs- und Plattformprobleme