2> Fetch the complete documentation index at: https://code.claude.com/docs/llms.txt2> Fetch the complete documentation index at: https://code.claude.com/docs/llms.txt
3> Use this file to discover all available pages before exploring further.3> Use this file to discover all available pages before exploring further.
4 4
5# Claude Code-Einstellungen5# Einstellungsdateien und Priorität
6 6
7> Konfigurieren Sie Claude Code mit globalen und projektbezogenen Einstellungen sowie Umgebungsvariablen.7> Ändern Sie Claude Code-Einstellungen, wählen Sie den Bereich aus, zu dem ein Schlüssel gehört, überprüfen Sie die Änderung, und erfahren Sie, welchen Wert Claude Code verwendet, wenn ein Schlüssel an mehreren Stellen gesetzt ist.
8 8
9Claude 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. 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`.9export const SettingsPrecedence = () => {
10 10 const LEVELS = [{
11<h2 id="configuration-scopes">11 n: 1,
12 Konfigurationsbereiche12 name: 'Managed settings',
13</h2>13 file: 'managed-settings.json, MDM, or the claude.ai console',
14 14 who: 'Your organization',
15Claude 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.15 w: 390
16 16 }, {
17<h3 id="available-scopes">17 n: 2,
18 Verfügbare Bereiche18 name: 'Command line',
19</h3>19 file: 'claude --settings',
20 who: 'You, this session',
21 w: 420
22 }, {
23 n: 3,
24 name: 'Project local',
25 file: '.claude/settings.local.json',
26 who: 'You, this project',
27 w: 480
28 }, {
29 n: 4,
30 name: 'Shared project',
31 file: '.claude/settings.json',
32 who: 'Everyone in the project',
33 w: 540
34 }, {
35 n: 5,
36 name: 'User',
37 file: '~/.claude/settings.json',
38 who: 'You, every project',
39 w: 600
40 }];
41 const W = 760;
42 const ROW = 58;
43 const GAP = 8;
44 const TOP = 34;
45 const H = TOP + LEVELS.length * (ROW + GAP) + 30;
46 const cx = W / 2;
47 const mono = 'var(--font-mono, ui-monospace, SFMono-Regular, Menlo, monospace)';
48 const sans = 'var(--font-sans, system-ui, -apple-system, sans-serif)';
49 return <div className="sp-root not-prose" role="img" aria-label="Settings precedence, highest first: managed settings, command line, project local, shared project, user. A key set at a higher level overrides the same key set lower down.">
50 <style>{`
51 .sp-root { --sp-text: #1A1918; --sp-sub: #5E5D59; --sp-faint: #8A8880; --sp-fill: #F5F4EF; --sp-stroke: rgba(0,0,0,0.12); --sp-top: #D97757; --sp-top-fill: rgba(217,119,87,0.14); --sp-arrow: #8A8880; margin: 1.25rem 0; }
52 .dark .sp-root { --sp-text: #F1EFE9; --sp-sub: #B8B5AD; --sp-faint: #8A8880; --sp-fill: #24231F; --sp-stroke: rgba(255,255,255,0.12); --sp-top-fill: rgba(217,119,87,0.22); --sp-arrow: #8A8880; }
53 .sp-root svg { width: 100%; height: auto; display: block; max-width: ${W}px; margin: 0 auto; }
54 `}</style>
55 <svg viewBox={`0 0 ${W} ${H}`} xmlns="http://www.w3.org/2000/svg">
56 <text x={cx} y={18} textAnchor="middle" fontFamily={sans} fontSize="12.5" fontWeight="600" fill="var(--sp-sub)">Highest precedence</text>
57 {LEVELS.map((l, i) => {
58 const y = TOP + i * (ROW + GAP);
59 const x = cx - l.w / 2;
60 const top = i === 0;
61 return <g key={l.n}>
62 <rect x={x} y={y} width={l.w} height={ROW} rx={10} fill={top ? 'var(--sp-top-fill)' : 'var(--sp-fill)'} stroke={top ? 'var(--sp-top)' : 'var(--sp-stroke)'} strokeWidth={top ? 1.5 : 1} />
63 <text x={x + 14} y={y + 24} fontFamily={sans} fontSize="14" fontWeight="600" fill="var(--sp-text)">{l.n}. {l.name}</text>
64 <text x={x + 14} y={y + 43} fontFamily={mono} fontSize="11.5" fill="var(--sp-sub)">{l.file}</text>
65 <text x={x + l.w - 14} y={y + 24} textAnchor="end" fontFamily={sans} fontSize="12" fill="var(--sp-faint)">{l.who}</text>
66 </g>;
67 })}
68 <text x={cx} y={H - 10} textAnchor="middle" fontFamily={sans} fontSize="12.5" fontWeight="600" fill="var(--sp-sub)">Lowest precedence</text>
69 <g stroke="var(--sp-arrow)" strokeWidth="1.5" fill="none">
70 <line x1={W - 40} y1={TOP + 10} x2={W - 40} y2={H - 38} />
71 <path d={`M ${W - 46} ${TOP + 18} L ${W - 40} ${TOP + 10} L ${W - 34} ${TOP + 18}`} />
72 </g>
73 <text x={W - 40} y={H - 22} textAnchor="middle" fontFamily={sans} fontSize="10.5" fill="var(--sp-faint)">overrides</text>
74 </svg>
75 </div>;
76};
77
78export const SettingsScope = ({defaultSelected = 'project'}) => {
79 const FILES = [{
80 id: 'user',
81 path: '~/.claude/settings.json'
82 }, {
83 id: 'project',
84 path: 'acme-app/.claude/settings.json'
85 }, {
86 id: 'local',
87 path: 'acme-app/.claude/settings.local.json'
88 }, {
89 id: 'managed',
90 path: 'Managed settings',
91 ring: 'managed-settings.json, MDM, or the claude.ai console'
92 }];
93 const SHORT = {
94 user: '~/.claude/settings.json',
95 project: 'acme-app/.claude/settings.json',
96 local: 'acme-app/.claude/settings.local.json',
97 managed: 'managed-settings.json, MDM, or the claude.ai console'
98 };
99 const TILE_MARK = {
100 project: 'settings.json',
101 local: 'settings.local.json'
102 };
103 const initial = FILES.some(f => f.id === defaultSelected) ? defaultSelected : 'project';
104 const [sel, setSel] = useState(initial);
105 const [scale, setScale] = useState(1);
106 const [isFullscreen, setIsFullscreen] = useState(false);
107 const rootRef = useRef(null);
108 const frameRef = useRef(null);
109 const CANVAS_W = 862;
110 const CANVAS_H = 240;
111 useEffect(() => {
112 const el = frameRef.current;
113 if (!el) return;
114 const measure = () => setScale(Math.min(1, el.clientWidth / CANVAS_W));
115 measure();
116 if (typeof ResizeObserver === 'undefined') {
117 window.addEventListener('resize', measure);
118 return () => window.removeEventListener('resize', measure);
119 }
120 const ro = new ResizeObserver(measure);
121 ro.observe(el);
122 return () => ro.disconnect();
123 }, []);
124 useEffect(() => {
125 const onFsChange = () => setIsFullscreen(!!document.fullscreenElement);
126 document.addEventListener('fullscreenchange', onFsChange);
127 return () => document.removeEventListener('fullscreenchange', onFsChange);
128 }, []);
129 const toggleFullscreen = () => {
130 if (!rootRef.current) return;
131 if (document.fullscreenElement) document.exitFullscreen(); else rootRef.current.requestFullscreen().catch(() => {});
132 };
133 const COVERAGE = {
134 user: ['website', 'api', 'yacme'],
135 project: ['yacme', 'tacme', 'cacme'],
136 local: ['yacme'],
137 managed: ['website', 'api', 'yacme', 'tacme', 'cacme']
138 };
139 const RINGS = {
140 local: {
141 l: 282,
142 t: 50,
143 w: 142,
144 h: 124
145 },
146 project: {
147 l: 282,
148 t: 50,
149 w: 560,
150 h: 124
151 },
152 user: {
153 l: 2,
154 t: 34,
155 w: 446,
156 h: 198
157 },
158 managed: {
159 l: 0,
160 t: 32,
161 w: 862,
162 h: 204
163 }
164 };
165 const TILES = [{
166 id: 'website',
167 name: 'website/',
168 left: 30,
169 caption: ''
170 }, {
171 id: 'api',
172 name: 'api/',
173 left: 160,
174 caption: ''
175 }, {
176 id: 'yacme',
177 name: 'acme-app/',
178 left: 290,
179 caption: ''
180 }, {
181 id: 'tacme',
182 name: 'acme-app/',
183 left: 497,
184 caption: sel === 'project' ? 'their clone, once you commit the file' : 'their clone'
185 }, {
186 id: 'cacme',
187 name: 'acme-app/',
188 left: 704,
189 caption: sel === 'project' ? 'fresh clone, once you commit the file' : sel === 'managed' ? 'server-managed only' : 'fresh clone'
190 }];
191 const FILE_AT = {
192 user: {
193 machine: 'you',
194 tiles: []
195 },
196 project: {
197 machine: null,
198 tiles: ['yacme', 'tacme', 'cacme']
199 },
200 local: {
201 machine: null,
202 tiles: ['yacme']
203 },
204 managed: {
205 machine: null,
206 tiles: []
207 }
208 };
209 const fileAt = FILE_AT[sel];
210 const coverage = COVERAGE[sel];
211 const ring = RINGS[sel];
212 const selFile = FILES.find(f => f.id === sel);
213 const FolderIcon = ({open}) => <svg width="15" height="15" viewBox="0 0 16 16" fill="none" stroke="currentColor" strokeWidth="1.3" strokeLinejoin="round" aria-hidden="true">
214 <path d="M1.5 4.5a1 1 0 0 1 1-1h3.2l1.3 1.5h6a1 1 0 0 1 1 1V12a1 1 0 0 1-1 1h-10.5a1 1 0 0 1-1-1z" />
215 {open && <path d="M1.5 7.5h13" />}
216 </svg>;
217 const FileIcon = () => <svg width="10" height="10" viewBox="0 0 16 16" fill="none" stroke="currentColor" strokeWidth="1.3" strokeLinejoin="round" aria-hidden="true">
218 <path d="M4 1.5h5.5L13 5v9.5H4z" />
219 <path d="M9.5 1.5V5H13" />
220 </svg>;
221 const CloudIcon = () => <svg width="16" height="16" viewBox="0 0 16 16" fill="none" stroke="currentColor" strokeWidth="1.3" strokeLinejoin="round" aria-hidden="true">
222 <path d="M4.5 12.5h7a2.5 2.5 0 0 0 .4-4.97A3.5 3.5 0 0 0 5.2 6.6 3 3 0 0 0 4.5 12.5z" />
223 </svg>;
224 const LaptopIcon = () => <svg width="16" height="16" viewBox="0 0 16 16" fill="none" stroke="currentColor" strokeWidth="1.3" strokeLinejoin="round" aria-hidden="true">
225 <rect x="2.5" y="3" width="11" height="7.5" rx="1" />
226 <path d="M1 12.5h14" />
227 </svg>;
228 return <div ref={rootRef} className={'ssc-root not-prose' + (isFullscreen ? ' ssc-fs' : '')}>
229 <style>{`
230 .ssc-root {
231 --ssc-bg: #FFFFFF;
232 --ssc-text: #1A1918;
233 --ssc-sub: #5E5D59;
234 --ssc-faint: #8A8880;
235 --ssc-border: rgba(0,0,0,0.12);
236 --ssc-panel: #F5F4EF;
237 --ssc-tile: #FAFAF8;
238 --ssc-clay: #D97757;
239 --ssc-clay-bg: rgba(217,119,87,0.14);
240 --ssc-label: #B0562F;
241 --ssc-hover: rgba(115,114,108,0.10);
242 font-family: var(--font-sans, system-ui, -apple-system, sans-serif);
243 background: var(--ssc-bg);
244 color: var(--ssc-text);
245 border: 1px solid var(--ssc-border);
246 border-radius: 16px;
247 padding: 20px 24px 24px;
248 margin: 1.5rem 0;
249 box-sizing: border-box;
250 }
251 .dark .ssc-root {
252 --ssc-bg: #1B1A18;
253 --ssc-text: #F1EFE9;
254 --ssc-sub: #B8B5AD;
255 --ssc-faint: #8A8880;
256 --ssc-border: rgba(255,255,255,0.12);
257 --ssc-panel: #24231F;
258 --ssc-tile: #2A2925;
259 --ssc-clay-bg: rgba(217,119,87,0.20);
260 --ssc-label: #EBC9B7;
261 }
262 .ssc-fs { display: flex; flex-direction: column; justify-content: center; align-items: center; margin: 0; border-radius: 0; height: 100vh; }
263 .ssc-fs .ssc-head { width: 100%; max-width: ${CANVAS_W}px; }
264 .ssc-fs .ssc-frame { width: 100%; }
265 .ssc-mono { font-family: var(--font-mono, ui-monospace, SFMono-Regular, Menlo, monospace); }
266 .ssc-head { display: flex; align-items: flex-start; justify-content: space-between; gap: 12px; margin-bottom: 20px; }
267 .ssc-files { display: flex; gap: 8px; flex-wrap: wrap; }
268 .ssc-file {
269 font-size: 12.5px; font-weight: 430; padding: 8px 13px; border-radius: 10px; cursor: pointer;
270 border: 0.5px solid var(--ssc-border); background: var(--ssc-tile); color: var(--ssc-text);
271 white-space: nowrap; transition: background 0.2s, border-color 0.2s;
272 }
273 .ssc-file:hover { filter: brightness(0.97); }
274 .ssc-file[aria-pressed="true"] { font-weight: 600; border: 1.5px solid var(--ssc-clay); background: var(--ssc-clay-bg); }
275 .ssc-fsbtn {
276 display: flex; align-items: center; justify-content: center; width: 28px; height: 28px; flex-shrink: 0;
277 border: none; background: none; border-radius: 6px; cursor: pointer; color: var(--ssc-faint); font-size: 15px;
278 }
279 .ssc-fsbtn:hover { background: var(--ssc-hover); }
280 .ssc-frame { width: 100%; max-width: ${CANVAS_W}px; margin: 0 auto; }
281 .ssc-canvas { position: relative; width: ${CANVAS_W}px; height: ${CANVAS_H}px; transform-origin: top left; }
282 .ssc-machine { position: absolute; top: 42px; height: 182px; background: var(--ssc-panel); border-radius: 16px; }
283 .ssc-machine-label { position: absolute; top: 192px; display: flex; align-items: center; gap: 8px; font-size: 13.5px; font-weight: 600; }
284 .ssc-tile {
285 position: absolute; top: 58px; width: 126px; height: 108px; border-radius: 12px; padding: 11px 12px; box-sizing: border-box;
286 background: var(--ssc-tile); border: 0.5px solid var(--ssc-border); opacity: 0.6;
287 transition: background 0.25s, border-color 0.25s, opacity 0.25s;
288 }
289 .ssc-tile.ssc-on { background: var(--ssc-clay-bg); border: 1px solid var(--ssc-clay); opacity: 1; }
290 .ssc-tile-name { display: flex; align-items: center; gap: 6px; color: var(--ssc-faint); }
291 .ssc-tile.ssc-on .ssc-tile-name { color: var(--ssc-clay); }
292 .ssc-tile-name span { font-size: 12px; font-weight: 430; white-space: nowrap; color: var(--ssc-text); }
293 .ssc-tile.ssc-on .ssc-tile-name span { font-weight: 600; }
294 .ssc-tile-caption { font-size: 10.5px; color: var(--ssc-sub); margin-top: 5px; line-height: 1.35; }
295 .ssc-filemark {
296 position: absolute; left: 5px; right: 5px; bottom: 8px; display: inline-flex; align-items: center; justify-content: center; gap: 2px;
297 font-size: 8.5px; color: var(--ssc-label); background: var(--ssc-bg); border: 1px solid var(--ssc-clay);
298 border-radius: 6px; padding: 2px 3px; white-space: nowrap; overflow: hidden;
299 }
300 .ssc-filemark svg { flex-shrink: 0; }
301 .ssc-machine-filemark { display: inline-flex; align-items: center; gap: 4px; margin-left: 10px; font-size: 10.5px; font-weight: 500; color: var(--ssc-label); }
302 .ssc-ring {
303 position: absolute; border: 2px solid var(--ssc-clay); border-radius: 18px; pointer-events: none;
304 transition: left 0.35s ease, top 0.35s ease, width 0.35s ease, height 0.35s ease;
305 }
306 .ssc-ring-label {
307 position: absolute; font-size: 12px; font-weight: 600; color: var(--ssc-label); white-space: nowrap; pointer-events: none;
308 transition: left 0.35s ease, top 0.35s ease;
309 }
310 `}</style>
311
312 <div className="ssc-head">
313 <div className="ssc-files" role="group" aria-label="Settings file">
314 {FILES.map(f => <button key={f.id} type="button" className="ssc-file ssc-mono" aria-pressed={f.id === sel} onClick={() => setSel(f.id)}>{f.path}</button>)}
315 </div>
316 <button type="button" className="ssc-fsbtn" onClick={toggleFullscreen} aria-label={isFullscreen ? 'Exit fullscreen' : 'Enter fullscreen'} title={isFullscreen ? 'Exit fullscreen' : 'Fullscreen'}>{isFullscreen ? '⤡' : '⛶'}</button>
317 </div>
318
319 <div ref={frameRef} className="ssc-frame" style={{
320 height: CANVAS_H * scale + 'px'
321 }}>
322 <div className="ssc-canvas" style={{
323 transform: 'scale(' + scale + ')'
324 }}>
325 <div className="ssc-machine" style={{
326 left: '10px',
327 width: '430px'
328 }} />
329 <span className="ssc-machine-label" style={{
330 left: '30px'
331 }}><LaptopIcon />Your machine{fileAt.machine === 'you' && <span className="ssc-machine-filemark ssc-mono"><FileIcon />{selFile.path}</span>}</span>
332 <div className="ssc-machine" style={{
333 left: '460px',
334 width: '200px'
335 }} />
336 <span className="ssc-machine-label" style={{
337 left: '470px'
338 }}><LaptopIcon />A teammate’s machine</span>
339 <div className="ssc-machine" style={{
340 left: '682px',
341 width: '170px'
342 }} />
343 <span className="ssc-machine-label" style={{
344 left: '692px'
345 }}><CloudIcon />A cloud session</span>
346
347 {TILES.map(t => {
348 const on = coverage.includes(t.id);
349 return <div key={t.id} className={'ssc-tile' + (on ? ' ssc-on' : '')} style={{
350 left: t.left + 'px'
351 }}>
352 <div className="ssc-tile-name"><FolderIcon open={on} /><span className="ssc-mono">{t.name}</span></div>
353 {t.caption && <div className="ssc-tile-caption">{t.caption}</div>}
354 {fileAt.tiles.includes(t.id) && <span className="ssc-filemark ssc-mono" title={SHORT[sel]}><FileIcon />{TILE_MARK[sel]}</span>}
355 </div>;
356 })}
357
358 <div className="ssc-ring" style={{
359 left: ring.l + 'px',
360 top: ring.t + 'px',
361 width: ring.w + 'px',
362 height: ring.h + 'px'
363 }} />
364 <span className="ssc-ring-label ssc-mono" style={{
365 left: ring.l + 14 + 'px',
366 top: ring.t - 26 + 'px'
367 }}>{selFile.ring || selFile.path}</span>
368 </div>
369 </div>
370 </div>;
371};
372
373Einstellungen sind JSON-Schlüssel, die ändern, wie Claude Code sich verhält: welches Modell es startet, was es ohne Nachfrage ausführen kann, welche Dateien es nicht lesen kann, wie es in Ihrem Terminal aussieht, und was Ihre Organisation erzwingt.
374
375<Tip>
376 Um einen bestimmten Schlüssel nachzuschlagen, gehen Sie zu [Alle Einstellungen](/docs/de/settings-reference), die jeden Schlüssel mit der Datei, in der Sie ihn setzen, seinem Standard und einem Beispiel auflistet.
377</Tip>
378
379Claude Code liest Einstellungen aus JSON-Einstellungsdateien wie `~/.claude/settings.json`. Es sucht an einigen Stellen danach, und [die Datei, aus der es eine Einstellung liest, entscheidet, für wen die Einstellung gilt](#settings-files-and-who-they-affect). Diese Seite behandelt diese Dateien: in welche man eine Einstellung setzt, wie man eine Einstellung ändert und bestätigt, dass sie angewendet wurde, und welchen Wert Claude Code verwendet, wenn derselbe Schlüssel in mehr als einer Datei gesetzt ist. [Berechtigungen konfigurieren](/docs/de/permissions) behandelt, was Claude Code ohne Nachfrage ausführen kann und wie man `allow`, `ask` und `deny` Regeln schreibt.
20 380
21| Bereich | Speicherort | Wer ist betroffen | Mit Team geteilt? |381<Note>
22| :------------ | :---------------------------------------------------------------------------------------- | :-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :------------------------------------------------ |382 Diese Seite behandelt Claude Code, das auf Ihrer Maschine läuft: das Terminal, die [VS Code](/docs/de/vs-code) und [JetBrains](/docs/de/jetbrains) Erweiterungen und die [Desktop-App](/docs/de/desktop), die alle die gleichen Einstellungsdateien lesen. Eine Cloud-Sitzung auf [Claude Code im Web](/docs/de/claude-code-on-the-web) läuft auf einer anderen Maschine und liest nur einige davon; siehe [Einstellungen in Cloud-Sitzungen](#settings-in-cloud-sessions).
23| **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) |383</Note>
24| **Benutzer** | `~/.claude/` Verzeichnis | Sie, über alle Projekte hinweg | Nein |
25| **Projekt** | `.claude/` im Repository | Alle Mitarbeiter in diesem Repository | Ja (in Git eingecheckt) |
26| **Lokal** | `.claude/settings.local.json` | Sie, nur in diesem Repository | Nein (gitignoriert, wenn Claude Code es erstellt) |
27 384
28<h3 id="when-to-use-each-scope">385<span id="settings-files" />
29 Wann sollte jeder Bereich verwendet werden
30</h3>
31 386
32Der **Verwaltungsbereich** ist für:387<span id="configuration-scopes" />
33 388
34* Sicherheitsrichtlinien, die organisationsweit durchgesetzt werden müssen389<span id="available-scopes" />
35* Compliance-Anforderungen, die nicht überschrieben werden können
36* Standardisierte Konfigurationen, die von IT/DevOps bereitgestellt werden
37 390
38Der **Benutzerbereich** ist am besten für:391<span id="when-to-use-each-scope" />
39 392
40* Persönliche Voreinstellungen, die Sie überall haben möchten (Designs, Editor-Einstellungen)393<span id="what-uses-scopes" />
41* Tools und Plugins, die Sie in allen Projekten verwenden
42* API-Schlüssel und Authentifizierung (sicher gespeichert)
43 394
44Der **Projektbereich** ist am besten für:395<span id="subagent-configuration" />
45 396
46* Teamübergreifend gemeinsame Einstellungen (Berechtigungen, Hooks, MCP-Server)397<span id="where-settings-live" />
47* Plugins, die das gesamte Team haben sollte
48* Standardisierung von Tools über Mitarbeiter hinweg
49 398
50Der **lokale Bereich** ist am besten für:399<h2 id="settings-files-and-who-they-affect">
400 Einstellungsdateien und wer sie betreffen
401</h2>
51 402
52* Persönliche Überschreibungen für ein bestimmtes Projekt403Claude Code liest Einstellungen aus vier Dateien, und eine Organisation kann auch verwaltete Einstellungen von der claude.ai-Konsole bereitstellen. Jede Quelle hat einen Bereich: die Menge von Personen und Projekten, auf die eine in ihr gespeicherte Einstellung angewendet wird, ob das nur Sie, alle in einem Projekt oder alle in Ihrer Organisation sind.
53* Testen von Konfigurationen vor dem Teilen mit dem Team
54* Maschinenspezifische Einstellungen, die für andere nicht funktionieren
55 404
56<h3 id="how-scopes-interact">405| Bereich | Datei | Wer ist betroffen | Verwenden Sie es für |
57 Wie Bereiche interagieren406| :------------------ | :------------------------------------------------------------------------------------------------ | :----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :--------------------------------------------------------------------------------------------------- |
58</h3>407| Benutzer | `~/.claude/settings.json` | Sie, in jedem Projekt auf dieser Maschine | Persönliche Voreinstellungen: Design, Editor-Modus, Standardmodell, Ihre eigenen Berechtigungsregeln |
408| Gemeinsames Projekt | `.claude/settings.json` | Alle, die im Ordner arbeiten, der es enthält. In einem Git-Repository committen Sie es, damit Teamkollegen es bekommen | Team-Berechtigungen, Hooks, Plugins und die Umgebungsvariablen, die das Projekt benötigt |
409| Projekt lokal | `.claude/settings.local.json` | Sie, nur in diesem einen Projekt. Claude Code hält es aus Git heraus, wenn es die Datei erstellt; wenn Sie sie von Hand erstellen, fügen Sie sie selbst zu `.gitignore` hinzu | Persönliche Überschreibungen für ein Projekt und Testen vor dem Teilen |
410| Verwaltet | `managed-settings.json` und andere [verwaltete Quellen](/docs/de/managed-settings#delivery-mechanisms) | Alle, für die Ihre Organisation es bereitstellt; nichts, das Sie setzen, überschreibt es, außer einigen wenigen [sicherheitsempfindlichen Ausnahmen](#exceptions-to-managed-settings-precedence) | Sicherheitsrichtlinie und Compliance-Anforderungen |
59 411
60Wenn die gleiche Einstellung in mehreren Bereichen konfiguriert ist, wendet Claude Code sie in Prioritätsreihenfolge an:412In der Spalte Datei ist `~/.claude` der `.claude` Ordner in Ihrem Home-Verzeichnis, und ein bloßes `.claude` ist der `.claude` Ordner in Ihrem Projekt.
61 413
621. **Verwaltet** (höchste): kann von nichts überschrieben werden414<span id="where-each-file-applies" />
632. **Befehlszeilenargumente**: temporäre Sitzungsüberschreibungen
643. **Lokal**: überschreibt Projekt- und Benutzereinstellungen
654. **Projekt**: überschreibt Benutzereinstellungen
665. **Benutzer** (niedrigste): gilt, wenn nichts anderes die Einstellung angibt
67 415
68Wenn 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).416<span id="compare-what-each-file-reaches" />
69 417
70<h3 id="what-uses-scopes">418<h3 id="compare-the-scope-of-each-settings-file">
71 Was verwendet Bereiche419 Vergleichen Sie den Bereich jeder Einstellungsdatei
72</h3>420</h3>
73 421
74Bereiche gelten für viele Claude Code-Funktionen:422Angenommen, Sie haben drei Projekte auf Ihrer Maschine, `website/`, `api/` und `acme-app/`, ein Teamkollege hat seinen eigenen Klon von `acme-app/`, und Sie starten eine [Cloud-Sitzung](#settings-in-cloud-sessions) auf `acme-app/`.
75
76| Funktion | Benutzerort | Projektort | Lokaler Ort |
77| :---------------- | :------------------------ | :----------------------------------- | :----------------------------- |
78| **Einstellungen** | `~/.claude/settings.json` | `.claude/settings.json` | `.claude/settings.local.json` |
79| **Subagents** | `~/.claude/agents/` | `.claude/agents/` | Keine |
80| **MCP-Server** | `~/.claude.json` | `.mcp.json` | `~/.claude.json` (pro Projekt) |
81| **Plugins** | `~/.claude/settings.json` | `.claude/settings.json` | `.claude/settings.local.json` |
82| **CLAUDE.md** | `~/.claude/CLAUDE.md` | `CLAUDE.md` oder `.claude/CLAUDE.md` | `CLAUDE.local.md` |
83
84Unter Windows werden Pfade, die als `~/.claude` angezeigt werden, zu `%USERPROFILE%\.claude` aufgelöst.
85 423
86***424Die Grafik unten zeigt, in welchen dieser Ordner eine Einstellung angewendet wird, wenn Sie Claude Code von ihnen aus starten. Klicken Sie auf eine Einstellungsdatei, um die Ordner zu sehen, die sie erreicht.
87 425
88<h2 id="settings-files">426<SettingsScope />
89 Einstellungsdateien
90</h2>
91
92Die Datei `settings.json` ist der offizielle Mechanismus zur Konfiguration von Claude Code durch hierarchische Einstellungen:
93
94* **Benutzereinstellungen** werden in `~/.claude/settings.json` definiert und gelten für alle Projekte.
95* **Projekteinstellungen** werden in Ihrem Projektverzeichnis gespeichert:
96 * `.claude/settings.json` für Einstellungen, die in die Versionskontrolle eingecheckt und mit Ihrem Team geteilt werden
97 * `.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.
98
99 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.
100* **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:
101
102 * **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).
103 * **MDM/OS-Richtlinien**: über native Geräteverwaltung auf macOS und Windows bereitgestellt:
104 * 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.
105 * Windows: `HKLM\SOFTWARE\Policies\ClaudeCode` Registrierungsschlüssel mit einem `Settings`-Wert (REG\_SZ oder REG\_EXPAND\_SZ) mit JSON (bereitgestellt über Gruppenrichtlinie oder Intune)
106 * Windows (Benutzerebene): `HKCU\SOFTWARE\Policies\ClaudeCode` (niedrigste Richtlinienpriorität, wird nur verwendet, wenn keine Admin-Quelle vorhanden ist)
107 * **Dateibasiert**: `managed-settings.json` und `managed-mcp.json` in Systemverzeichnissen bereitgestellt:
108 427
109 * macOS: `/Library/Application Support/ClaudeCode/`428* **`~/.claude/settings.json`**: jedes Projekt auf Ihrer Maschine, und nichts auf der Ihres Teamkollegen oder in der Cloud-Sitzung
110 * Linux und WSL: `/etc/claude-code/`429* **`acme-app/.claude/settings.json`**: Ihr `acme-app/`. Es erreicht den Klon Ihres Teamkollegen und die Cloud-Sitzung nur, wenn Sie die Datei in die Versionskontrolle committen; bis dahin ist es eine Datei auf Ihrer Festplatte wie jede andere und niemand sonst hat sie
111 * Windows: `C:\Program Files\ClaudeCode\`430* **`acme-app/.claude/settings.local.json`**: nur Ihr `acme-app/`. Claude Code fügt es zu Ihren globalen Git-Ausschlüssen hinzu, wenn es die Datei zum ersten Mal schreibt, sodass es aus Ihren Commits herausbleibt; wenn Sie die Datei von Hand erstellen, [fügen Sie sie selbst zu `.gitignore` hinzu](#keep-personal-settings-out-of-a-repository)
431* **Verwaltete Einstellungen**, ob eine `managed-settings.json` Datei, eine MDM-Richtlinie oder [serververwaltete Einstellungen](/docs/de/server-managed-settings) von der claude.ai-Konsole: jedes Projekt auf jeder Maschine, für die Ihre Organisation es bereitstellt, oder auf die Sie sich mit Ihrem Organisationskonto anmelden. Nur serververwaltete Einstellungen erreichen die Cloud-Sitzung
112 432
113 <Warning>433<span id="which-files-you-have" />
114 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.
115 </Warning>
116 434
117 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.435<h3 id="find-or-create-your-settings-files">
118 436 Finden oder erstellen Sie Ihre Einstellungsdateien
119 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.437</h3>
120
121 Verwenden Sie numerische Präfixe, um die Zusammenführungsreihenfolge zu steuern, z. B. `10-telemetry.json` und `20-security.json`.
122 438
123 Siehe [Verwaltete Einstellungen](/docs/de/permissions#managed-only-settings) und [Verwaltete MCP-Konfiguration](/docs/de/managed-mcp) für Details.439Die Installation von Claude Code erstellt keine Einstellungsdatei. Wenn Ihre Maschine oder Ihr Projekt bereits eine hat, kam sie aus einer dieser Quellen:
124 440
125 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.441* **Verwaltet**: Ihre Organisation stellt sie bereit. Sie erstellen oder bearbeiten sie nicht.
442* **Gemeinsames Projekt**: Ein Projekt, das bereits Claude Code verwendet, kann eine eingecheckte haben. Wenn nicht, erstellen Sie eine unter `.claude/settings.json` im Projektordner.
443* **Benutzer** und **Projekt lokal**: Erstellen Sie sie selbst, oder lassen Sie Claude Code sie erstellen. Es schreibt `~/.claude/settings.json` das erste Mal, wenn Sie eine Option im `/config` Menü ändern, die es in Benutzereinstellungen speichert, wie das Design, und `.claude/settings.local.json` das erste Mal, wenn Sie eine stehende Genehmigung auf einer Berechtigungsaufforderung geben, wie "Ja, und frag mich nicht mehr" für einen Bash-Befehl. Ein paar `/config` Optionen, einschließlich **Tipps anzeigen**, speichern stattdessen in `.claude/settings.local.json`.
126 444
127 <Note>445<Info>
128 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).446 Unter Windows bedeutet `~/.claude` `%USERPROFILE%\.claude`. Um die Home-Verzeichnis-Dateien woanders zu behalten, setzen Sie [`CLAUDE_CONFIG_DIR`](/docs/de/env-vars); Claude Code speichert dann Ihre Einstellungen, Sitzungsverlauf und Plugins dort statt.
129 </Note>447</Info>
130* **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.
131 448
132<Note>449Claude Code behält auch eine fünfte Datei, [`~/.claude.json`](/docs/de/claude-directory#ce-claude-json), die es für sich selbst schreibt; Sie müssen sie nicht bearbeiten. Sie enthält Ihre Anmeldungssitzung, [MCP-Server](/docs/de/mcp) Konfigurationen, projektbezogenen Status wie Vertrauensentscheidungen, und die [globalen Konfigurationsschlüssel](/docs/de/settings-reference#global-config-settings), die `/config` für Sie schreibt.
133 Claude Code erstellt automatisch zeitgestempelte Sicherungen von Konfigurationsdateien und behält die fünf neuesten Sicherungen bei, um Datenverlust zu verhindern.
134</Note>
135 450
136```JSON Beispiel settings.json theme={null}451<h3 id="share-settings-with-your-team">
137{452 Teilen Sie Einstellungen mit Ihrem Team
138 "$schema": "https://json.schemastore.org/claude-code-settings.json",453</h3>
139 "permissions": {
140 "allow": [
141 "Bash(npm run lint)",
142 "Bash(npm run test *)",
143 "Read(~/.zshrc)"
144 ],
145 "deny": [
146 "Bash(curl *)",
147 "Read(./.env)",
148 "Read(./.env.*)",
149 "Read(./secrets/**)"
150 ]
151 },
152 "env": {
153 "CLAUDE_CODE_ENABLE_TELEMETRY": "1",
154 "OTEL_METRICS_EXPORTER": "otlp"
155 },
156 "companyAnnouncements": [
157 "Welcome to Acme Corp! Review our code guidelines at docs.acme.com",
158 "Reminder: Code reviews required for all PRs",
159 "New security policy in effect"
160 ]
161}
162```
163 454
164Die 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.455Committen Sie `.claude/settings.json`, damit jeder, der das Repository klont, die gleichen Berechtigungen, Hooks, Telemetrie und Plugins bekommt. Jeder Teamkollege kann es immer noch für sich selbst in seiner eigenen `.claude/settings.local.json` überschreiben, sodass persönliche Ausnahmen keinen Commit benötigen. Für eine vollständige Team-Datei, siehe [Gemeinsame Einstellungen eines Teams](/docs/de/settings-example#a-teams-shared-settings).
165 456
166Das 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.457Einiges von dem, das Sie committen, wartet, bis jeder Teamkollege den [Ordner vertraut](/docs/de/permissions#project-allow-rules-and-workspace-trust), und ein paar Schlüssel wirken sich nie von einer Repository-Datei aus; [Beheben Sie eine Einstellung, die nicht angewendet wird](#common-cases) behandelt beide.
167 458
168<h3 id="when-edits-take-effect">459<span id="local-settings-file" />
169 Wenn Änderungen wirksam werden
170</h3>
171 460
172Claude 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.461<span id="where-claude-code-saves-the-project-local-file" />
173 462
174Einige wenige Schlüssel werden einmal beim Sitzungsstart gelesen und gelten stattdessen beim nächsten Neustart:463<span id="the-project-local-file" />
175 464
176* `model`: Verwenden Sie [`/model`](/docs/de/model-config#setting-your-model), um während der Sitzung zu wechseln465<span id="keep-personal-settings-out-of-the-repository" />
177* [`outputStyle`](/docs/de/output-styles): Teil der Systemaufforderung, die beim `/clear` oder Neustart neu erstellt wird
178 466
179<h3 id="invalid-entries-in-managed-settings">467<h3 id="keep-personal-settings-out-of-a-repository">
180 Ungültige Einträge in verwalteten Einstellungen468 Halten Sie persönliche Einstellungen aus einem Repository heraus
181</h3>469</h3>
182 470
183Verwaltete 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.471Um eine Einstellung für sich selbst in einem Projekt zu ändern, ohne sie für Ihre Teamkollegen zu ändern, speichern Sie sie in `.claude/settings.local.json` im Projekt. Claude Code wendet diese Datei über die eingecheckte `.claude/settings.json` an, sodass wenn die Datei Ihres Teams `"model": "claude-sonnet-5"` setzt und Sie Opus wollen, setzen Sie `"model": "claude-opus-4-8"` in Ihre lokale Datei und nur Ihre Sitzungen ändern.
184 472
185Dieses 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.473Drei Dinge, die Sie über die lokale Datei wissen sollten:
186 474
187Sicherheitsdurchsetzungsfelder werden pro Feld behandelt, anstatt vollständig entfernt zu werden, wenn sie vorhanden, aber ungültig sind:475* **Claude Code schreibt sie auch.** Wenn Claude Sie fragt, einen Bash-Befehl auszuführen und Sie "Ja, und frag mich nicht mehr" wählen, speichert Claude Code diese [Berechtigungsgenehmigung](/docs/de/permissions#permission-system) hier als `allow` Regel.
476* **Sie müssen sie nicht selbst gitignorieren, es sei denn, Sie haben sie von Hand erstellt.** Das erste Mal, wenn Claude Code die Datei in einem Git-Repository schreibt, das sie nicht bereits ignoriert, fügt es `**/.claude/settings.local.json` zu Ihrer globalen Git-Ausschluss-Datei hinzu, sodass die Datei in jedem Repository aus Ihren Commits herausbleibt. Diese Datei ist `core.excludesFile`, wenn Ihre globale Git-Konfiguration sie auf einen absoluten oder `~`-präfixierten Pfad setzt; ansonsten ist es `$XDG_CONFIG_HOME/git/ignore`, oder `~/.config/git/ignore`, wenn `XDG_CONFIG_HOME` nicht gesetzt ist. Wenn Sie die Datei von Hand erstellt haben und Claude Code noch nicht darin geschrieben hat, fügen Sie sie selbst zu `.gitignore` hinzu.
477* **Seine Allow-Regeln warten nicht auf Vertrauen, während die Datei nicht verfolgt bleibt.** Weil die Datei Ihnen gehört und nicht dem Repository, wendet Claude Code ihre `allow` Regeln ohne den [Workspace-Vertrauens](/docs/de/permissions#project-allow-rules-and-workspace-trust)-Schritt an, den es für die eingecheckte Datei erfordert. Wenn die Datei von Git verfolgt wird, gilt der Vertrauensschritt auch für sie; siehe [Wenn Ihre lokale Einstellungsdatei Vertrauen benötigt](/docs/de/permissions#when-your-local-settings-file-needs-trust).
188 478
189| Feld | Verhalten, wenn vorhanden, aber ungültig |479<span id="where-claude-code-looks-for-each-file" />
190| :--------------------------- | :----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
191| `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. |
192| `allowManagedMcpServersOnly` | Behandelt als `true`. |
193| `availableModels` | 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. |
194| `enforceAvailableModels` | Behandelt als `true`. Gilt in v2.1.175 und später. |
195| `forceLoginOrgUUID` | Keine Organisation darf sich anmelden, bis der Wert behoben ist. |
196| `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. |
197| `sandbox.credentials` | 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. |
198 480
199`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.481<span id="how-claude-code-keeps-the-local-file-out-of-git" />
200 482
201Validierungsfehler werden an drei Stellen angezeigt:483<span id="local-allow-rules-dont-wait-for-workspace-trust" />
202 484
203* Interaktive Sitzungen zeigen beim Start einen Dialog mit den ungültigen Einträgen an.485<h4 id="where-claude-code-keeps-the-local-file-in-a-git-repository">
204* Headless-Läufe mit `-p` drucken eine Zusammenfassung zu stderr.486 Wo Claude Code die lokale Datei in einem Git-Repository behält
205* [`claude doctor`](/docs/de/debug-your-config) listet jeden ungültigen Eintrag mit seiner Quelle und seinem Feld auf.487</h4>
206 488
207Validieren Sie Richtlinienänderungen, indem Sie `claude doctor` auf einem Test-Computer ausführen, bevor Sie sie unternehmensweite bereitstellen.489Wenn Claude Sie fragt, einen Bash-Befehl auszuführen und Sie "Ja, und frag mich nicht mehr" wählen, speichert Claude Code diese Genehmigung als `allow` Regel in `.claude/settings.local.json`. Wenn Sie Claude Code in einem Unterverzeichnis eines Git-Repositorys starten, liest und schreibt es diese Datei im Repository-Root und wendet die Genehmigung auf das ganze Repository an. In einem [Worktree](/docs/de/worktrees) verwendet es die Datei im Root des Haupt-Checkouts.
208 490
209Diese 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.491Zwei Regeln qualifizieren den Root-Speicherort:
210 492
211<h3 id="available-settings">493* **Wenn die Datei stattdessen bei `.claude/settings.json` bleibt**: außerhalb eines Git-Repositorys, wenn der Repository-Root Ihr Home-Verzeichnis ist, unter Windows, oder wenn der Repository-Root oder sein `.git` oder `.claude` Eintrag nicht Ihrem Benutzer gehört.
212 Verfügbare Einstellungen494* **Pfade in der Datei verankern nicht im Repository-Root**: eine Berechtigungsregel, die mit `/` beginnt oder ein relativer Sandbox-Pfad [verankert stattdessen im primären Arbeitsverzeichnis der Sitzung](/docs/de/permissions#read-and-edit).
213</h3>
214 495
215`settings.json` unterstützt eine Reihe von Optionen:496Vor v2.1.211 behielt Claude Code die Datei im Startverzeichnis. Es liest immer noch eine Datei, die eine frühere Version dort neben der Root-Datei hinterlassen hat; wo beide den gleichen Schlüssel setzen, gilt der Wert des Root, und Berechtigungsregeln aus beiden Dateien gelten. Der Agent SDK's [`resolveSettings()`](/docs/de/agent-sdk/typescript#resolvesettings) Helper liest die Datei immer aus dem Startverzeichnis.
216
217| Schlüssel | Beschreibung | Beispiel |
218| :--------------------------------- | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :------------------------------------------------------------------------------------------------------------------------------- |
219| `advisorModel` | Modell für das serverseitige [Advisor-Tool](/docs/de/advisor). Akzeptiert einen Modellalias wie `"opus"`, `"sonnet"` oder `"fable"` (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"` |
220| `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"` |
221| `agentPushNotifEnabled` | **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` |
222| `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` |
223| `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" }]` |
224| `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/*"]` |
225| `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" }]` |
226| `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` |
227| `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` |
228| `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` |
229| `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` |
230| `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` |
231| `askUserQuestionTimeout` | **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"` |
232| `attribution` | Passen Sie die Zuschreibung für Git-Commits und Pull Requests an. Siehe [Zuschreibungseinstellungen](#attribution-settings) | `{"commit": "🤖 Generated with Claude Code", "pr": ""}` |
233| `autoCompactEnabled` | **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` |
234| `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"` |
235| `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` |
236| `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`. Vor v2.1.207 wurde `.claude/settings.local.json` auch gelesen | `{"soft_deny": ["$defaults", "Never run terraform apply"]}` |
237| `autoMode.classifyAllShell` | **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` |
238| `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` |
239| `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"` |
240| `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"]` |
241| `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` |
242| `awsAuthRefresh` | Benutzerdefiniertes Skript, das das `.aws`-Verzeichnis ändert (siehe [erweiterte Anmeldedatenkonfiguration](/docs/de/amazon-bedrock#advanced-credential-configuration)) | `aws sso login --profile myprofile` |
243| `awsCredentialExport` | Benutzerdefiniertes Skript, das JSON mit AWS-Anmeldedaten ausgibt (siehe [erweiterte Anmeldedatenkonfiguration](/docs/de/amazon-bedrock#advanced-credential-configuration)) | `/bin/generate_aws_grant.sh` |
244| `axScreenReader` | 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` |
245| `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" }]` |
246| `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"` |
247| `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` |
248| `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."` |
249| `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"]` |
250| `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. 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` |
251| `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"]` |
252| `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"` |
253| `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" }]` |
254| `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` |
255| `disableAllHooks` | Deaktivieren Sie alle [Hooks](/docs/de/hooks) und alle benutzerdefinierten [Statuszeilen](/docs/de/statusline) | `true` |
256| `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` |
257| `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"` |
258| `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` |
259| `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` |
260| `disableClaudeAiConnectors` | 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` |
261| `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"` |
262| `disabledMcpjsonServers` | Liste spezifischer MCP-Server aus `.mcp.json`-Dateien zum Ablehnen | `["filesystem"]` |
263| `disableRemoteControl` | 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` |
264| `disableSideloadFlags` | (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` |
265| `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` |
266| `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` |
267| `editorMode` | **Standard**: `"normal"`. Tastaturkürzel-Modus für die Eingabeaufforderung: `"normal"` oder `"vim"`. Wird in `/config` als **Editor mode** angezeigt | `"vim"` |
268| `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"` |
269| `enableAllProjectMcpServers` | Genehmigen Sie automatisch alle MCP-Server, die in Projekt-`.mcp.json`-Dateien definiert sind. 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` |
270| `enableArtifact` | 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` |
271| `enabledMcpjsonServers` | Liste spezifischer MCP-Server aus `.mcp.json`-Dateien zum Genehmigen. 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"]` |
272| `enforceAvailableModels` | 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` |
273| `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. 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"}` |
274| `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"]` |
275| `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` |
276| `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` |
277| `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` |
278| `fileCheckpointingEnabled` | **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` |
279| `fileSuggestion` | Konfigurieren Sie ein benutzerdefiniertes Skript für `@` Datei-Autovervollständigung. Siehe [Dateivorschlag-Einstellungen](#file-suggestion-settings) | `{"type": "command", "command": "~/.claude/file-suggestion.sh"}` |
280| `footerLinksRegexes` | 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(?<key>PROJ-\\d+)\\b", "url": "https://issues.example.com/browse/{key}", "label": "{key}"}]` |
281| `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` |
282| `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"` |
283| `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"]` |
284| `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` |
285| `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` |
286| `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) |
287| `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"]` |
288| `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` |
289| `inputNeededNotifEnabled` | **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` |
290| `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. Ab v2.1.176 entsprechen Sitzungstitel, wenn nicht gesetzt, der Sprache Ihres Gesprächs | `"japanese"` |
291| `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"` |
292| `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"` |
293| `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:..."}` |
294| `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` |
295| `outputStyle` | Konfigurieren Sie einen Ausgabestil, um die Systemaufforderung anzupassen. Siehe [Ausgabestil-Dokumentation](/docs/de/output-styles) | `"Explanatory"` |
296| `parentSettingsBehavior` | (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"` |
297| `permissions` | Siehe Tabelle unten für die Struktur der Berechtigungen. | |
298| `plansDirectory` | **Standard**: `~/.claude/plans`. Passen Sie an, wo Plandateien gespeichert werden. Der Pfad ist relativ zum Projektstamm. | `"./plans"` |
299| `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"]` |
300| `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"` |
301| `policyHelper` | 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"}` |
302| `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"` |
303| `prefersReducedMotion` | Reduzieren oder deaktivieren Sie UI-Animationen (Spinner, Shimmer, Flash-Effekte) für Barrierefreiheit | `true` |
304| `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}"` |
305| `remoteControlAtStartup` | 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` |
306| `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 <version>` 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"` |
307| `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"` |
308| `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` |
309| `respondToBashCommands` | **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` |
310| `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` |
311| `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` |
312| `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` |
313| `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` |
314| `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` |
315| `skillOverrides` | 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"}` |
316| `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` |
317| `spinnerTipsEnabled` | **Standard**: `true`. Zeigen Sie Tipps im Spinner an, während Claude arbeitet. Setzen Sie auf `false`, um Tipps zu deaktivieren | `false` |
318| `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"] }` |
319| `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"]}` |
320| `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"}]` |
321| `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"}` |
322| `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" }]` |
323| `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"]` |
324| `syntaxHighlightingDisabled` | Deaktivieren Sie Syntax-Hervorhebung in Diffs, Code-Blöcken und Dateivorschau | `true` |
325| `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 }`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"` |
326| `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` |
327| `theme` | **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:<slug>"` oder `"custom:<plugin-name>:<slug>"`. Siehe [Erstellen Sie ein benutzerdefiniertes Theme](/docs/de/terminal-config#create-a-custom-theme). Wird in `/config` als **Theme** angezeigt | `"dark"` |
328| `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"` |
329| `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. 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` |
330| `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` |
331| `verbose` | **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` |
332| `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"` |
333| `vimInsertModeRemaps` | 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 `"<Esc>"` 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": "<Esc>"}` |
334| `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" }` |
335| `voiceEnabled` | Veralteter Alias für `voice.enabled`. Bevorzugen Sie das `voice`-Objekt | `true` |
336| `wheelScrollAccelerationEnabled` | **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` |
337| `workflowKeywordTriggerEnabled` | **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` |
338| `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` |
339
340<h3 id="global-config-settings">
341 Globale Konfigurationseinstellungen
342</h3>
343 497
344Diese Einstellungen werden in `~/.claude.json` statt in `settings.json` gespeichert. Das Hinzufügen zu `settings.json` löst einen Schema-Validierungsfehler aus.498Claude Code liest die gemeinsame `.claude/settings.json` aus dem [primären Arbeitsverzeichnis](/docs/de/permissions#working-directories) der Sitzung, sodass um eine Datei zu verwenden, die im Repository-Root eingecheckt ist, starten Sie Claude Code dort. Nachdem Sie [die Sitzung mit `/cd` verschieben](/docs/de/permissions#move-the-session-to-another-directory), liest Claude Code beide Projektdateien stattdessen aus dem neuen Verzeichnis, wobei die lokale Datei nach den gleichen Regeln platziert wird. Das Lesen von ihnen aus dem Verzeichnis, zu dem Sie verschoben haben, erfordert Claude Code v2.1.246 oder später.
345 499
346<Note>500<span id="managed-settings-delivery" />
347 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`.
348</Note>
349 501
350| Schlüssel | Beschreibung | Beispiel |502<span id="precedence-within-the-managed-tier" />
351| :--------------------------- | :-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :--------- |
352| `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` |
353| `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` |
354| `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` |
355| `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` |
356| `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"` |
357| `workflowSizeGuideline` | **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. 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"` |
358
359<h3 id="worktree-settings">
360 Worktree-Einstellungen
361</h3>
362 503
363Konfigurieren Sie, wie `--worktree` Git-Worktrees erstellt und verwaltet.504<span id="parent-settings-from-embedding-hosts" />
364 505
365| Schlüssel | Beschreibung | Beispiel |506<span id="enforce-settings-for-an-organization" />
366| :---------------------------- | :----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :------------------------------------ |
367| `worktree.baseRef` | Welcher Ref neue Worktrees branchen von. `"fresh"` (Standard) brancht von `origin/<default-branch>` 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"` |
368| `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"]` |
369| `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"]` |
370| `worktree.bgIsolation` | 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. 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"` |
371 507
372Um 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.508<span id="settings-your-organization-manages" />
373
374<h3 id="permission-settings">
375 Berechtigungseinstellungen
376</h3>
377 509
378| Schlüssel | Beschreibung | Beispiel |510<h3 id="check-what-your-organization-enforces">
379| :---------------------------------- | :---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :--------------------------------------------------------------------- |511 Überprüfen Sie, was Ihre Organisation erzwingt
380| `allow` | Array von Berechtigungsregeln, um die Werkzeugnutzung zu erlauben. Werkzeugname-Globs werden nur in der Werkzeugposition nach einem literalen `mcp__<server>__` 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 *)" ]` |
381| `ask` | Array von Berechtigungsregeln, um bei der Werkzeugnutzung um Bestätigung zu bitten. Siehe [Berechtigungsregelsyntax](#permission-rule-syntax) unten | `[ "Bash(git push *)" ]` |
382| `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/**)" ]` |
383| `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/" ]` |
384| `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"` |
385| `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"` |
386| `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` |
387
388<h3 id="permission-rule-syntax">
389 Berechtigungsregelsyntax
390</h3>512</h3>
391 513
392Berechtigungsregeln 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.514Wenn Ihre Organisation Claude Code verwaltet, werden einige Einstellungen für Sie entschieden und nichts, das Sie in Ihre eigenen Dateien setzen, ändert sie. Um zu sehen, welche, führen Sie `/status` aus: die Zeile `Setting sources` nennt die verwaltete Quelle, die auf Sie angewendet wird. Verwaltete Einstellungen gelten überall dort, wo Claude Code auf dieser Maschine läuft; [Was ein Entwickler ändern kann](/docs/de/managed-settings#what-a-developer-can-change) behandelt lokale Admin-Rechte und Tools außer Claude Code.
393
394Schnelle Beispiele:
395
396| Regel | Effekt |
397| :----------------------------- | :-------------------------------------------- |
398| `Bash` | Passt auf alle Bash-Befehle |
399| `Bash(npm run *)` | Passt auf Befehle, die mit `npm run` beginnen |
400| `Read(./.env)` | Passt auf das Lesen der `.env`-Datei |
401| `WebFetch(domain:example.com)` | Passt auf Abrufanfragen an example.com |
402
403Fü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).
404
405<h3 id="sandbox-settings">
406 Sandbox-Einstellungen
407</h3>
408 515
409Konfigurieren Sie erweitertes Sandbox-Verhalten. Sandboxing isoliert Bash-Befehle von Ihrem Dateisystem und Netzwerk. Siehe [Sandboxing](/docs/de/sandboxing) für Details.516Verwaltete Einstellungen erreichen Sie durch die [Bereitstellungsmechanismen](/docs/de/managed-settings#delivery-mechanisms) auf der Seite für verwaltete Einstellungen, am häufigsten:
410
411| Schlüssel | Beschreibung | Beispiel |
412| :------------------------------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :--------------------------------------------------- |
413| `enabled` | Aktivieren Sie Bash-Sandboxing (macOS, Linux und WSL2). Standard: false | `true` |
414| `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` |
415| `autoAllowBashIfSandboxed` | Genehmigen Sie Bash-Befehle automatisch, wenn sie in einer Sandbox ausgeführt werden. Standard: true | `true` |
416| `excludedCommands` | Befehle, die außerhalb der Sandbox ausgeführt werden sollten | `["docker *"]` |
417| `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` |
418| `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"]` |
419| `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"]` |
420| `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"]` |
421| `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. | `["."]` |
422| `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` |
423| `credentials.files` | 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" }]` |
424| `credentials.envVars` | 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" }]` |
425| `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"]` |
426| `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` |
427| `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"]` |
428| `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` |
429| `network.allowLocalBinding` | Erlauben Sie das Binden an Localhost-Ports (nur macOS). Standard: false | `true` |
430| `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.*"]` |
431| `network.allowedDomains` | Array von Domänen, um ausgehenden Netzwerkverkehr zu erlauben. Unterstützt Platzhalter (z. B. `*.example.com`). | `["github.com", "*.npmjs.org"]` |
432| `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"]` |
433| `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` |
434| `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` |
435| `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` |
436| `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 */}} | `{}` |
437| `enableWeakerNestedSandbox` | Aktivieren Sie schwächere Sandbox für unprivilegierte Docker-Umgebungen (nur Linux und WSL2). **Reduziert die Sicherheit.** Standard: false | `true` |
438| `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` |
439| `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` |
440| `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` |
441| `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` |
442
443<h4 id="sandbox-path-prefixes">
444 Sandbox-Pfadpräfixe
445</h4>
446 517
447Pfade in `filesystem.allowWrite`, `filesystem.denyWrite`, `filesystem.denyRead`, `filesystem.allowRead` und `credentials.files` unterstützen diese Präfixe:518* [Serververwaltete Einstellungen](/docs/de/server-managed-settings), die Claude Code von der claude.ai Admin-Konsole oder einem selbstgehosteten [Claude-Apps-Gateway](/docs/de/claude-apps-gateway) abruft
519* MDM- oder OS-Richtlinien und `managed-settings.json` Dateien in einem Systemverzeichnis
520* Ein Embedding-Host wie Claude Desktop, über die SDK `managedSettings` Option; siehe [Kontrollieren Sie die Richtlinie von einem Embedding-Host](/docs/de/managed-settings#parent-settings-from-embedding-hosts)
448 521
449| Präfix | Bedeutung | Beispiel |522In einer [Cowork](https://claude.com/docs/cowork/overview) Sitzung, die auf Ihrer Maschine in der Claude Desktop-App läuft, ruft Claude Code keine serververwalteten Einstellungen von der claude.ai Admin-Konsole ab, und es liest Richtlinien, die auf Ihrem Gerät bereitgestellt sind, es sei denn, die Claude Desktop-Konfiguration Ihrer Organisation setzt `requireCoworkFullVmSandbox`. [Wo und wann eine Richtlinie angewendet wird](/docs/de/managed-settings#where-and-when-a-policy-applies) behandelt Cowork und Cloud-Sitzungen.
450| :-------------------- | :---------------------------------------------------------------------------------------------- | :-------------------------------------------------------------------- |
451| `/` | Absoluter Pfad vom Dateisystem-Root | `/tmp/build` bleibt `/tmp/build` |
452| `~/` | Relativ zum Home-Verzeichnis | `~/.kube` wird zu `$HOME/.kube` |
453| `./` oder kein Präfix | Relativ zum Projektstamm für Projekteinstellungen oder zu `~/.claude` für Benutzereinstellungen | `./output` in `.claude/settings.json` wird zu `<project-root>/output` |
454 523
455Das ä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.524Wenn Sie der Administrator sind, [Richten Sie Claude Code für Ihre Organisation ein](/docs/de/admin-setup) führt Sie durch die Auswahl dessen, was Sie erzwingen, und [Stellen Sie verwaltete Einstellungen bereit](/docs/de/managed-settings) behandelt Bereitstellung und wie Sie bestätigen, dass eine Richtlinie wirksam ist.
456 525
457**Konfigurationsbeispiel:**526<h2 id="change-a-setting">
527 Ändern Sie eine Einstellung
528</h2>
458 529
459```json theme={null}530Sie können eine Einstellung vom `/config` Menü, durch Bearbeiten einer Einstellungsdatei oder für eine Sitzung von der Befehlszeile aus ändern.
460{
461 "sandbox": {
462 "enabled": true,
463 "autoAllowBashIfSandboxed": true,
464 "excludedCommands": ["docker *"],
465 "filesystem": {
466 "allowWrite": ["/tmp/build", "~/.kube"],
467 "denyRead": ["~/.aws/credentials"]
468 },
469 "network": {
470 "allowedDomains": ["github.com", "*.npmjs.org", "registry.yarnpkg.com"],
471 "deniedDomains": ["uploads.github.com"],
472 "allowUnixSockets": [
473 "/var/run/docker.sock"
474 ],
475 "allowLocalBinding": true
476 }
477 }
478}
479```
480 531
481**Dateisystem- und Netzwerkbeschränkungen** können auf zwei Arten konfiguriert werden, die zusammengeführt werden:532<span id="system-prompt" />
482 533
483* **`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.534Claude Code's Systemaufforderung wird nicht veröffentlicht. Um Claude stehende Anweisungen zu geben, verwenden Sie [`CLAUDE.md` Dateien](/docs/de/memory) oder das Flag `--append-system-prompt`.
484* **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.
485 535
486<h3 id="attribution-settings">536<h3 id="use-the-/config-menu">
487 Zuschreibungseinstellungen537 Verwenden Sie das /config Menü
488</h3>538</h3>
489 539
490Claude Code fügt Git-Commits und Pull Requests Zuschreibungen hinzu. Diese werden separat konfiguriert:540Führen Sie `/config` in Claude Code aus und öffnen Sie die Registerkarte **Config**. Es listet eine kurze Menge persönlicher Optionen wie Design, Editor-Modus und ausführliche Ausgabe auf, nicht jeden Einstellungsschlüssel. Wählen Sie eine Option, um sie zu ändern; Claude Code speichert sie für Sie:
491
492* 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
493* Pull-Request-Beschreibungen sind Klartext
494 541
495| Schlüssel | Beschreibung |542* **Die meisten Optionen**: `~/.claude/settings.json`
496| :----------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |543* **Ein paar Optionen, wie Tipps anzeigen**: `.claude/settings.local.json`
497| `commit` | Zuschreibung für Git-Commits, einschließlich aller Trailer. Leere Zeichenkette blendet Commit-Zuschreibung aus |544* **Die [globalen Konfigurationsoptionen](/docs/de/settings-reference#global-config-settings)**: `~/.claude.json`
498| `pr` | Zuschreibung für Pull-Request-Beschreibungen. Leere Zeichenkette blendet Pull-Request-Zuschreibung aus |
499| `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 |
500 545
501**Standard-Commit-Zuschreibung:**546Um eine Option ohne das Menü zu setzen, übergeben Sie `key=value`, wie `/config verbose=true`.
502
503```text theme={null}
504Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
505```
506
507Der Modellname im Trailer spiegelt das aktive Modell für die Sitzung wider.
508
509**Standard-Pull-Request-Zuschreibung:**
510
511```text theme={null}
512🤖 Generated with [Claude Code](https://claude.com/claude-code)
513```
514
515**Beispiel:**
516
517```json theme={null}
518{
519 "attribution": {
520 "commit": "Generated with AI\n\nCo-Authored-By: AI <ai@example.com>",
521 "pr": ""
522 }
523}
524```
525 547
526<Note>548<Note>
527 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`.549 `/config` ist Teil der Terminal-Schnittstelle. Das [VS Code](/docs/de/vs-code) Chat-Panel und die [Desktop-App](/docs/de/desktop) öffnen es nicht; ändern Sie Einstellungen dort durch Bearbeiten einer Einstellungsdatei oder durch die Einstellungen dieser Apps.
528</Note>550</Note>
529 551
530<h3 id="file-suggestion-settings">552<h3 id="edit-a-settings-file">
531 Dateivorschlag-Einstellungen553 Bearbeiten Sie eine Einstellungsdatei
532</h3>554</h3>
533 555
534Konfigurieren 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.556Öffnen Sie die Einstellungsdatei für den Bereich, den Sie möchten, in Ihrem Editor und fügen Sie einen Schlüssel hinzu oder ändern Sie ihn. Einstellungsdateien sind striktes JSON: ein `//` Kommentar oder ein nachfolgendes Komma ist ein Syntaxfehler, und Claude Code meldet die Datei als [Einstellungsfehler](#fix-a-broken-settings-file) beim nächsten Start. Um beispielsweise Claude Code Ihre Lint- und Test-Befehle ohne Nachfrage ausführen zu lassen und es daran zu hindern, `.env` Dateien zu lesen, fügen Sie dies zu `~/.claude/settings.json` hinzu:
535
536```json theme={null}
537{
538 "fileSuggestion": {
539 "type": "command",
540 "command": "~/.claude/file-suggestion.sh"
541 }
542}
543```
544
545Der 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:
546
547```json theme={null}
548{"query": "src/comp"}
549```
550
551Geben Sie zeilengetrennte Dateipfade zu stdout aus (derzeit auf 15 begrenzt):
552
553```text theme={null}
554src/components/Button.tsx
555src/components/Modal.tsx
556src/components/Form.tsx
557```
558
559**Beispiel:**
560
561```bash theme={null}
562#!/bin/bash
563query=$(cat | jq -r '.query')
564# Replace your-repo-file-index with your own file search command
565your-repo-file-index --query "$query" | head -20
566```
567
568<h3 id="footer-link-badges">
569 Footer-Link-Badges
570</h3>
571
572Die 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.
573
574Jeder 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.
575
576Das folgende Beispiel rendert ein Badge, wenn eine Issue-Taste wie `PROJ-1234` in der Ausgabe der Runde erscheint. Die `(?<key>...)` benannte Gruppe erfasst den Schlüssel, und `{key}` ersetzt ihn in der URL und dem Label:
577 557
578```json ~/.claude/settings.json theme={null}558```json ~/.claude/settings.json theme={null}
579{559{
580 "footerLinksRegexes": [560 "$schema": "https://json.schemastore.org/claude-code-settings.json",
581 {561 "permissions": {
582 "type": "regex",562 "allow": [
583 "pattern": "\\b(?<key>PROJ-\\d+)\\b",563 "Bash(npm run lint)",
584 "url": "https://issues.example.com/browse/{key}",564 "Bash(npm run test *)"
585 "label": "{key}"565 ],
586 }566 "deny": [
567 "Read(./.env)",
568 "Read(./.env.*)"
587 ]569 ]
570 }
588}571}
589```572```
590 573
591Mit 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.574Jeder Eintrag unter `permissions` ist eine Regel, die ein Tool und das, was es darf, benennt; [Berechtigungen konfigurieren](/docs/de/permissions) erklärt die Syntax. Die Zeile `$schema` verweist auf das [veröffentlichte JSON-Schema](https://json.schemastore.org/claude-code-settings.json) für Claude Code-Einstellungen, das Ihnen Autovervollständigung und Inline-Validierung in VS Code, Cursor und jedem anderen Editor gibt, der JSON-Schema unterstützt. Das Schema kann hinter den neuesten CLI-Versionen zurückbleiben, sodass eine Validierungswarnung auf einem kürzlich dokumentierten Schlüssel nicht bedeutet, dass Ihre Konfiguration ungültig ist.
592 575
593Die folgenden Einschränkungen gelten für jeden Eintrag:576Nachdem Sie speichern, führen Sie `/status` in Claude Code aus, um zu bestätigen, dass die Datei geladen wurde; [Bestätigen Sie, was geladen wurde](#check-what-loaded) sagt, was die Zeile `Setting sources` zeigt und wie eine fehlerhafte Datei gemeldet wird.
594 577
595| Einschränkung | Verhalten |578Für eine vollständige persönliche Datei, Team-Datei und Organisations-Datei, jeweils mit einem Kommentar zu jedem Schlüssel, den sie setzt, siehe die [Beispiel-Einstellungsdateien](/docs/de/settings-example).
596| :------------------ | :----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
597| 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 |
598| URL-Länge | Konstruierte URLs länger als 2048 Zeichen werden verworfen |
599| 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` |
600| Label | Standardmäßig der abgeglichene Text und wird auf 28 Anzeigespalten gekürzt |
601| Badge-Anzahl | Maximal 5 Badges werden gerendert. Das älteste wird durch neuere Übereinstimmungen verdrängt und `/clear` entfernt sie |
602| Einstellungsbereich | Nur aus Benutzereinstellungen, dem Flag `--settings` und verwalteten Einstellungen gelesen. Ignoriert in Projekt `.claude/settings.json` und lokal `.claude/settings.local.json` |
603 579
604Wenn 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 `*`.580<span id="pass-settings-for-one-session" />
605 581
606Footer-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.582<h3 id="change-a-setting-for-one-session">
607 583 Ändern Sie eine Einstellung für eine Sitzung
608<h3 id="hook-configuration">
609 Hook-Konfiguration
610</h3>584</h3>
611 585
612Diese 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.586Um einen Wert zu versuchen, ohne ihn zu speichern, setzen Sie ihn, wenn Sie Claude Code starten. Der Wert gilt für diese Sitzung und Ihre Einstellungsdateien bleiben wie sie waren. Sie haben drei Möglichkeiten, es zu tun:
613
614**Verhalten, wenn `allowManagedHooksOnly` `true` ist:**
615
616* Verwaltete Hooks und SDK-Hooks werden geladen
617* 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
618* Benutzer-Hooks, Projekt-Hooks und alle anderen Plugin-Hooks werden blockiert
619 587
620**HTTP-Hook-URLs einschränken:**588* **`--settings`**: übergeben Sie einen Schlüssel als JSON, inline oder als Pfad zu einer Datei. Claude Code wendet ihn über Ihre Benutzer-, Projekt- und lokalen Dateien und unter verwalteten Einstellungen an. Es kann jeden Schlüssel setzen, den Ihre Benutzereinstellungsdatei kann; es kann keine `Managed` oder `Global config` Schlüssel setzen.
589* **Ein Flag für diesen Schlüssel**: einige Schlüssel haben ihr eigenes Flag, wie `--model` für `model` und `--effort` für `effortLevel` und `modelSettings`.
590* **Eine Umgebungsvariable**: exportieren Sie die gepaarte Variable des Schlüssels, bevor Sie `claude` ausführen, wie `ANTHROPIC_MODEL` für `model`.
621 591
622Begrenzen 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.592Jeder Eintrag des Schlüssels auf der [Einstellungsreferenz](/docs/de/settings-reference) listet seine Überschreibungen pro Sitzung und welche Vorrang hat auf, also überprüfen Sie den Eintrag für den Schlüssel, den Sie ändern möchten.
623 593
624```json theme={null}594Befehle, die Sie in einer Sitzung ausführen, speichern meist Ihre Wahl: `/config` schreibt in Ihre Einstellungsdateien, `/model` speichert den Wert als Ihren Standard für neue Sitzungen, und `/effort` auf Ihrer Maschine speichert die Stufe als Ihren Standard für das Modell, das Sie verwenden.
625{
626 "allowedHttpHookUrls": ["https://hooks.example.com/*", "http://localhost:*"]
627}
628```
629 595
630**HTTP-Hook-Umgebungsvariablen einschränken:**596Wenn Sie `s` im `/model` Picker drücken, wechselt Claude Code das Modell, ohne es als Ihren Benutzer-Standard zu speichern. Claude Code wendet einige `/effort` Stufen, wie `max` und `ultracode`, nur auf die aktuelle Sitzung an; siehe [Passen Sie die Anstrengungsstufe an](/docs/de/model-config#adjust-effort-level).
631 597
632Begrenzen 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.598Um beispielsweise eine Sitzung auf Opus zu starten, ohne Ihren Standard zu ändern:
633 599
634```json theme={null}600```bash theme={null}
635{601claude --settings '{"model": "claude-opus-4-8"}'
636 "httpHookAllowed EnvVars": ["MY_TOKEN", "HOOK_SECRET"]
637}
638```602```
639 603
640<h3 id="compute-managed-settings-with-a-policy-helper">604<h3 id="when-edits-take-effect">
641 Berechnen Sie verwaltete Einstellungen mit einem Policy Helper605 Wenn Änderungen wirksam werden
642</h3>606</h3>
643 607
644Die 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).608Claude Code überwacht Ihre Einstellungsdateien und lädt sie neu, wenn sie sich ändern, sodass es die meisten Änderungen auf die laufende Sitzung ohne Neustart anwendet, einschließlich Änderungen an `permissions`, `hooks` und Anmeldedaten-Helfern wie `apiKeyHelper`. Das Neuladen behandelt Benutzer-, Projekt-, lokale und verwaltete Einstellungen, und Claude Code führt den [`ConfigChange` Hook](/docs/de/hooks#configchange) für jede erkannte Einstellungsdatei-Änderung aus, nicht für verwaltete Einstellungen, die von MDM oder der claude.ai-Konsole ankommen. Verwaltete Einstellungen, die von MDM oder der claude.ai-Konsole ankommen, erreichen eine laufende Sitzung nach einem Zeitplan statt sofort; die [Bereitstellungstabelle](/docs/de/managed-settings#choose-a-delivery-mechanism) gibt ihn pro Quelle an.
645
646Die Einstellung akzeptiert diese Schlüssel:
647 609
648| Schlüssel | Typ | Beschreibung |610Claude Code liest einige Schlüssel nur einmal, beim Sitzungsstart, sodass eine Änderung an einem von ihnen die laufende Sitzung nicht erreicht. Admin-seitige Schlüssel, die auch auf einen Neustart warten, wie `requiredMinimumVersion`, sind unter [wo und wann eine Richtlinie angewendet wird](/docs/de/managed-settings#where-and-when-a-policy-applies) aufgelistet. Die, die Sie am ehesten mid-Sitzung bearbeiten:
649| ------------------- | ------ | ------------------------------------------------------------------------------------------------------------------------------------------------------- |
650| `path` | string | Absoluter Pfad zur Helper-Ausführungsdatei |
651| `timeoutMs` | number | Wie lange auf den Helper gewartet werden soll, bevor die Ausführung als fehlgeschlagen behandelt wird |
652| `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` |
653 611
654Der 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:612* [`model`](/docs/de/settings-reference#model): verwenden Sie [`/model`](/docs/de/model-config#setting-your-model), um mid-Sitzung zu wechseln. Jedes Modell hat seinen eigenen Prompt-Cache, sodass die erste Anfrage nach einem Wechsel das ganze Gespräch ungecacht erneut liest; siehe [Wechsel von Modellen](/docs/de/prompt-caching#switching-models)
613* [`effortLevel`](/docs/de/settings-reference#effortlevel) und [`modelSettings`](/docs/de/settings-reference#modelsettings): verwenden Sie [`/effort`](/docs/de/model-config#adjust-effort-level), um Anstrengung mid-Sitzung zu ändern
655 614
656```json theme={null}615<span id="verify-active-settings" />
657{
658 "managedSettings": {
659 "permissions": { "deny": ["Read(//etc/secrets/**)"] }
660 },
661 "claudeMd": "# Organization context\n...",
662 "appendSystemPrompt": "Always cite the internal style guide."
663}
664```
665 616
666Wenn 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.617<span id="check-what-loaded" />
667 618
668<h3 id="settings-precedence">619<h3 id="confirm-what-loaded">
669 Einstellungspriorität620 Bestätigen Sie, was geladen wurde
670</h3>621</h3>
671 622
672Einstellungen werden in Prioritätsreihenfolge angewendet. Von höchster zu niedrigster:623Führen Sie `/status` in Claude Code aus, um zu sehen, welche Einstellungsquellen aktiv sind. Die Registerkarte **Status** enthält eine Zeile `Setting sources`, die jede Einstellungsdatei auflistet, die Claude Code für die aktuelle Sitzung geladen hat, wie `User settings` oder `Project local settings`. Wenn [verwaltete Einstellungen](/docs/de/admin-setup#decide-how-settings-reach-devices) wirksam sind, zeigt der Eintrag für verwaltete Einstellungen in Klammern, wie sie Ihre Maschine erreicht haben.
673
6741. **Verwaltete Einstellungen** ([Serververwaltete](/docs/de/server-managed-settings), [MDM/OS-Richtlinien](#configuration-scopes) oder [Verwaltete Einstellungen](/docs/de/settings#settings-files))
675 * Richtlinien, die von IT über Server-Bereitstellung, MDM-Konfigurationsprofile, Registry-Richtlinien oder verwaltete Einstellungsdateien bereitgestellt werden
676 * Können nicht durch andere Ebenen überschrieben werden, einschließlich Befehlszeilenargumenten
677 * 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.
678 * 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.
679
6802. **Befehlszeilenargumente**
681 * Temporäre Überschreibungen für eine bestimmte Sitzung. JSON, das über `--settings <file-or-json>` ü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
682
6833. **Lokale Projekteinstellungen** (`.claude/settings.local.json`)
684 * Persönliche projektspezifische Einstellungen
685 624
6864. **Gemeinsame Projekteinstellungen** (`.claude/settings.json`)625Die Zeile bestätigt, welche Dateien Claude Code gelesen hat; sie zeigt nicht, welche Datei jeden Schlüssel bereitgestellt hat. Um Einträge aufzulisten, die Claude Code abgelehnt hat, führen Sie [`claude doctor`](/docs/de/debug-your-config) aus; für ein Modell, das Projekt- oder verwaltete Einstellungen setzen, nennt der Startup-Header die Datei, die es gesetzt hat. `/status` und `/config` öffnen den gleichen Dialog auf verschiedenen Registerkarten, und die Registerkarte **Config** ist keine Ansicht Ihrer `settings.json` Inhalte.
687 * Teamübergreifend gemeinsame Projekteinstellungen in der Versionskontrolle
688 626
6895. **Benutzereinstellungen** (`~/.claude/settings.json`)627<h3 id="fix-a-broken-settings-file">
690 * Persönliche globale Einstellungen628 Beheben Sie eine fehlerhafte Einstellungsdatei
691
692Diese 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.
693
694Wenn 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.
695
696<Note>
697 **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.
698
699 Zwei Array-Einstellungen werden nicht auf diese Weise zusammengeführt:
700
701 * [`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.
702 * [`availableModels`](#available-settings): 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).
703</Note>
704
705<h3 id="verify-active-settings">
706 Aktive Einstellungen überprüfen
707</h3>629</h3>
708 630
709Fü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:631Wenn Sie JSON falsch tippen oder einen Schlüssel auf einen Wert setzen, den Claude Code nicht akzeptiert, teilt Claude Code Ihnen dies am Anfang einer interaktiven Sitzung mit. Was es zeigt, hängt davon ab, wie viel der Datei betroffen ist:
710 632
711* Wenn eine Ebene wie `User settings` oder `Project local settings` angezeigt wird, wird diese Datei gelesen.633* **Einstellungsfehler**: eine Benutzer-, Projekt- oder lokale Datei hat ungültiges JSON oder einen Wert, den das Schema ablehnt. Am Anfang einer interaktiven Sitzung zeigt Claude Code einen Dialog, der Ihnen erlaubt, die Datei mit Claudes Hilfe zu beheben, zu beenden oder ohne die fehlerhaften Einstellungen fortzufahren.
712* Wenn eine Ebene fehlt, wurde diese Datei nicht gefunden oder enthält keine Schlüssel.634* **Einstellungswarnung**: nur einzelne Einträge schlagen fehl, wie eine fehlerhafte Berechtigungsregel oder ein unbekannter Hook-Ereignisname. Claude Code überspringt diese Werte und behält den Rest der Datei wirksam.
635* **Verwaltete Einstellungen**: Claude Code erzwingt weiterhin den Rest der Datei. [Ungültige Einträge in verwalteten Einstellungen](/docs/de/managed-settings#invalid-entries-in-managed-settings) sagt, was es ablegt und welche Schlüssel auf einen strengeren Wert zurückfallen, bis Sie sie beheben. Für ein verwaltetes Einstellungsdokument, das nicht gültiges JSON ist, siehe [Verwaltetes Einstellungsdokument konnte nicht analysiert werden](/docs/de/errors#managed-settings-document-could-not-be-parsed).
636* **Konfigurationsfehler**: `~/.claude.json` kann nicht analysiert werden. Claude Code kopiert die fehlerhafte Datei zu `~/.claude/backups/.claude.json.corrupted.<timestamp>` und fragt, ob Sie beenden und sie von Hand beheben oder auf die Standardkonfiguration zurücksetzen möchten; ein `-p` Lauf druckt den Fehler und beendet. Um Ihren vorherigen Status wiederherzustellen, kopieren Sie eine der fünf neuesten `.claude.json.backup.<timestamp>` Dateien in `~/.claude/backups/` zurück, die Claude Code vor dem Schreiben der Datei speichert.
713 637
714Wenn [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.638Nachdem Sie fortfahren, führen Sie `/status` aus, um die betroffenen Dateien zu sehen, und `claude doctor` für die Details jedes Fehlers.
715 639
716Die 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.640Ein `-p` Lauf zeigt keinen Dialog. Es sei denn, [ein verwaltetes Einstellungsdokument kann nicht analysiert werden](/docs/de/errors#managed-settings-document-could-not-be-parsed), überspringt Claude Code die fehlerhafte Datei oder Werte und fährt mit dem Rest fort, sodass nach einem `-p` Lauf, der eine Einstellung ignoriert, `claude doctor` ausführen, um zu sehen, was es abgelegt hat.
717 641
718Wenn 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.642<span id="how-scopes-interact" />
719 643
720<h3 id="key-points-about-the-configuration-system">644<span id="key-points-about-the-configuration-system" />
721 Wichtige Punkte zum Konfigurationssystem
722</h3>
723 645
724* **Speicherdateien (`CLAUDE.md`)**: Enthalten Anweisungen und Kontext, die Claude beim Start lädt646<span id="which-value-claude-code-uses" />
725* **Einstellungsdateien (JSON)**: Konfigurieren Sie Berechtigungen, Umgebungsvariablen und Werkzeugverhalten
726* **Skills**: Benutzerdefinierte Aufforderungen, die mit `/skill-name` aufgerufen oder von Claude automatisch geladen werden können
727* **MCP-Server**: Erweitern Sie Claude Code mit zusätzlichen Tools und Integrationen
728* **Priorität**: Höherrangige Konfigurationen (Verwaltet) überschreiben niedrigere (Benutzer/Projekt)
729* **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
730 647
731<h3 id="system-prompt">648<span id="which-value-wins" />
732 Systemaufforderung
733</h3>
734 649
735Claudes interne Systemaufforderung wird nicht veröffentlicht. Um benutzerdefinierte Anweisungen hinzuzufügen, verwenden Sie `CLAUDE.md`-Dateien oder das Flag `--append-system-prompt`.650<h2 id="settings-precedence">
651 Einstellungspriorität
652</h2>
736 653
737<h3 id="exclude-sensitive-files">654Wenn der gleiche Schlüssel an mehr als einer Stelle erscheint, verwendet Claude Code den Wert aus der höchsten Ebene, die ihn setzt. Der Stapel unten zeigt die Ebenen, höchste oben; ein Schlüssel auf einer höheren Ebene überschreibt den gleichen Schlüssel überall darunter.
738 Ausschließen sensibler Dateien
739</h3>
740 655
741Um 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:656<SettingsPrecedence />
742 657
743```json theme={null}658In Reihenfolge, höchste Priorität zuerst:
744{
745 "permissions": {
746 "deny": [
747 "Read(./.env)",
748 "Read(./.env.*)",
749 "Read(./secrets/**)",
750 "Read(./config/credentials.json)",
751 "Read(./build)"
752 ]
753 }
754}
755```
756 659
757Dies 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.6601. **Verwaltete Einstellungen**: Einstellungen, die Ihre Organisation bereitstellt, durch eine `managed-settings.json` Datei, eine MDM-Richtlinie oder [serververwaltete Einstellungen](/docs/de/server-managed-settings) von der claude.ai-Konsole. Nichts, das Sie setzen, überschreibt sie: ein Schlüssel, den Sie mit `--settings` übergeben, überschreibt nicht den gleichen verwalteten Schlüssel, und ein Flag wie `--model` wählt nur aus den Modellen, die Ihre Organisation erlaubt. Ein verwaltetes `model` setzt das Modell, mit dem jede Sitzung startet, und Sie können immer noch mit `/model` wechseln; die Sperre ist [`availableModels`](/docs/de/settings-reference#availablemodels), die `/model`, `--model` und den `model` Schlüssel in Ihren eigenen Dateien einschränkt. Wenn Ihre Organisation mehr als eine verwaltete Quelle bereitstellt, sagen die Regeln für [Priorität innerhalb der verwalteten Ebene](/docs/de/managed-settings#precedence-within-the-managed-tier), was Claude Code aus jeder liest.
6612. **Befehlszeilenargumente**: Flags, die Sie übergeben, wenn Sie `claude` von einem Terminal aus starten, für eine Sitzung; siehe [Ändern Sie eine Einstellung für eine Sitzung](#change-a-setting-for-one-session). Claude Code führt JSON, das Sie mit `--settings <file-or-json>` übergeben, mit Ihren Einstellungsdateien nach den gleichen Regeln wie die anderen Ebenen zusammen: es nimmt einen Schlüssel, den Sie hier setzen, über den gleichen Schlüssel in lokalen, Projekt- oder Benutzereinstellungen, und behält den Wert der niedrigeren Ebene für einen Schlüssel, den Sie weglassen.
6623. **Projekt-lokale Einstellungen** (`.claude/settings.local.json`): Ihre persönlichen Einstellungen für dieses Projekt.
6634. **Gemeinsame Projekt-Einstellungen** (`.claude/settings.json`): Einstellungen, die Ihr Team in die Versionskontrolle eincheckt.
6645. **Benutzer-Einstellungen** (`~/.claude/settings.json`): Ihre persönlichen Einstellungen für jedes Projekt.
758 665
759<h2 id="subagent-configuration">666Umgebungsvariablen sind keine Ebene in diesem Stapel. Wenn ein Verhalten sowohl eine Shell-Variable als auch einen Einstellungsschlüssel hat, wird entschieden, welche angewendet wird, pro Paar, nicht nach Ebene: `ANTHROPIC_MODEL`, das in Ihrer Shell exportiert wird, gilt über den `model` Schlüssel aus jeder Datei, während `ANTHROPIC_DEFAULT_MODEL` nur gilt, wenn keine Datei `model` setzt. Die [Umgebungsvariablen-Referenz](/docs/de/env-vars#precedence) sagt, welche Schlüssel ein Paar haben und welche Claude Code zuerst liest. Ein `env` Block in einer Einstellungsdatei ist ein gewöhnlicher Schlüssel und folgt den Ebenen oben.
760 Subagent-Konfiguration
761</h2>
762 667
763Claude 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:668Für ein paar sicherheitsempfindliche Schlüssel ehrt Claude Code einen strengeren Wert aus einer niedrigeren Ebene über einen verwalteten Wert; [Ausnahmen zur Priorität der verwalteten Einstellungen](#exceptions-to-managed-settings-precedence) listet sie auf.
764 669
765* **Benutzer-Subagents**: `~/.claude/agents/`, verfügbar über alle Ihre Projekte670<h3 id="lists-merge-instead-of-overriding">
766* **Projekt-Subagents**: `.claude/agents/`, spezifisch für Ihr Projekt und teilbar mit Ihrem Team671 Listen werden zusammengeführt statt überschrieben
672</h3>
767 673
768Subagent-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).674Wenn Sie den gleichen Listen-Schlüssel, wie `permissions.allow`, in mehr als einer Datei setzen, kombiniert Claude Code die Listen statt eine zu wählen, sodass jede Datei Einträge hinzufügen kann, ohne die eines anderen zu entfernen. Vier Schlüssel, die Modell-Listen oder Pro-Modell-Einträge halten, folgen ihren eigenen Regeln:
769 675
770<h2 id="plugin-configuration">676* [`fallbackModel`](/docs/de/settings-reference#fallbackmodel) ist eine geordnete Kette, wo Position Bedeutung hat, sodass Claude Code den ganzen Wert aus der höchsten Prioritätsdatei nimmt, die ihn definiert.
771 Plugin-Konfiguration677* [`modelPicker`](/docs/de/settings-reference#modelpicker) hält eine geordnete Liste von Zeilen plus ein Replace-Flag, sodass Claude Code Zeilen aus zwei Quellen nie zusammenführt. Es nimmt den ganzen Wert aus dem höchsten von verwalteten Einstellungen, `--settings` und Benutzereinstellungen, die ihn definieren, und ignoriert den Schlüssel in Projekt- und lokalen Einstellungen. Erfordert Claude Code v2.1.242 oder später.
772</h2>678* [`availableModels`](/docs/de/settings-reference#availablemodels): wenn die verwalteten Einstellungen, die Claude Code anwendet, ihn definieren, wendet Claude Code diese Liste wie sie ist an und ignoriert Einträge, die Sie in Benutzer-, Projekt- oder lokalen Einstellungen hinzufügen, es sei denn, eine App, die Claude Code einbettet, liefert ihre eigene Modell-Liste; siehe [Ausnahmen zur Priorität der verwalteten Einstellungen](#exceptions-to-managed-settings-precedence). Über verwaltete Quellen wird die Liste auch nie zusammengeführt; [wie Claude Code verwaltete Quellen kombiniert](/docs/de/managed-settings#how-claude-code-combines-managed-sources) sagt, welche Quelle's Liste angewendet wird. Über nicht verwaltete Bereiche führt Claude Code die Arrays wie üblich zusammen.
679* [`modelSettings`](/docs/de/settings-reference#modelsettings): Claude Code löst es ein Modell auf einmal auf, zusammen mit [`effortLevel`](/docs/de/settings-reference#effortlevel). Der `modelSettings` Eintrag sagt, welche Datei's Wert auf ein Modell angewendet wird.
773 680
774Claude 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.681<span id="examples" />
775 682
776<h3 id="plugin-settings">683<h3 id="precedence-examples">
777 Plugin-Einstellungen684 Beispiele für Priorität
778</h3>685</h3>
779 686
780Plugin-bezogene Einstellungen in `settings.json`:687Während Claude arbeitet, zeigt Claude Code einen einzeiligen Tipp unter dem Spinner, wie "Verwenden Sie /config, um Ihren Standard-Berechtigungsmodus zu ändern (einschließlich Plan Mode)". Angenommen, Sie möchten diese Tipps aus, sodass Sie [`spinnerTipsEnabled`](/docs/de/settings-reference#spinnertipsenabled) auf `false` in `~/.claude/settings.json` setzen. Jedes Szenario unten ist etwas, das sie wieder einschalten kann, und was Sie dagegen tun können.
781 688
782```json theme={null}689<h4 id="team-settings-override-personal-settings">
783{690 Team-Einstellungen überschreiben persönliche Einstellungen
784 "enabledPlugins": {
785 "formatter@acme-tools": true,
786 "deployer@acme-tools": true,
787 "analyzer@security-plugins": false
788 },
789 "extraKnownMarketplaces": {
790 "acme-tools": {
791 "source": {
792 "source": "github",
793 "repo": "acme-corp/claude-plugins"
794 }
795 }
796 }
797}
798```
799
800<h4 id="enabledplugins">
801 `enabledPlugins`
802</h4>691</h4>
803 692
804Steuert, 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.693Die `.claude/settings.json` Ihres Teams setzt es auf `true`. Claude Code verwendet den Projektwert, weil gemeinsames Projekt über Benutzer sitzt, sodass Sie Tipps in diesem Projekt und nirgendwo sonst sehen.
805
806**Bereiche**:
807
808* **Benutzereinstellungen** (`~/.claude/settings.json`): Persönliche Plugin-Voreinstellungen
809* **Projekteinstellungen** (`.claude/settings.json`): Projektspezifische Plugins, die mit dem Team geteilt werden
810* **Lokale Einstellungen** (`.claude/settings.local.json`): Pro-Maschinen-Überschreibungen, gitignored wenn Claude Code es erstellt
811* **Verwaltete Einstellungen** (`managed-settings.json`): Organisationsweite Richtlinien-Überschreibungen, die die Installation auf allen Ebenen blockieren und das Plugin aus dem Marketplace ausblenden
812
813<Note>
814 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`.
815
816 Plugins, die durch verwaltete Einstellungen erzwungen aktiviert sind, können auf diese Weise nicht deaktiviert werden, da verwaltete Einstellungen lokale Einstellungen überschreiben.
817
818 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.
819</Note>
820 694
821**Beispiel**:695Sie können Ihren Wert zurückbekommen: fügen Sie `"spinnerTipsEnabled": false` zu `.claude/settings.local.json` in diesem Projekt hinzu. Projekt-lokal sitzt über gemeinsames Projekt, sodass Ihre Sitzungen dort Tipps nicht mehr zeigen und die Sitzungen Ihrer Teamkollegen sich nicht ändern.
822 696
823```json theme={null}697<h4 id="organization-settings-override-everything">
824{698 Organisations-Einstellungen überschreiben alles
825 "enabledPlugins": {
826 "code-formatter@team-tools": true,
827 "deployment-tools@team-tools": true,
828 "experimental-features@personal": false
829 }
830}
831```
832
833<h4 id="pluginconfigs">
834 `pluginConfigs`
835</h4>699</h4>
836 700
837Speichert 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.701Die verwalteten Einstellungen Ihrer Organisation setzen es auf `true`. Nichts, das Sie in Benutzer-, Projekt- oder lokale Einstellungen setzen, schaltet Tipps aus, und auch nicht `--settings`. Verwaltet ist die oberste Ebene.
838
839Dieses Beispiel speichert eine Option für ein Plugin, das vom `acme-tools` Marketplace installiert wurde:
840
841```json theme={null}
842{
843 "pluginConfigs": {
844 "deployer@acme-tools": {
845 "options": {
846 "api_endpoint": "https://api.example.com"
847 }
848 }
849 }
850}
851```
852 702
853`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.703Sie können Ihren Wert nicht zurückbekommen. Führen Sie `/status` aus, um zu sehen, welche verwaltete Quelle angewendet wird, und fragen Sie Ihren Administrator, ob die Richtlinie sich ändern sollte.
854 704
855<h4 id="extraknownmarketplaces">705<h4 id="the-command-line-overrides-your-files-for-one-session">
856 `extraKnownMarketplaces`706 Die Befehlszeile überschreibt Ihre Dateien für eine Sitzung
857</h4>707</h4>
858 708
859Definiert 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.709Sie haben die Sitzung mit `claude --settings '{"spinnerTipsEnabled": true}'` gestartet. Befehlszeile sitzt über jeder Datei außer verwaltet, sodass diese Sitzung Tipps zeigt, obwohl Ihre Dateien `false` sagen.
860
861**Wenn ein Repository `extraKnownMarketplaces` enthält**:
862
8631. Teamkollegen werden aufgefordert, den Marketplace zu installieren, wenn sie dem Ordner vertrauen
8642. Teamkollegen werden dann aufgefordert, Plugins aus diesem Marketplace zu installieren
8653. Benutzer können unerwünschte Marketplaces oder Plugins überspringen (in Benutzereinstellungen gespeichert)
8664. Die Installation respektiert Vertrauensgrenzen und erfordert explizite Zustimmung
867 710
868**Beispiel**:711Sie bekommen Ihren Wert in der nächsten Sitzung zurück; `--settings` dauert eine Sitzung und schreibt nicht in eine Datei.
869 712
870```json theme={null}713<h4 id="a-flag-or-environment-variable-sets-the-same-thing">
871{714 Ein Flag oder eine Umgebungsvariable setzt das gleiche
872 "extraKnownMarketplaces": {
873 "acme-tools": {
874 "source": {
875 "source": "github",
876 "repo": "acme-corp/claude-plugins"
877 }
878 },
879 "security-plugins": {
880 "source": {
881 "source": "git",
882 "url": "https://git.example.com/security/plugins.git"
883 }
884 }
885 }
886}
887```
888
889**Marketplace-Quellentypen**:
890
891* `github`: GitHub-Repository (verwendet `repo`)
892* `git`: Beliebige Git-URL (verwendet `url`)
893* `directory`: Lokaler Dateisystem-Pfad (verwendet `path`, nur für Entwicklung)
894* `hostPattern`: Regex-Muster zum Abgleichen von Marketplace-Hosts (verwendet `hostPattern`)
895* `settings`: Inline-Marketplace, der direkt in settings.json deklariert wird, ohne ein separates gehostetes Repository (verwendet `name` und `plugins`)
896
897Der `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.
898
899Fü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. Erfordert Claude Code v2.1.153 oder später.
900
901Jeder 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).
902
903Verwenden 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.
904
905```json theme={null}
906{
907 "extraKnownMarketplaces": {
908 "team-tools": {
909 "source": {
910 "source": "settings",
911 "name": "team-tools",
912 "plugins": [
913 {
914 "name": "code-formatter",
915 "source": {
916 "source": "github",
917 "repo": "acme-corp/code-formatter"
918 }
919 }
920 ]
921 }
922 }
923 }
924}
925```
926
927<h4 id="strictknownmarketplaces">
928 `strictKnownMarketplaces`
929</h4>715</h4>
930 716
931**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.717Einige Schlüssel haben ein Befehlszeilenflag oder eine Umgebungsvariable, die den Einstellungswert unabhängig davon überschreibt, welche Datei ihn setzt: `ANTHROPIC_MODEL` überschreibt die [`model`](/docs/de/settings-reference#model) Einstellung, und `--model` überschreibt beide für eine Sitzung.
932
933**Verwaltete Einstellungsdatei-Speicherorte**:
934
935* **macOS**: `/Library/Application Support/ClaudeCode/managed-settings.json`
936* **Linux und WSL**: `/etc/claude-code/managed-settings.json`
937* **Windows**: `C:\Program Files\ClaudeCode\managed-settings.json`
938
939**Wichtige Merkmale**:
940
941* Nur in verwalteten Einstellungen verfügbar (`managed-settings.json`)
942* Kann nicht durch Benutzer- oder Projekteinstellungen überschrieben werden (höchste Priorität)
943* Durchgesetzt VOR Netzwerk-/Dateisystem-Operationen, sodass blockierte Quellen nie ausgeführt werden
944* Verwendet exakte Übereinstimmung für Quellspezifikationen (einschließlich `ref`, `path` für Git-Quellen), außer `hostPattern` und `pathPattern`, die Regex-Abgleich verwenden
945
946**Allowlist-Verhalten**:
947
948* `undefined` (Standard): Keine Einschränkungen, sodass Benutzer jeden Marketplace hinzufügen können
949* Leeres Array `[]`: Vollständiger Lockdown, sodass Benutzer keine neuen Marketplaces hinzufügen können
950* Liste von Quellen: Benutzer können nur Marketplaces hinzufügen, die genau übereinstimmen
951
952**Alle unterstützten Quellentypen**:
953
954Die 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.
955
9561. **GitHub-Repositories**:
957
958```json theme={null}
959{ "source": "github", "repo": "acme-corp/approved-plugins" }
960{ "source": "github", "repo": "acme-corp/security-tools", "ref": "v2.0" }
961{ "source": "github", "repo": "acme-corp/plugins", "ref": "main", "path": "marketplace" }
962```
963
964Felder: `repo` (erforderlich), `ref` (optional: Branch oder Tag), `path` (optional: Unterverzeichnis)
965
9662. **Git-Repositories**:
967
968```json theme={null}
969{ "source": "git", "url": "https://gitlab.example.com/tools/plugins.git" }
970{ "source": "git", "url": "https://bitbucket.org/acme-corp/plugins.git", "ref": "production" }
971{ "source": "git", "url": "ssh://git@git.example.com/plugins.git", "ref": "v3.1", "path": "approved" }
972```
973
974Felder: `url` (erforderlich), `ref` (optional: Branch oder Tag), `path` (optional: Unterverzeichnis)
975
9763. **URL-basierte Marketplaces**:
977
978```json theme={null}
979{ "source": "url", "url": "https://plugins.example.com/marketplace.json" }
980{ "source": "url", "url": "https://cdn.example.com/marketplace.json", "headers": { "Authorization": "Bearer ${TOKEN}" } }
981```
982
983Felder: `url` (erforderlich), `headers` (optional: HTTP-Header für authentifizierten Zugriff)
984
985<Note>
986 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.
987</Note>
988
9894. **NPM-Pakete**:
990
991```json theme={null}
992{ "source": "npm", "package": "@acme-corp/claude-plugins" }
993{ "source": "npm", "package": "@acme-corp/approved-marketplace" }
994```
995
996Felder: `package` (erforderlich, unterstützt scoped Pakete)
997
9985. **Dateipfade**:
999 718
1000```json theme={null}719Ob Sie Ihren Wert zurückbekommen, hängt vom Schlüssel ab: heben Sie die Variable auf oder lassen Sie das Flag fallen, und überprüfen Sie den Eintrag des Schlüssels auf der [Einstellungsreferenz](/docs/de/settings-reference) und die Zeile der Variable auf der [Umgebungsvariablen-Referenz](/docs/de/env-vars) für welche Claude Code verwendet.
1001{ "source": "file", "path": "/usr/local/share/claude/acme-marketplace.json" }
1002{ "source": "file", "path": "/opt/acme-corp/plugins/marketplace.json" }
1003```
1004
1005Felder: `path` (erforderlich: absoluter Pfad zur marketplace.json-Datei)
1006
10076. **Verzeichnispfade**:
1008
1009```json theme={null}
1010{ "source": "directory", "path": "/usr/local/share/claude/acme-plugins" }
1011{ "source": "directory", "path": "/opt/acme-corp/approved-marketplaces" }
1012```
1013 720
1014Felder: `path` (erforderlich: absoluter Pfad zum Verzeichnis mit `.claude-plugin/marketplace.json`)721<span id="keys-ignored-in-a-repository-file" />
1015
10167. **Host-Muster-Abgleich**:
1017
1018```json theme={null}
1019{ "source": "hostPattern", "hostPattern": "^github\\.example\\.com$" }
1020{ "source": "hostPattern", "hostPattern": "^gitlab\\.internal\\.example\\.com$" }
1021```
1022
1023Felder: `hostPattern` (erforderlich: Regex-Muster zum Abgleich gegen den Marketplace-Host)
1024
1025Verwenden 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.
1026
1027Host-Extraktion nach Quellentyp:
1028
1029* `github`: passt immer gegen `github.com`
1030* `git`: extrahiert Hostname aus der URL (unterstützt sowohl HTTPS als auch SSH-Formate)
1031* `url`: extrahiert Hostname aus der URL
1032* `npm`, `file`, `directory`: nicht unterstützt für Host-Muster-Abgleich
1033
10348. **Pfad-Muster-Abgleich**:
1035
1036```json theme={null}
1037{ "source": "pathPattern", "pathPattern": "^/opt/approved/" }
1038{ "source": "pathPattern", "pathPattern": ".*" }
1039```
1040 722
1041Felder: `pathPattern` (erforderlich: Regex-Muster, das gegen das `path`-Feld von `file` und `directory`-Quellen abgeglichen wird)723<span id="keys-only-you-or-your-organization-can-set" />
1042 724
1043Verwenden 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.725<span id="common-cases" />
1044 726
1045**Konfigurationsbeispiele**:727<span id="which-value-applies-in-common-situations" />
1046 728
1047Beispiel: Nur bestimmte Marketplaces erlauben:729<h3 id="troubleshoot-a-setting-that-doesn’t-apply">
1048 730 Beheben Sie eine Einstellung, die nicht angewendet wird
1049```json theme={null}731</h3>
1050{
1051 "strictKnownMarketplaces": [
1052 {
1053 "source": "github",
1054 "repo": "acme-corp/approved-plugins"
1055 },
1056 {
1057 "source": "github",
1058 "repo": "acme-corp/security-tools",
1059 "ref": "v2.0"
1060 },
1061 {
1062 "source": "url",
1063 "url": "https://plugins.example.com/marketplace.json"
1064 },
1065 {
1066 "source": "npm",
1067 "package": "@acme-corp/compliance-plugins"
1068 }
1069 ]
1070}
1071```
1072
1073Beispiel: Alle Marketplace-Ergänzungen deaktivieren:
1074
1075```json theme={null}
1076{
1077 "strictKnownMarketplaces": []
1078}
1079```
1080
1081Beispiel: Alle Marketplaces von einem internen Git-Server erlauben:
1082
1083```json theme={null}
1084{
1085 "strictKnownMarketplaces": [
1086 {
1087 "source": "hostPattern",
1088 "hostPattern": "^github\\.example\\.com$"
1089 }
1090 ]
1091}
1092```
1093
1094**Anforderungen für exakte Übereinstimmung**:
1095
1096Marketplace-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:
1097
1098* Das `repo` oder `url` muss genau übereinstimmen
1099* Das `ref`-Feld muss genau übereinstimmen (oder beide sind undefined)
1100* Das `path`-Feld muss genau übereinstimmen (oder beide sind undefined)
1101
1102Beispiele von Quellen, die nicht übereinstimmen:
1103
1104```json theme={null}
1105// Diese sind UNTERSCHIEDLICHE Quellen:
1106{ "source": "github", "repo": "acme-corp/plugins" }
1107{ "source": "github", "repo": "acme-corp/plugins", "ref": "main" }
1108
1109// Diese sind auch UNTERSCHIEDLICH:
1110{ "source": "github", "repo": "acme-corp/plugins", "path": "marketplace" }
1111{ "source": "github", "repo": "acme-corp/plugins" }
1112```
1113
1114**Vergleich mit `extraKnownMarketplaces`**:
1115
1116| Aspekt | `strictKnownMarketplaces` | `extraKnownMarketplaces` |
1117| ----------------------------- | ----------------------------------------- | ------------------------------------------------ |
1118| **Zweck** | Durchsetzung von Organisationsrichtlinien | Team-Komfort |
1119| **Einstellungsdatei** | Nur `managed-settings.json` | Beliebige Einstellungsdatei |
1120| **Verhalten** | Blockiert nicht-allowlisted Ergänzungen | Auto-installiert fehlende Marketplaces |
1121| **Wann durchgesetzt** | Vor Netzwerk-/Dateisystem-Operationen | Nach Benutzer-Vertrauensaufforderung |
1122| **Kann überschrieben werden** | Nein (höchste Priorität) | Ja (durch höherrangige Einstellungen) |
1123| **Quellenformat** | Direktes Quellobjekt | Benannter Marketplace mit verschachtelter Quelle |
1124| **Anwendungsfall** | Compliance, Sicherheitsbeschränkungen | Onboarding, Standardisierung |
1125
1126**Formatunterschied**:
1127
1128`strictKnownMarketplaces` verwendet direkte Quellobjekte:
1129
1130```json theme={null}
1131{
1132 "strictKnownMarketplaces": [
1133 { "source": "github", "repo": "acme-corp/plugins" }
1134 ]
1135}
1136```
1137 732
1138`extraKnownMarketplaces` erfordert benannte Marketplaces:733Wenn Sie einen Schlüssel setzen und Claude Code sich nicht so verhält, als hätten Sie, beginnen Sie mit `/status`, um zu sehen, welche Dateien es geladen hat, dann finden Sie Ihr Symptom unten. [Debuggen Sie Ihre Konfiguration](/docs/de/debug-your-config) behandelt die breiteren Überprüfungen, einschließlich eines sauberen Konfigurationstests.
1139 734
1140```json theme={null}735<h4 id="a-value-you-set-is-ignored">
1141{736 Ein Wert, den Sie setzen, wird ignoriert
1142 "extraKnownMarketplaces": {737</h4>
1143 "acme-tools": {
1144 "source": { "source": "github", "repo": "acme-corp/plugins" }
1145 }
1146 }
1147}
1148```
1149 738
1150**Beide zusammen verwenden**:739Etwas anderes setzt den gleichen Schlüssel, die Datei kann diesen Wert nicht setzen, oder die Datei wurde nicht geladen:
1151 740
1152`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`:741* **Eine höhere Ebene setzt ihn.** Eine andere Einstellungsdatei, ein `--settings` Flag oder eine verwaltete Quelle setzt den Schlüssel über Ihrem; der [Stapel](#settings-precedence) sagt welche. Ein Flag oder eine Umgebungsvariable kann auch den Schlüssel auf eigene Faust überschreiben, entschieden Schlüssel für Schlüssel; der Eintrag des Schlüssels auf der [Einstellungsreferenz](/docs/de/settings-reference) sagt, welche Claude Code verwendet, und der [`env` Eintrag](/docs/de/settings-reference#env) behandelt einen verwalteten `env` Wert versus einen Shell-Export.
742* **Ein Sicherheitsschlüssel behält seinen strengen Wert.** Für ein paar Schlüssel ehrt Claude Code den restriktiven Wert aus jeder Datei, sodass ein Projekt `true` für [`disableClaudeAiConnectors`](/docs/de/settings-reference#disableclaudeaiconnectors) bleibt an; siehe [Ausnahmen zur Priorität der verwalteten Einstellungen](#exceptions-to-managed-settings-precedence).
743* **Die Datei kann diesen Wert nicht setzen.** [`permissions.defaultMode`](/docs/de/settings-reference#permissions-defaultmode) Werte `auto` und `bypassPermissions` wirken sich nicht von Projekt- oder lokalen Einstellungen aus; setzen Sie sie stattdessen in Benutzer- oder verwaltete Einstellungen, oder übergeben Sie `--permission-mode` für eine Sitzung. Vor v2.1.257 wirkte sich `bypassPermissions` von jeder Datei aus.
744* **Die Datei ist fehlerhaft.** Ungültiges JSON oder ein abgelehnter Wert lässt Claude Code die Datei oder den Eintrag überspringen; siehe [Beheben Sie eine fehlerhafte Einstellungsdatei](#fix-a-broken-settings-file).
1153 745
1154```json theme={null}746<h4 id="a-change-you-made-in-claude-code-is-lost-in-new-sessions">
1155{747 Eine Änderung, die Sie in Claude Code gemacht haben, geht in neuen Sitzungen verloren
1156 "strictKnownMarketplaces": [748</h4>
1157 { "source": "github", "repo": "acme-corp/plugins" }
1158 ],
1159 "extraKnownMarketplaces": {
1160 "acme-tools": {
1161 "source": { "source": "github", "repo": "acme-corp/plugins" }
1162 }
1163 }
1164}
1165```
1166 749
1167Mit nur `strictKnownMarketplaces` gesetzt, können Benutzer den erlaubten Marketplace weiterhin manuell über `/plugin marketplace add` hinzufügen, aber er ist nicht automatisch verfügbar.750Wenn Sie eine Wahl für neue Sitzungen von innen Claude Code speichern, wie ein Standardmodell mit `/model`, schreibt Claude Code es in Ihre Benutzereinstellungsdatei, `~/.claude/settings.json`. Wenn Sie nicht in diese Datei schreiben können, zum Beispiel weil ein anderes Tool sie generiert oder sie mit einer schreibgeschützten Kopie verlinkt, gilt die Änderung für die aktuelle Sitzung und ist in der nächsten weg. Setzen Sie den Schlüssel in das Tool, das die Datei generiert, oder ersetzen Sie die Datei mit einer, in die Sie schreiben können.
1168 751
1169**Wichtige Hinweise**:752Wenn Sie in die Datei schreiben können und die Änderung bleibt immer noch nicht, überprüfen Sie, ob die Änderung [nur für eine Sitzung](#change-a-setting-for-one-session) war oder [eine höhere Ebene setzt den gleichen Schlüssel](#a-value-you-set-is-ignored). Für den `model` Schlüssel, [Eine neue Sitzung startet auf einem anderen Modell als Sie gewählt haben](/docs/de/model-config#a-new-session-starts-on-a-different-model-than-you-picked) listet mehr Ursachen auf.
1170 753
1171* Einschränkungen werden VOR Netzwerkanfragen oder Dateisystem-Operationen überprüft754<h4 id="a-managed-change-hasn’t-reached-you">
1172* Wenn blockiert, sehen Benutzer klare Fehlermeldungen, die angeben, dass die Quelle durch verwaltete Richtlinie blockiert ist755 Eine verwaltete Änderung hat Sie nicht erreicht
1173* 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 übereinstimmt756</h4>
1174* Verwaltete Einstellungen haben die höchste Priorität und können nicht überschrieben werden
1175 757
1176Siehe [Verwaltete Marketplace-Einschränkungen](/docs/de/plugin-marketplaces#managed-marketplace-restrictions) für Dokumentation für Benutzer.758Verwaltete Quellen erreichen eine laufende Sitzung nach dem Zeitplan in der [Bereitstellungstabelle](/docs/de/managed-settings#choose-a-delivery-mechanism), sodass starten Sie die Sitzung zuerst neu. Wenn `/status` dann eine andere Quelle nennt als die, die Ihr Administrator geändert hat, gilt eine höherrangige Quelle; [Wie Claude Code verwaltete Quellen kombiniert](/docs/de/managed-settings#how-claude-code-combines-managed-sources) gibt die Reihenfolge.
1177 759
1178<h4 id="strictpluginonlycustomization">760<h4 id="a-committed-key-doesn’t-reach-teammates">
1179 `strictPluginOnlyCustomization`761 Ein eingecheckter Schlüssel erreicht Teamkollegen nicht
1180</h4>762</h4>
1181 763
1182**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.764Zwei Dinge halten einen Schlüssel in `.claude/settings.json` davon ab, für alle zu gelten, die ihn klonen:
1183
1184Der Wert ist entweder `true`, um alle vier Oberflächen zu sperren, oder ein Array, das die zu sperrenden Oberflächen benennt:
1185 765
1186```json theme={null}766* **Claude Code ignoriert den Schlüssel in einer Repository-Datei.** Suchen Sie nach `User, local, or managed`, `User or managed`, `Managed` oder `Global config` in der Spalte Scope des [Einstellungsindex](/docs/de/settings-reference#settings-index); diese Schlüssel wirken sich nie von der gemeinsamen Datei aus, außer [`autoContinueAtUsageLimit`](/docs/de/settings-reference#autocontinueatusagelimit), das eine Repository-Datei immer noch ausschalten kann: während die Datei den Schlüssel setzt und kein Benutzer, `--settings` oder verwalteter Wert, liest Claude Code die Einstellung als aus. `Global config` Schlüssel gelten nur von `~/.claude.json`.
1187{767* **Der Schlüssel wartet auf Vertrauen.** `permissions.allow` Regeln, `permissions.additionalDirectories`, `extraKnownMarketplaces` und die meisten [`env`](/docs/de/settings-reference#env) Werte gelten nur, nachdem jeder Teamkollege den [Ordner vertraut](/docs/de/permissions#project-allow-rules-and-workspace-trust). Bis dahin sehen sie immer noch Aufforderungen und bekommen keine Plugins von einem Marketplace, den die Datei erklärt. `deny` und `ask` Regeln gelten sofort.
1188 "strictPluginOnlyCustomization": ["skills", "hooks"]
1189}
1190```
1191 768
1192Für jede gesperrte Oberfläche überspringt Claude Code Benutzer- und Projektquellen und lädt nur Plugin-bereitgestellte und verwaltete Quellen:769<h4 id="permission-rules-combine-differently-than-you-expected">
770 Berechtigungsregeln kombinieren sich anders als Sie erwartet
771</h4>
1193 772
1194| Oberfläche | Blockiert wenn gesperrt | Lädt weiterhin |773* **Sie haben "Ja, und frag mich nicht mehr" auf einer Berechtigungsaufforderung gewählt, aber bekommen immer noch eine Aufforderung für das gleiche Tool.** Diese Wahl speicherte eine `allow` Regel in Ihrer lokalen Datei, und eine `allow` Regel dort übertrifft nicht eine `ask` Regel aus einer Projekt- oder verwalteten Datei; [wie Berechtigungsregeln kombinieren](/docs/de/permissions#settings-precedence) erklärt die Reihenfolge. In der VS Code-Erweiterung lässt die Genehmigungskarte Sie die Zieldatei wählen, einschließlich der gemeinsamen Datei des Projekts, was die Regel für alle ändert; in der CLI schreibt Claude Code nur in Ihre lokale Datei.
1195| :--------- | :------------------------------------------------------- | :------------------------------------------------------------------------------ |774* **Die Allow-Regeln Ihrer Organisation gelten immer noch neben Ihren.** Das ist erwartet: Claude Code führt [`permissions.allow`](/docs/de/settings-reference#permissions-allow) über Bereiche zusammen, es sei denn, Ihre Organisation setzt [`allowManagedPermissionRulesOnly`](/docs/de/settings-reference#allowmanagedpermissionrulesonly).
1196| `skills` | `~/.claude/skills/`, `.claude/skills/` | Plugin-Skills, gebündelte Skills, Skills im verwalteten Richtlinienverzeichnis |
1197| `agents` | `~/.claude/agents/`, `.claude/agents/` | Plugin-Agents, integrierte Agents, Agents im verwalteten Richtlinienverzeichnis |
1198| `hooks` | Hooks in Benutzer-, Projekt- und lokalen `settings.json` | Plugin-Hooks, Hooks in verwalteten Einstellungen |
1199| `mcp` | Server in `~/.claude.json` und `.mcp.json` | Plugin-MCP-Server, [`managed-mcp.json`](/docs/de/managed-mcp) Server |
1200 775
1201Oberflä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.776<span id="security-keys-where-the-stricter-value-applies" />
1202 777
1203<h3 id="manage-plugins">778<h3 id="exceptions-to-managed-settings-precedence">
1204 Verwalten von Plugins779 Ausnahmen zur Priorität der verwalteten Einstellungen
1205</h3>780</h3>
1206 781
1207Verwenden Sie den Befehl `/plugin`, um Plugins interaktiv zu verwalten:782Für ein paar sicherheitsempfindliche Schlüssel ehrt Claude Code einen restriktiven Wert aus einem Bereich, der ansonsten verwaltete Einstellungen nicht überschreiben könnte. Finden Sie den Schlüssel in dieser Tabelle, um zu sehen, welchen Wert er ehrt und von wo.
1208 783
1209* Durchsuchen Sie verfügbare Plugins aus Marketplaces784| Schlüssel | Wert, den Claude Code ehrt | Notizen |
1210* Installieren/Deinstallieren Sie Plugins785| :------------------------------------------------------------------------------ | :-------------------------------------------------------------------------------------------------------------------------------- | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
1211* Aktivieren/Deaktivieren Sie Plugins786| [`disableClaudeAiConnectors`](/docs/de/settings-reference#disableclaudeaiconnectors) | `true` aus jedem Bereich | Geehrt, auch wenn eine verwaltete Quelle `false` setzt |
1212* Zeigen Sie Plugin-Details an (bereitgestellte Skills, Agents, Hooks)787| [`enableArtifact`](/docs/de/settings-reference#enableartifact) | `false` aus jedem Bereich und `disableArtifact: true` aus jedem Bereich | Geehrt, auch wenn eine verwaltete Quelle `true` setzt; nichts schaltet das [Artifact-Tool](/docs/de/artifacts#disable-artifacts) wieder ein. Erfordert Claude Code v2.1.242 oder später |
1213* Fügen Sie Marketplaces hinzu/entfernen Sie sie788| [`isolatePeerMachines`](/docs/de/settings-reference#isolatepeermachines) | `true` aus jedem Bereich | Geehrt, auch wenn eine verwaltete Quelle `false` setzt |
789| [`remoteControlAtStartup`](/docs/de/settings-reference#remotecontrolatstartup) | `false` aus `.claude/settings.json` oder `.claude/settings.local.json` | Geehrt, auch wenn eine verwaltete Quelle `true` setzt; ein Projekt- oder lokales `true` wird ignoriert |
790| [`crossSessionInbound`](/docs/de/settings-reference#crosssessioninbound) | Ein strengerer Wert aus `.claude/settings.json` oder `.claude/settings.local.json`, auf der `accept` \< `hold` \< `refuse` Leiter | Geehrt über verwaltete, `--settings` und Benutzer-Werte; ein Projekt- oder lokaler Wert, der nicht strenger ist, wird ignoriert |
791| [`useAutoModeDuringPlan`](/docs/de/settings-reference#useautomodeduringplan) | `false` aus jeder verwalteten Quelle, `--settings`, `~/.claude/settings.json` oder `.claude/settings.local.json` | Geehrt, auch wenn die gewinnende verwaltete Quelle `true` setzt; ein `false` in `.claude/settings.json` wird ignoriert |
792| [`syncClaudeAiSkills`](/docs/de/settings-reference#syncclaudeaiskills) | `false` aus jeder verwalteten Quelle, `--settings`, `~/.claude/settings.json` oder `.claude/settings.local.json` | Geehrt, auch wenn die gewinnende verwaltete Quelle `true` setzt; ein `false` in `.claude/settings.json` wird ignoriert |
1214 793
1215Erfahren Sie mehr über das Plugin-System in der [Plugins-Dokumentation](/docs/de/plugins).794Eine App, die Claude Code in sich selbst ausführt und [`CLAUDE_CODE_PROVIDER_MANAGED_BY_HOST`](/docs/de/env-vars) setzt, ist auch eine Ausnahme. Claude Code nimmt die Modell-Konfiguration dieser App über die `model`, `fallbackModel` und `modelOverrides` Schlüssel aus jeder verwalteten Quelle, und über die Modell-Auswahl-Variablen in einem verwalteten `env` Block, wie `ANTHROPIC_MODEL` und die `ANTHROPIC_DEFAULT_*_MODEL` Familie. Claude Code behält eine verwaltete [`availableModels`](/docs/de/settings-reference#availablemodels) Allowlist in Kraft, es sei denn, die App liefert ihre eigene.
1216 795
1217<h2 id="environment-variables">796<h2 id="settings-in-cloud-sessions">
1218 Umgebungsvariablen797 Einstellungen in Cloud-Sitzungen
1219</h2>798</h2>
1220 799
1221Umgebungsvariablen 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.800Eine Cloud-Sitzung, auf [Claude Code im Web](/docs/de/claude-code-on-the-web) oder von [`claude --cloud`](/docs/de/claude-code-on-the-web#from-terminal-to-web), läuft in einer [Cloud-Umgebung](/docs/de/cloud-environments) auf einem frischen Klon Ihres Repositorys, nicht auf Ihrer Maschine. Das ändert, welche Einstellungen es erreichen:
1222
1223Siehe die [Umgebungsvariablen-Referenz](/docs/de/env-vars) für die vollständige Liste.
1224
1225<h2 id="tools-available-to-claude">
1226 Tools, die Claude zur Verfügung stehen
1227</h2>
1228 801
1229Claude 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.802* **Gemeinsame Projekt-Einstellungen** (`.claude/settings.json`): gelesen, weil die Datei Teil des Klons ist. Committen Sie eine Einstellung dort, um sie in Cloud-Sitzungen anzuwenden.
803* **Benutzer- und Projekt-lokale Einstellungen** (`~/.claude/settings.json` und `.claude/settings.local.json`): nicht gelesen. Beide bleiben auf Ihrer Maschine, und die lokale Datei ist nicht im Klon.
804* **Verwaltete Einstellungen**: nur [serververwaltete Einstellungen](/docs/de/server-managed-settings) erreichen eine Cloud-Sitzung; eine `managed-settings.json` Datei oder MDM-Profil auf Ihrem Gerät nicht. Eine [selbstgehostete Umgebung](/docs/de/self-hosted-environments) liest auch die verwaltete Einstellungsdatei in ihrem Runner-Image. [Wie Claude Code verwaltete Quellen kombiniert](/docs/de/managed-settings#how-claude-code-combines-managed-sources) sagt, wann diese Datei angewendet wird.
805* **`/config`**: im Web öffnet die Claude Code-Sektion Ihrer claude.ai-Einstellungen statt einen Wert zu ändern. Um eine Einstellung für eine Cloud-Sitzung zu ändern, setzen Sie eine [Umgebungsvariable](/docs/de/cloud-environments#set-environment-variables) auf der Umgebung oder committen Sie den Schlüssel zu der `.claude/settings.json` des Repositorys.
1230 806
1231Siehe die [Tools-Referenz](/docs/de/tools-reference) für die vollständige Liste und Details zum Bash-Tool-Verhalten.807[Was von Ihrem Setup überträgt](/docs/de/cloud-environments#what-carries-over-from-your-setup) listet den Rest auf: `CLAUDE.md`, Skills, MCP-Server, Plugins und Anmeldedaten.
1232 808
1233<h2 id="see-also">809<h2 id="what’s-next">
1234 Siehe auch810 Was kommt als nächstes
1235</h2>811</h2>
1236 812
1237* [Berechtigungen](/docs/de/permissions): Berechtigungssystem, Regelsyntax, werkzeugspezifische Muster und verwaltete Richtlinien813* [Alle Einstellungen](/docs/de/settings-reference): jeder Schlüssel, mit wo Sie ihn setzen und einem Beispiel
1238* [Authentifizierung](/docs/de/authentication): Richten Sie Benutzerzugriff auf Claude Code ein814* [Beispiel-Einstellungsdateien](/docs/de/settings-example): eine persönliche Datei, eine Team-Datei und eine verwaltete Datei einer Organisation
1239* [Konfiguration debuggen](/docs/de/debug-your-config): Diagnostizieren Sie, warum eine Einstellung, ein Hook oder ein MCP-Server nicht wirksam wird815* [Berechtigungen konfigurieren](/docs/de/permissions): allow, ask und deny Regeln, und was Claude Code ohne Nachfrage ausführt
1240* [Troubleshooting bei Installation und Anmeldung](/docs/de/troubleshoot-install): Installations-, Authentifizierungs- und Plattformprobleme816* [Umgebungsvariablen](/docs/de/env-vars): die Variablen, die Claude Code liest und der `env` Block
817* [Debuggen Sie Ihre Konfiguration](/docs/de/debug-your-config): wenn eine Einstellung nicht angewendet wird
818* [Claude-Verzeichnis-Referenz](/docs/de/claude-directory): jede Datei, die Claude Code liest, einschließlich Subagents, MCP-Server, Plugins und `CLAUDE.md`