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# Impostazioni di Claude Code5# File di impostazioni e precedenza
6 6
7> Configura Claude Code con impostazioni globali e a livello di progetto, e variabili di ambiente.7> Modifica le impostazioni di Claude Code, scegli l'ambito a cui appartiene una chiave, verifica la modifica e scopri quale valore Claude Code utilizza quando una chiave è impostata in più posizioni.
8 8
9Claude Code offre una varietà di impostazioni per configurare il suo comportamento in base alle vostre esigenze. Potete configurare Claude Code eseguendo il comando `/config`, che apre un'interfaccia Impostazioni con schede dove potete visualizzare le informazioni di stato e modificare le opzioni di configurazione. A partire dalla versione 2.1.181, potete modificare una singola opzione senza aprire l'interfaccia passando `key=value` a `/config`, ad esempio `/config verbose=true`.9export const SettingsPrecedence = () => {
10 10 const LEVELS = [{
11<h2 id="configuration-scopes">11 n: 1,
12 Ambiti di configurazione12 name: 'Managed settings',
13</h2>13 file: 'managed-settings.json, MDM, or the claude.ai console',
14 14 who: 'Your organization',
15Claude Code utilizza un sistema di ambiti per determinare dove si applicano le configurazioni e con chi vengono condivise. Comprendere gli ambiti ti aiuta a decidere come configurare Claude Code per uso personale, collaborazione di team o distribuzione aziendale.15 w: 390
16 16 }, {
17<h3 id="available-scopes">17 n: 2,
18 Ambiti disponibili18 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
373Le impostazioni sono le chiavi JSON che modificano il comportamento di Claude Code: quale modello avvia, cosa può eseguire senza chiedere, quali file non può leggere, come appare nel vostro terminale e cosa la vostra organizzazione applica.
374
375<Tip>
376 Per cercare una chiave specifica, andate a [Tutte le impostazioni](/docs/it/settings-reference), che elenca ogni chiave con il file in cui la impostate, il suo valore predefinito e un esempio.
377</Tip>
378
379Claude Code legge le impostazioni da file di impostazioni JSON come `~/.claude/settings.json`. Le cerca in pochi percorsi, e [il file da cui legge un'impostazione decide a chi si applica](#settings-files-and-who-they-affect). Questa pagina copre quei file: quale usare per un'impostazione, come modificare un'impostazione e confermare che è stata applicata, e quale valore Claude Code utilizza quando la stessa chiave è impostata in più di un file. [Configura i permessi](/docs/it/permissions) copre cosa Claude Code può eseguire senza chiedere e come scrivere regole `allow`, `ask` e `deny`.
20 380
21| Ambito | Posizione | Chi è interessato | Condiviso con il team? |381<Note>
22| :---------- | :------------------------------------------------------------------------------------------------ | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :----------------------------------------- |382 Questa pagina copre Claude Code in esecuzione sulla vostra macchina: il terminale, le estensioni [VS Code](/docs/it/vs-code) e [JetBrains](/docs/it/jetbrains), e l'[app desktop](/docs/it/desktop), che leggono tutti gli stessi file di impostazioni. Una sessione cloud su [Claude Code sul web](/docs/it/claude-code-on-the-web) viene eseguita su una macchina diversa e legge solo alcuni di essi; vedere [Impostazioni nelle sessioni cloud](#settings-in-cloud-sessions).
23| **Managed** | Impostazioni gestite dal server, plist / registro, o `managed-settings.json` a livello di sistema | Tutti i membri dell'organizzazione per la distribuzione gestita dal server; tutti gli utenti sulla macchina per plist, registro HKLM e distribuzione di file; l'utente corrente per la distribuzione del registro HKCU | Sì (distribuito da IT) |383</Note>
24| **User** | Directory `~/.claude/` | Tu, in tutti i progetti | No |
25| **Project** | `.claude/` nel repository | Tutti i collaboratori su questo repository | Sì (committato in git) |
26| **Local** | `.claude/settings.local.json` | Tu, solo in questo repository | No (gitignored quando Claude Code lo crea) |
27 384
28<h3 id="when-to-use-each-scope">385<span id="settings-files" />
29 Quando utilizzare ogni ambito
30</h3>
31 386
32L'ambito **Managed** è per:387<span id="configuration-scopes" />
33 388
34* Politiche di sicurezza che devono essere applicate a livello organizzativo389<span id="available-scopes" />
35* Requisiti di conformità che non possono essere ignorati
36* Configurazioni standardizzate distribuite da IT/DevOps
37 390
38L'ambito **User** è migliore per:391<span id="when-to-use-each-scope" />
39 392
40* Preferenze personali che desideri ovunque (temi, impostazioni dell'editor)393<span id="what-uses-scopes" />
41* Strumenti e plugin che utilizzi in tutti i progetti
42* Chiavi API e autenticazione (archiviate in modo sicuro)
43 394
44L'ambito **Project** è migliore per:395<span id="subagent-configuration" />
45 396
46* Impostazioni condivise dal team (permessi, hooks, MCP servers)397<span id="where-settings-live" />
47* Plugin che l'intero team dovrebbe avere
48* Standardizzazione degli strumenti tra i collaboratori
49 398
50L'ambito **Local** è migliore per:399<h2 id="settings-files-and-who-they-affect">
400 File di impostazioni e chi ne è interessato
401</h2>
51 402
52* Override personali per un progetto specifico403Claude Code legge le impostazioni da quattro file, e un'organizzazione può anche fornire impostazioni gestite dalla console claude.ai. Ogni fonte ha un ambito: l'insieme di persone e progetti a cui si applica un'impostazione salvata in essa, che sia solo voi, tutti in un progetto, o tutti nella vostra organizzazione.
53* Test delle configurazioni prima di condividerle con il team
54* Impostazioni specifiche della macchina che non funzioneranno per altri
55 404
56<h3 id="how-scopes-interact">405| Ambito | File | Chi è interessato | Usalo per |
57 Come interagiscono gli ambiti406| :----------------- | :---------------------------------------------------------------------------------------- | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :------------------------------------------------------------------------------------------ |
58</h3>407| Utente | `~/.claude/settings.json` | Voi, in ogni progetto su questa macchina | Preferenze personali: tema, modalità editor, modello predefinito, vostre regole di permesso |
408| Progetto condiviso | `.claude/settings.json` | Tutti coloro che lavorano nella cartella che lo contiene. In un repository git, committalo in modo che i compagni di squadra lo ottengano | Permessi del team, hooks, plugin e le variabili di ambiente di cui il progetto ha bisogno |
409| Progetto locale | `.claude/settings.local.json` | Voi, solo in questo progetto. Claude Code lo mantiene fuori da git quando crea il file; se lo create manualmente, aggiungetelo a `.gitignore` voi stessi | Override personali per un progetto e test prima di condividere |
410| Gestito | `managed-settings.json` e altre [fonti gestite](/docs/it/managed-settings#delivery-mechanisms) | Tutti coloro a cui la vostra organizzazione lo distribuisce; nulla di quello che impostate lo ignora, a parte poche [eccezioni sensibili alla sicurezza](#exceptions-to-managed-settings-precedence) | Politica di sicurezza e requisiti di conformità |
59 411
60Quando la stessa impostazione è configurata in più ambiti, Claude Code le applica in ordine di priorità:412Nella colonna File, `~/.claude` è la cartella `.claude` nella vostra directory home, e un `.claude` nudo è la cartella `.claude` dentro il vostro progetto.
61 413
621. **Managed** (più alta): non può essere ignorata da nulla414<span id="where-each-file-applies" />
632. **Argomenti della riga di comando**: override temporanei della sessione
643. **Local**: ignora le impostazioni di progetto e utente
654. **Project**: ignora le impostazioni utente
665. **User** (più bassa): si applica quando nient'altro specifica l'impostazione
67 415
68Ad esempio, se le impostazioni utente impostano `spinnerTipsEnabled` su `true` e le impostazioni di progetto lo impostano su `false`, si applica il valore del progetto. Le regole di permesso si comportano diversamente perché si uniscono tra gli ambiti piuttosto che ignorarsi. Vedi [Precedenza delle impostazioni](#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 Cosa utilizza gli ambiti419 Confronta l'ambito di ogni file di impostazioni
72</h3>420</h3>
73 421
74Gli ambiti si applicano a molte funzionalità di Claude Code:422Supponiamo che abbiate tre progetti sulla vostra macchina, `website/`, `api/` e `acme-app/`, un compagno di squadra ha il suo clone di `acme-app/`, e avviate una [sessione cloud](#settings-in-cloud-sessions) su `acme-app/`.
75
76| Funzionalità | Posizione utente | Posizione progetto | Posizione locale |
77| :-------------- | :------------------------ | :-------------------------------- | :------------------------------ |
78| **Settings** | `~/.claude/settings.json` | `.claude/settings.json` | `.claude/settings.local.json` |
79| **Subagents** | `~/.claude/agents/` | `.claude/agents/` | Nessuno |
80| **MCP servers** | `~/.claude.json` | `.mcp.json` | `~/.claude.json` (per-progetto) |
81| **Plugins** | `~/.claude/settings.json` | `.claude/settings.json` | `.claude/settings.local.json` |
82| **CLAUDE.md** | `~/.claude/CLAUDE.md` | `CLAUDE.md` o `.claude/CLAUDE.md` | `CLAUDE.local.md` |
83
84Su Windows, i percorsi mostrati come `~/.claude` si risolvono in `%USERPROFILE%\.claude`.
85 423
86***424Il grafico sottostante mostra a quali di quelle cartelle si applica un'impostazione quando avviate Claude Code da esse. Cliccate su un file di impostazioni per vedere le cartelle che raggiunge.
87 425
88<h2 id="settings-files">426<SettingsScope />
89 File di impostazioni
90</h2>
91
92Il file `settings.json` è il meccanismo ufficiale per configurare Claude Code attraverso impostazioni gerarchiche:
93
94* **Le impostazioni utente** sono definite in `~/.claude/settings.json` e si applicano a tutti i progetti.
95* **Le impostazioni di progetto** vengono salvate nella directory del tuo progetto:
96 * `.claude/settings.json` per le impostazioni che vengono controllate nel controllo del codice sorgente e condivise con il tuo team
97 * `.claude/settings.local.json` per le impostazioni che non vengono controllate, utili per preferenze personali e sperimentazione. Quando Claude Code crea `.claude/settings.local.json`, configura git per ignorare il file. Se crei il file tu stesso, aggiungilo al tuo gitignore manualmente.
98
99 Poiché questo file è tuo piuttosto che del repository, le sue regole di permesso `allow` hanno effetto senza il passaggio di [fiducia dell'area di lavoro](/docs/it/permissions#project-allow-rules-and-workspace-trust) che le regole allow di `.claude/settings.json` richiedono. Se il repository fornisce il file, ad esempio eseguendone il commit, la fiducia dell'area di lavoro si applica comunque.
100* **Impostazioni gestite**: Per le organizzazioni che necessitano di controllo centralizzato, Claude Code supporta più meccanismi di distribuzione per le impostazioni gestite. Tutti utilizzano lo stesso formato JSON e non possono essere ignorati dalle impostazioni utente o di progetto:
101
102 * **Impostazioni gestite dal server**: consegnate da remoto al momento dell'accesso, sia dai server di Anthropic tramite la console di amministrazione claude.ai che da un [gateway di app Claude](/docs/it/claude-apps-gateway) auto-ospitato. Vedi [impostazioni gestite dal server](/docs/it/server-managed-settings).
103 * **Politiche MDM/a livello di sistema operativo**: consegnate tramite la gestione nativa dei dispositivi su macOS e Windows:
104 * macOS: dominio delle preferenze gestite `com.anthropic.claudecode`. Le chiavi di primo livello del plist rispecchiano `managed-settings.json`, con impostazioni annidate come dizionari e array come array plist. Distribuisci tramite profili di configurazione in Jamf, Iru (Kandji) o strumenti MDM simili.
105 * Windows: chiave di registro `HKLM\SOFTWARE\Policies\ClaudeCode` con un valore `Settings` (REG\_SZ o REG\_EXPAND\_SZ) contenente JSON (distribuito tramite Criteri di gruppo o Intune)
106 * Windows (a livello utente): `HKCU\SOFTWARE\Policies\ClaudeCode` (priorità di politica più bassa, utilizzata solo quando non esiste alcuna fonte a livello di amministratore)
107 * **Basate su file**: `managed-settings.json` e `managed-mcp.json` distribuite alle directory di sistema:
108 427
109 * macOS: `/Library/Application Support/ClaudeCode/`428* **`~/.claude/settings.json`**: ogni progetto sulla vostra macchina, e nulla su quella del vostro compagno di squadra o nella sessione cloud
110 * Linux e WSL: `/etc/claude-code/`429* **`acme-app/.claude/settings.json`**: il vostro `acme-app/`. Raggiunge il clone del vostro compagno di squadra e la sessione cloud solo se committate il file al controllo della versione; fino a quando non lo fate, è un file sul vostro disco come qualsiasi altro e nessun altro lo ha
111 * Windows: `C:\Program Files\ClaudeCode\`430* **`acme-app/.claude/settings.local.json`**: il vostro `acme-app/` solo. Claude Code lo aggiunge ai vostri esclusioni git globali la prima volta che scrive il file, quindi rimane fuori dai vostri commit; se create il file manualmente, [aggiungetelo a `.gitignore` voi stessi](#keep-personal-settings-out-of-a-repository)
431* **Impostazioni gestite**, che sia un file `managed-settings.json`, una politica MDM, o [impostazioni gestite dal server](/docs/it/server-managed-settings) dalla console claude.ai: ogni progetto su ogni macchina a cui la vostra organizzazione lo distribuisce, o a cui vi accedete con il vostro account organizzativo. Solo le impostazioni gestite dal server raggiungono la sessione cloud
112 432
113 <Warning>433<span id="which-files-you-have" />
114 Il percorso Windows legacy `C:\ProgramData\ClaudeCode\managed-settings.json` non è più supportato a partire da v2.1.75. Gli amministratori che hanno distribuito impostazioni in quella posizione devono migrare i file a `C:\Program Files\ClaudeCode\managed-settings.json`.
115 </Warning>
116 434
117 Le impostazioni gestite basate su file supportano anche una directory drop-in in `managed-settings.d/` nella stessa directory di sistema insieme a `managed-settings.json`. Questo consente ai team separati di distribuire frammenti di politica indipendenti senza coordinare le modifiche a un singolo file.435<h3 id="find-or-create-your-settings-files">
118 436 Trovate o create i vostri file di impostazioni
119 Seguendo la convenzione systemd, `managed-settings.json` viene unito per primo come base, quindi tutti i file `*.json` nella directory drop-in vengono ordinati alfabeticamente e uniti in cima. I file successivi ignorano quelli precedenti per i valori scalari; gli array vengono concatenati e deduplicati; gli oggetti vengono uniti in profondità. I file nascosti che iniziano con `.` vengono ignorati.437</h3>
120
121 Usa prefissi numerici per controllare l'ordine di unione, ad esempio `10-telemetry.json` e `20-security.json`.
122 438
123 Vedi [impostazioni gestite](/docs/it/permissions#managed-only-settings) e [Configurazione MCP gestita](/docs/it/managed-mcp) per i dettagli.439L'installazione di Claude Code non crea alcun file di impostazioni. Se la vostra macchina o il vostro progetto ne ha già uno, è venuto da una di queste fonti:
124 440
125 Questo [repository](https://github.com/anthropics/claude-code/tree/main/examples/mdm) include modelli di distribuzione iniziali per Jamf, Iru (Kandji), Intune e Criteri di gruppo. Usa questi come punti di partenza e adattali alle tue esigenze.441* **Gestito**: la vostra organizzazione lo distribuisce. Non lo create o modificate voi.
442* **Progetto condiviso**: un progetto che già usa Claude Code potrebbe averne uno committato. Se no, createlo a `.claude/settings.json` nella cartella del progetto.
443* **Utente** e **Progetto locale**: createli voi stessi, o lasciate che Claude Code li crei. Scrive `~/.claude/settings.json` la prima volta che cambiate un'opzione nel menu `/config` che memorizza nelle impostazioni utente, come il tema, e `.claude/settings.local.json` la prima volta che date un'approvazione permanente su un prompt di permesso, come "Sì, e non chiedere di nuovo" per un comando Bash. Poche opzioni `/config`, incluso **Mostra suggerimenti**, salvano in `.claude/settings.local.json` invece del file utente.
126 444
127 <Note>445<Info>
128 Le distribuzioni gestite possono anche limitare **le aggiunte del marketplace dei plugin** utilizzando `strictKnownMarketplaces`. Per ulteriori informazioni, vedi [Restrizioni del marketplace gestito](/docs/it/plugin-marketplaces#managed-marketplace-restrictions).446 Su Windows, `~/.claude` significa `%USERPROFILE%\.claude`. Per mantenere i file della directory home da qualche altra parte, impostate [`CLAUDE_CONFIG_DIR`](/docs/it/env-vars); Claude Code memorizza quindi le vostre impostazioni, la cronologia della sessione e i plugin lì invece.
129 </Note>447</Info>
130* **Altra configurazione** è archiviata in `~/.claude.json`. Questo file contiene la tua sessione OAuth, configurazioni dei [MCP server](/docs/it/mcp) per gli ambiti utente e locale, stato per-progetto (strumenti consentiti, impostazioni di fiducia), e varie cache. I MCP server con ambito di progetto sono archiviati separatamente in `.mcp.json`.
131 448
132<Note>449Claude Code mantiene anche un quinto file, [`~/.claude.json`](/docs/it/claude-directory#ce-claude-json), che scrive per se stesso; non dovete modificarlo. Contiene la vostra sessione di accesso, configurazioni [MCP server](/docs/it/mcp), stato per-progetto come decisioni di fiducia, e le [chiavi di configurazione globale](/docs/it/settings-reference#global-config-settings) che `/config` scrive per voi.
133 Claude Code crea automaticamente backup con timestamp dei file di configurazione e conserva i cinque backup più recenti per prevenire la perdita di dati.
134</Note>
135 450
136```JSON Esempio settings.json theme={null}451<h3 id="share-settings-with-your-team">
137{452 Condividete le impostazioni con il vostro 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
164La riga `$schema` nell'esempio sopra punta allo [schema JSON ufficiale](https://json.schemastore.org/claude-code-settings.json) per le impostazioni di Claude Code. Aggiungerlo al tuo `settings.json` abilita l'autocompletamento e la convalida inline in VS Code, Cursor e qualsiasi altro editor che supporta la convalida dello schema JSON.455Committate `.claude/settings.json` in modo che tutti coloro che clonano il repository ottengano gli stessi permessi, hooks, telemetria e plugin. Ogni compagno di squadra può comunque ignorarlo per se stesso nel proprio `.claude/settings.local.json`, quindi le eccezioni personali non hanno bisogno di un commit. Per un file team completo, vedere [impostazioni condivise di un team](/docs/it/settings-example#a-teams-shared-settings).
165 456
166Lo schema pubblicato viene aggiornato periodicamente e potrebbe non includere le impostazioni aggiunte nei rilasci CLI più recenti, quindi un avviso di convalida su un campo documentato di recente non significa necessariamente che la tua configurazione non sia valida.457Parte di quello che committate attende fino a quando ogni compagno di squadra [non fidia della cartella](/docs/it/permissions#project-allow-rules-and-workspace-trust), e poche chiavi non hanno mai effetto da un file di repository; [Risolvi i problemi di un'impostazione che non si applica](#common-cases) copre entrambi.
167 458
168<h3 id="when-edits-take-effect">459<span id="local-settings-file" />
169 Quando gli edits hanno effetto
170</h3>
171 460
172Claude Code osserva i tuoi file di impostazioni e li ricarica quando cambiano, quindi gli edits alla maggior parte delle chiavi si applicano alla sessione in esecuzione senza un riavvio. Questo include `permissions`, `hooks`, e helper di credenziali come `apiKeyHelper`. Il ricaricamento copre le impostazioni utente, progetto, locale e gestite, e l'[hook `ConfigChange`](/docs/it/hooks#configchange) si attiva per ogni modifica rilevata.461<span id="where-claude-code-saves-the-project-local-file" />
173 462
174Alcune chiavi vengono lette una sola volta all'avvio della sessione e si applicano al riavvio successivo:463<span id="the-project-local-file" />
175 464
176* `model`: usa [`/model`](/docs/it/model-config#setting-your-model) per cambiare durante la sessione465<span id="keep-personal-settings-out-of-the-repository" />
177* [`outputStyle`](/docs/it/output-styles): parte del prompt di sistema, che viene ricostruito su `/clear` o riavvio
178 466
179<h3 id="invalid-entries-in-managed-settings">467<h3 id="keep-personal-settings-out-of-a-repository">
180 Voci non valide nelle impostazioni gestite468 Mantenete le impostazioni personali fuori da un repository
181</h3>469</h3>
182 470
183Le impostazioni gestite analizzano in modo tollerante. Quando una configurazione gestita contiene una voce che non supera la convalida dello schema, Claude Code rimuove quella voce, registra un avviso e applica ogni politica valida rimanente. Un singolo errore di battitura non può disabilitare il resto della politica della tua organizzazione. Esegui [`/doctor`](/docs/it/debug-your-config#check-resolved-settings) per elencare le voci rimosse con il loro file di origine e campo.471Per modificare un'impostazione per voi stessi in un progetto senza modificarla per i vostri compagni di squadra, salvatela in `.claude/settings.local.json` dentro il progetto. Claude Code applica quel file sopra il `.claude/settings.json` committato, quindi se il file del vostro team imposta `"model": "claude-sonnet-5"` e volete Opus, mettete `"model": "claude-opus-4-8"` nel vostro file locale e solo le vostre sessioni cambiano.
184 472
185Questo comportamento è coerente in tutti e tre i meccanismi di distribuzione: [impostazioni gestite dal server](/docs/it/server-managed-settings), politiche plist e registro distribuite tramite MDM, e file `managed-settings.json`. Richiede Claude Code v2.1.169 o successivo.473Tre cose da sapere sul file locale:
186 474
187I campi di applicazione della sicurezza vengono gestiti per campo invece di essere rimossi all'ingrosso quando sono presenti ma non validi:475* **Claude Code lo scrive anche.** Quando Claude chiede il permesso di eseguire un comando Bash e scegliete "Sì, e non chiedere di nuovo", Claude Code salva quell'[approvazione di permesso](/docs/it/permissions#permission-system) qui come una regola `allow`.
476* **Non dovete gitignorarlo voi stessi, a meno che non l'abbiate creato manualmente.** La prima volta che Claude Code scrive il file in un repository git che non lo ignora già, aggiunge `**/.claude/settings.local.json` al vostro file di esclusioni git globale, quindi il file rimane fuori dai vostri commit in ogni repository. Quel file è `core.excludesFile` quando la vostra configurazione git globale lo imposta a un percorso assoluto o con prefisso `~`; altrimenti è `$XDG_CONFIG_HOME/git/ignore`, o `~/.config/git/ignore` quando `XDG_CONFIG_HOME` non è impostato. Se avete creato il file manualmente e Claude Code non ha ancora scritto in esso, aggiungetelo a `.gitignore` voi stessi.
477* **Le sue regole allow non attendono la fiducia mentre il file rimane non tracciato.** Poiché il file è vostro e non del repository, Claude Code applica le sue regole `allow` senza il passaggio [workspace trust](/docs/it/permissions#project-allow-rules-and-workspace-trust) che richiede per il file committato. Se il file è tracciato da git, il passaggio di fiducia si applica anche a esso; vedere [Quando il vostro file di impostazioni locale ha bisogno di fiducia](/docs/it/permissions#when-your-local-settings-file-needs-trust).
188 478
189| Campo | Comportamento quando presente ma non valido |479<span id="where-claude-code-looks-for-each-file" />
190| :--------------------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
191| `allowedMcpServers` | Applicato come una lista di autorizzazione vuota, quindi nessun MCP server viene ammesso fino a quando il valore non viene corretto. Una singola voce non valida viene rimossa e il sottoinsieme valido viene applicato. |
192| `allowManagedMcpServersOnly` | Trattato come `true`. |
193| `availableModels` | Applicato come una lista di autorizzazione vuota, quindi solo il modello Predefinito è disponibile fino a quando il valore non viene corretto. Una singola voce non stringa viene rimossa e il sottoinsieme valido viene applicato. Si applica in v2.1.175 e successivo. |
194| `enforceAvailableModels` | Trattato come `true`. Si applica in v2.1.175 e successivo. |
195| `forceLoginOrgUUID` | Nessuna organizzazione è autorizzata ad accedere fino a quando il valore non viene corretto. |
196| `deniedMcpServers` | Una singola voce non valida viene rimossa e il sottoinsieme valido viene applicato. Un valore completamente non valido viene eliminato con un avviso, poiché negare ogni server bloccherebbe i server che la politica non ha mai nominato. |
197| `sandbox.credentials` | Una singola voce non valida in `files` o `envVars` viene rimossa con un avviso e il sottoinsieme valido viene applicato. Un valore `credentials` completamente non valido viene eliminato con un avviso mentre il resto di `sandbox` continua ad applicarsi. Si applica in v2.1.191 e successivo. |
198 480
199`requiredMinimumVersion` e `requiredMaximumVersion` falliscono in modo aperto per progettazione: un valore non valido viene rimosso piuttosto che applicato, quindi una politica errata non può impedire l'avvio di Claude Code.481<span id="how-claude-code-keeps-the-local-file-out-of-git" />
200 482
201Gli errori di convalida vengono visualizzati in tre posizioni:483<span id="local-allow-rules-dont-wait-for-workspace-trust" />
202 484
203* Le sessioni interattive mostrano una finestra di dialogo all'avvio che elenca le voci non valide.485<h4 id="where-claude-code-keeps-the-local-file-in-a-git-repository">
204* Le esecuzioni headless con `-p` stampano un riepilogo su stderr.486 Dove Claude Code mantiene il file locale in un repository git
205* [`claude doctor`](/docs/it/debug-your-config) elenca ogni voce non valida con la sua fonte e il campo.487</h4>
206
207Convalida i cambiamenti di politica eseguendo `claude doctor` su una macchina di test prima di distribuirli su tutta la flotta.
208 488
209Questa tolleranza si applica solo alle impostazioni gestite. I file di impostazioni utente, progetto e locale rimangono rigorosi: un file che non supera la convalida viene rifiutato nel complesso e segnalato.489Quando Claude chiede il permesso di eseguire un comando Bash e scegliete "Sì, e non chiedere di nuovo", Claude Code salva quell'approvazione come una regola `allow` in `.claude/settings.local.json`. Se avviate Claude Code in una sottodirectory di un repository git, legge e scrive quel file alla radice del repository e applica l'approvazione in tutto il repository. In un [worktree](/docs/it/worktrees), usa il file alla radice del checkout principale.
210 490
211<h3 id="available-settings">491Due regole qualificano la posizione della radice:
212 Impostazioni disponibili
213</h3>
214 492
215`settings.json` supporta un numero di opzioni:493* **Quando il file rimane con `.claude/settings.json` invece**: fuori da un repository git, quando la radice del repository è la vostra directory home, su Windows, o quando la radice del repository o la sua voce `.git` o `.claude` non è di proprietà del vostro utente.
216 494* **I percorsi nel file non si ancorano alla radice del repository**: una regola di permesso che inizia con `/` o un percorso sandbox relativo [si ancora alla directory di lavoro primaria della sessione](/docs/it/permissions#read-and-edit) invece.
217| Chiave | Descrizione | Esempio |
218| :--------------------------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :------------------------------------------------------------------------------------------------------------------------------ |
219| `advisorModel` | Modello per lo [strumento advisor](/docs/it/advisor) lato server. Accetta un alias di modello come `"opus"`, `"sonnet"`, o `"fable"` (v2.1.170+), o un ID modello completo. Scritto automaticamente quando esegui `/advisor`. Non impostato per disabilitare l'advisor | `"opus"` |
220| `agent` | Esegui il thread principale come un subagent denominato e imposta l'agente predefinito per le sessioni inviate da `claude agents`. Applica il prompt di sistema, le restrizioni degli strumenti e il modello di quel subagent. Vedi [Invoca i subagent esplicitamente](/docs/it/sub-agents#invoke-subagents-explicitly) | `"code-reviewer"` |
221| `agentPushNotifEnabled` | **Predefinito**: `false`. Quando il [Controllo remoto](/docs/it/remote-control) è connesso, consenti a Claude di inviare notifiche push proattive al tuo telefono, ad esempio quando un'attività lunga finisce. Appare in `/config` come **Push when Claude decides**. Vedi [Notifiche push mobile](/docs/it/remote-control#mobile-push-notifications). Richiede Claude Code v2.1.119 o successivo | `true` |
222| `allowAllClaudeAiMcps` | (Solo impostazioni gestite) Carica i connettori claude.ai insieme a un `managed-mcp.json` distribuito, che altrimenti assume il controllo esclusivo e li sopprime. Vedi [Configurazione MCP gestita](/docs/it/managed-mcp) | `true` |
223| `allowedChannelPlugins` | (Solo impostazioni gestite) Elenco di autorizzazione dei plugin di canale che possono inviare messaggi. Sostituisce l'elenco di autorizzazione predefinito di Anthropic quando impostato. Non definito = ricaduta al predefinito, array vuoto = blocca tutti i plugin di canale. Richiede `channelsEnabled: true`. Vedi [Limita quali plugin di canale possono essere eseguiti](/docs/it/channels#restrict-which-channel-plugins-can-run) | `[{ "marketplace": "claude-plugins-official", "plugin": "telegram" }]` |
224| `allowedHttpHookUrls` | Elenco di autorizzazione dei modelli di URL che gli hook HTTP possono indirizzare. Supporta `*` come carattere jolly. Quando impostato, gli hook con URL non corrispondenti vengono bloccati. Non definito = nessuna restrizione, array vuoto = blocca tutti gli hook HTTP. Gli array si uniscono tra le fonti di impostazioni. Vedi [Configurazione hook](#hook-configuration) | `["https://hooks.example.com/*"]` |
225| `allowedMcpServers` | Quando impostato in managed-settings.json, elenco di autorizzazione dei MCP server che gli utenti possono configurare. Non definito = nessuna restrizione, array vuoto = blocco. Si applica a tutti gli ambiti. L'elenco di negazione ha la precedenza. Vedi [Configurazione MCP gestita](/docs/it/managed-mcp) | `[{ "serverName": "github" }]` |
226| `allowManagedHooksOnly` | (Solo impostazioni gestite) Solo gli hook gestiti, gli hook SDK e gli hook dai plugin forzatamente abilitati nelle impostazioni gestite `enabledPlugins` vengono caricati. Gli hook utente, di progetto e di tutti gli altri plugin vengono bloccati. Vedi [Configurazione hook](#hook-configuration) | `true` |
227| `allowManagedMcpServersOnly` | (Solo impostazioni gestite) Solo `allowedMcpServers` dalle impostazioni gestite sono rispettati. `deniedMcpServers` si unisce comunque da tutte le fonti. Gli utenti possono ancora aggiungere MCP server, ma si applica solo l'elenco di autorizzazione definito dall'amministratore. Vedi [Configurazione MCP gestita](/docs/it/managed-mcp) | `true` |
228| `allowManagedPermissionRulesOnly` | (Solo impostazioni gestite) Previeni che le impostazioni utente e di progetto definiscano regole di permesso `allow`, `ask` o `deny`. Si applicano solo le regole nelle impostazioni gestite. Vedi [Impostazioni solo gestite](/docs/it/permissions#managed-only-settings) | `true` |
229| `alwaysThinkingEnabled` | Abilita il [pensiero esteso](/docs/it/model-config#extended-thinking) per impostazione predefinita per tutte le sessioni. Tipicamente configurato tramite il comando `/config` piuttosto che modificato direttamente. Per forzare il pensiero disattivato indipendentemente da questa impostazione, imposta [`MAX_THINKING_TOKENS=0`](/docs/it/env-vars) in `env`, che disabilita il pensiero sull'API Anthropic tranne su Fable 5, che non può avere il pensiero disattivato. Su [provider di terze parti](/docs/it/third-party-integrations) questo omette il parametro `thinking` invece, e i modelli di ragionamento adattivo potrebbero comunque pensare | `true` |
230| `apiKeyHelper` | Script personalizzato, da eseguire tramite la shell di sistema (`/bin/sh` su macOS e Linux, `cmd` su Windows), per generare un valore di autenticazione. Questo valore verrà inviato come intestazioni `X-Api-Key` e `Authorization: Bearer` per le richieste di modello. Imposta l'intervallo di aggiornamento con [`CLAUDE_CODE_API_KEY_HELPER_TTL_MS`](/docs/it/env-vars) | `/bin/generate_temp_api_key.sh` |
231| `askUserQuestionTimeout` | **Predefinito**: `"never"`. Tempo di inattività prima che una finestra di dialogo [`AskUserQuestion`](/docs/it/tools-reference) senza risposta continui automaticamente con le opzioni che hai già selezionato. Accetta `"60s"`, `"5m"`, `"10m"`, o `"never"`. Con il predefinito, le domande attendono fino a quando non rispondi. Appare in `/config` come **Question auto-continue timeout**, che scrive questa chiave nelle impostazioni utente. Non letto dalle impostazioni di progetto o locale. Richiede Claude Code v2.1.200 o successivo | `"5m"` |
232| `attribution` | Personalizza l'attribuzione per i commit git e le pull request. Vedi [Impostazioni di attribuzione](#attribution-settings) | `{"commit": "🤖 Generated with Claude Code", "pr": ""}` |
233| `autoCompactEnabled` | **Predefinito**: `true`. Compatta automaticamente la conversazione quando il contesto si avvicina al limite. Appare in `/config` come **Auto-compact**. Per disabilitare tramite variabile di ambiente, imposta [`DISABLE_AUTO_COMPACT`](/docs/it/env-vars) in `env` | `false` |
234| `autoMemoryDirectory` | Directory personalizzata per l'archiviazione della [memoria automatica](/docs/it/memory#storage-location). Accetta un percorso assoluto o un percorso con prefisso `~/`. Dalle impostazioni di progetto o locale, questo viene onorato solo dopo che accetti la finestra di dialogo di fiducia dell'area di lavoro, poiché un repository clonato può fornire questo file | `"~/my-memory-dir"` |
235| `autoMemoryEnabled` | **Predefinito**: `true`. Abilita la [memoria automatica](/docs/it/memory#enable-or-disable-auto-memory). Quando `false`, Claude non legge da o scrive nella directory di memoria automatica. Puoi anche attivare/disattivare questo con `/memory` durante una sessione. Per disabilitare tramite variabile di ambiente, imposta [`CLAUDE_CODE_DISABLE_AUTO_MEMORY`](/docs/it/env-vars) in `env` | `false` |
236| `autoMode` | Personalizza cosa il classificatore della [modalità auto](/docs/it/permission-modes#eliminate-prompts-with-auto-mode) blocca e consente. Contiene array `environment`, `allow`, `soft_deny` e `hard_deny` di regole in prosa. Includi la stringa letterale `"$defaults"` in un array per ereditare le regole incorporate in quella posizione. Vedi [Configura la modalità auto](/docs/it/auto-mode-config). Letto dalle impostazioni utente, dal flag `--settings`, e dalle impostazioni gestite solo. Ignorato nelle impostazioni di progetto `.claude/settings.json` e locale `.claude/settings.local.json`. Prima di v2.1.207, `.claude/settings.local.json` era anche letto | `{"soft_deny": ["$defaults", "Never run terraform apply"]}` |
237| `autoMode.classifyAllShell` | **Predefinito**: `false`. Quando `true`, sospende ogni regola allow di Bash e PowerShell mentre la modalità auto è attiva in modo che tutti i comandi shell vengono instradati attraverso il classificatore, non solo le regole che corrispondono ai modelli di esecuzione di codice arbitrario. Vedi [Instrada tutti i comandi shell attraverso il classificatore](/docs/it/auto-mode-config#route-all-shell-commands-through-the-classifier). Richiede Claude Code v2.1.193 o successivo | `true` |
238| `autoScrollEnabled` | **Predefinito**: `true`. Nel [rendering fullscreen](/docs/it/fullscreen), segui il nuovo output fino al fondo della conversazione. Appare in `/config` come **Auto-scroll**. I prompt di permesso scorrono comunque in vista quando questo è disattivato | `false` |
239| `autoUpdatesChannel` | **Predefinito**: `"latest"`. Canale di rilascio da seguire per gli aggiornamenti. Usa `"stable"` per una versione che è tipicamente circa una settimana vecchia e salta le versioni con regressioni importanti, o `"latest"` per il rilascio più recente. Per disabilitare completamente gli auto-aggiornamenti, imposta [`DISABLE_AUTOUPDATER`](/docs/it/setup#disable-auto-updates) in `env` | `"stable"` |
240| `availableModels` | Limita quali modelli gli utenti possono selezionare per la sessione principale, i [subagent](/docs/it/sub-agents), i [skills](/docs/it/skills) e l'[advisor](/docs/it/advisor). Non influisce sull'opzione Predefinito a meno che `enforceAvailableModels` non sia anche impostato. Vedi [Limita la selezione del modello](/docs/it/model-config#restrict-model-selection) | `["sonnet", "haiku"]` |
241| `awaySummaryEnabled` | Mostra un riepilogo di una riga della sessione quando torni al terminale dopo alcuni minuti di assenza. Imposta a `false` o disattiva Riepilogo sessione in `/config` per disabilitare. Uguale a [`CLAUDE_CODE_ENABLE_AWAY_SUMMARY`](/docs/it/env-vars) | `true` |
242| `awsAuthRefresh` | Script personalizzato che modifica la directory `.aws` (vedi [configurazione avanzata delle credenziali](/docs/it/amazon-bedrock#advanced-credential-configuration)) | `aws sso login --profile myprofile` |
243| `awsCredentialExport` | Script personalizzato che restituisce JSON con le credenziali AWS (vedi [configurazione avanzata delle credenziali](/docs/it/amazon-bedrock#advanced-credential-configuration)) | `/bin/generate_aws_grant.sh` |
244| `axScreenReader` | Renderizza output compatibile con lo screen reader: testo piatto senza bordi decorativi o animazioni. La modalità screen reader utilizza il renderer classico, quindi l'impostazione `tui` non ha effetto mentre è attiva; le [sessioni in background](/docs/it/agent-view) allegate vengono comunque renderizzate a schermo intero. La variabile di ambiente [`CLAUDE_AX_SCREEN_READER`](/docs/it/env-vars) e il flag [`--ax-screen-reader`](/docs/it/cli-reference#cli-flags) hanno la precedenza. Richiede Claude Code v2.1.181 o successivo | `true` |
245| `blockedMarketplaces` | (Solo impostazioni gestite) Elenco di negazione delle fonti del marketplace. Applicato all'aggiunta del marketplace e all'installazione, aggiornamento, aggiornamento e auto-aggiornamento del plugin, quindi un marketplace aggiunto prima che la politica fosse impostata non può essere utilizzato per recuperare i plugin. Le fonti bloccate vengono controllate prima del download, quindi non toccano mai il filesystem. Vedi [Restrizioni del marketplace gestito](/docs/it/plugin-marketplaces#managed-marketplace-restrictions) | `[{ "source": "github", "repo": "untrusted/plugins" }]` |
246| `browserExternalPageTools` | (Solo impostazioni gestite) Imposta a `"disabled"` per prevenire che Claude utilizzi strumenti per leggere o agire su pagine esterne nel riquadro [Browser](/docs/it/desktop#browse-external-sites) dell'app desktop. Gli utenti possono comunque navigare verso siti esterni da soli, e le anteprime del server di sviluppo locale non sono interessate | `"disabled"` |
247| `channelsEnabled` | (Solo impostazioni gestite) Consenti [channels](/docs/it/channels) per l'organizzazione. Nei piani Team e Enterprise di claude.ai, i canali vengono bloccati quando questo non è impostato o è `false`. Per gli account [Anthropic Console](/docs/it/authentication#claude-console-authentication) che utilizzano l'autenticazione con chiave API, i canali sono consentiti per impostazione predefinita a meno che la tua organizzazione non distribuisca impostazioni gestite, nel qual caso questa chiave deve essere impostata a `true` | `true` |
248| `claudeMd` | (Solo impostazioni gestite) Istruzioni in stile CLAUDE.md iniettate come memoria gestita dall'organizzazione. Onorato solo quando impostato nelle impostazioni gestite o di politica e ignorato nelle impostazioni utente, progetto e locale. Vedi [CLAUDE.md a livello organizzativo](/docs/it/memory#deploy-organization-wide-claude-md) | `"Always run make lint before committing."` |
249| `claudeMdExcludes` | Modelli Glob o percorsi assoluti dei file `CLAUDE.md` da saltare durante il caricamento della [memoria](/docs/it/memory). I modelli corrispondono ai percorsi assoluti dei file. Si applica solo alla memoria utente, progetto e locale; i file di politica gestiti non possono essere esclusi | `["**/vendor/**/CLAUDE.md"]` |
250| `cleanupPeriodDays` | **Predefinito**: `30` giorni, minimo `1`. Claude Code elimina i [file di sessione e altri dati dell'applicazione](/docs/it/claude-directory#cleaned-up-automatically) più vecchi di questo periodo all'avvio. L'impostazione a `0` viene rifiutata con un errore di convalida. Lo stesso limite di età si applica alla rimozione automatica dei [worktrees orfani](/docs/it/worktrees#clean-up-worktrees) all'avvio. Se Claude Code non riesce a leggere o analizzare un file di impostazioni, mette in pausa lo sweep di pulizia della conservazione e mostra un avviso in `/status` fino a quando non correggi il file, a meno che le [impostazioni gestite](/docs/it/server-managed-settings) forniscano `cleanupPeriodDays`, nel qual caso lo sweep viene eseguito al valore gestito. Prima di v2.1.203, la pulizia veniva eseguita al predefinito di 30 giorni in quello stato e potrebbe eliminare trascritti che un `cleanupPeriodDays` più lungo era destinato a mantenere; i file più recenti di 30 giorni non sono mai stati rimossi. Per disabilitare completamente le scritture di trascritti, imposta la variabile di ambiente [`CLAUDE_CODE_SKIP_PROMPT_HISTORY`](/docs/it/env-vars). In modalità non interattiva, passa `--no-session-persistence` insieme a `-p` o imposta `persistSession: false` nell'Agent SDK. | `20` |
251| `companyAnnouncements` | Annuncio da visualizzare agli utenti all'avvio. Se vengono forniti più annunci, verranno alternati casualmente. | `["Welcome to Acme Corp! Review our code guidelines at docs.acme.com"]` |
252| `defaultShell` | **Predefinito**: `"bash"`, o `"powershell"` su Windows quando Bash non è disponibile. Shell predefinita per i comandi `!` della casella di input. Accetta `"bash"` o `"powershell"`. L'impostazione a `"powershell"` instrada i comandi `!` interattivi tramite PowerShell su Windows. Richiede `CLAUDE_CODE_USE_POWERSHELL_TOOL=1`. Vedi [Strumento PowerShell](/docs/it/tools-reference#powershell-tool) | `"powershell"` |
253| `deniedMcpServers` | Quando impostato in managed-settings.json, elenco di negazione dei MCP server che sono esplicitamente bloccati. Si applica a tutti gli ambiti inclusi i server gestiti. L'elenco di negazione ha la precedenza sull'elenco di autorizzazione. Vedi [Configurazione MCP gestita](/docs/it/managed-mcp) | `[{ "serverName": "filesystem" }]` |
254| `disableAgentView` | Imposta a `true` per disattivare gli [agenti in background e la visualizzazione degli agenti](/docs/it/agent-view): `claude agents`, `--bg`, `/background`, e il supervisore su richiesta. Tipicamente impostato nelle [impostazioni gestite](/docs/it/permissions#managed-settings). Equivalente all'impostazione di `CLAUDE_CODE_DISABLE_AGENT_VIEW` a `1` | `true` |
255| `disableAllHooks` | Disabilita tutti gli [hooks](/docs/it/hooks) e qualsiasi [status line](/docs/it/statusline) personalizzato | `true` |
256| `disableArtifact` | Imposta a `true` per disabilitare lo strumento [Artifact](/docs/it/artifacts), che pubblica l'output della sessione come pagina web privata su claude.ai. Equivalente all'impostazione di `CLAUDE_CODE_DISABLE_ARTIFACT` a `1` | `true` |
257| `disableAutoMode` | Imposta a `"disable"` per prevenire l'attivazione della [modalità auto](/docs/it/permission-modes#eliminate-prompts-with-auto-mode). Rimuove `auto` dal ciclo `Shift+Tab` e rifiuta `--permission-mode auto` all'avvio. Molto utile nelle [impostazioni gestite](/docs/it/permissions#managed-settings) dove gli utenti non possono ignorarla | `"disable"` |
258| `disableBrowserExternalNavigation` | (Solo impostazioni gestite) Imposta a `true` per disattivare la navigazione esterna nel riquadro [Browser](/docs/it/desktop#browse-external-sites) dell'app desktop. Né gli utenti né Claude possono navigare verso siti esterni, e le anteprime del server localhost rimangono inalterate. Il valore deve essere il booleano JSON `true`; la stringa `"true"` viene ignorata | `true` |
259| `disableBundledSkills` | Imposta a `true` per disabilitare gli [skills](/docs/it/skills) e i flussi di lavoro che vengono forniti con Claude Code: gli skills bundled e i flussi di lavoro vengono rimossi completamente, mentre i comandi slash incorporati come `/init` rimangono digitabili ma sono nascosti dal modello. `/doctor` rimane digitabile come i comandi incorporati; nascondilo con [`DISABLE_DOCTOR_COMMAND`](/docs/it/env-vars) invece. Gli skills dai plugin, `.claude/skills/`, e `.claude/commands/` non sono interessati. Equivalente all'impostazione di `CLAUDE_CODE_DISABLE_BUNDLED_SKILLS` a `1` | `true` |
260| `disableClaudeAiConnectors` | Disabilita i [connettori MCP di claude.ai](/docs/it/mcp#use-mcp-servers-from-claude-ai) in modo che non vengano recuperati automaticamente o connessi. Imposta in qualsiasi ambito di impostazioni. `true` in qualsiasi fonte ha la precedenza, quindi un `.claude/settings.json` di progetto controllato può escludere un repository dai connettori cloud, ma un `false` a livello di progetto non può ignorare un `true` a livello utente o di politica. I server passati esplicitamente tramite `--mcp-config` non sono interessati. Per negare i singoli connettori invece di tutti loro, usa [`deniedMcpServers`](/docs/it/managed-mcp). Richiede Claude Code v2.1.182 o successivo | `true` |
261| `disableDeepLinkRegistration` | Imposta a `"disable"` per prevenire che Claude Code registri il gestore del protocollo `claude-cli://` con il sistema operativo all'avvio. I [deep link](/docs/it/deep-links) consentono agli strumenti esterni di aprire una sessione di Claude Code con un prompt pre-compilato. Utile negli ambienti in cui la registrazione del gestore del protocollo è limitata o gestita separatamente | `"disable"` |
262| `disabledMcpjsonServers` | Elenco di MCP server specifici dai file `.mcp.json` da rifiutare | `["filesystem"]` |
263| `disableRemoteControl` | Disabilita il [Controllo remoto](/docs/it/remote-control): blocca `claude remote-control`, il flag `--remote-control`, l'avvio automatico e l'interruttore in-sessione. Tipicamente posizionato nelle [impostazioni gestite](/docs/it/permissions#managed-settings) per l'applicazione MDM per dispositivo, ma funziona da qualsiasi ambito. Richiede Claude Code v2.1.128 o successivo | `true` |
264| `disableSideloadFlags` | (Solo impostazioni gestite) Rifiuta i flag CLI `--plugin-dir`, `--plugin-url`, `--agents`, e `--mcp-config` all'avvio, che gli utenti potrebbero altrimenti passare per ignorare [`strictKnownMarketplaces`](#strictknownmarketplaces) per una singola esecuzione. Rifiuta anche questi flag da qualsiasi superficie che genera la CLI con loro internamente, attualmente le sessioni locali di [Cowork](/docs/it/desktop) nell'app desktop. Un `--mcp-config` i cui server sono tutti voci `type: "sdk"` in-process è comunque accettato, quindi l'Agent SDK e l'estensione VS Code continuano a funzionare. Non blocca `claude mcp add`, `.mcp.json`, o SDK `setMcpServers()`; abbina con [`allowedMcpServers`](/docs/it/managed-mcp) per il controllo MCP per server. Richiede Claude Code v2.1.193 o successivo | `true` |
265| `disableSkillShellExecution` | Disabilita l'esecuzione inline della shell per i blocchi `` !`...` `` e ` ```! ` negli [skills](/it/skills) e nei comandi personalizzati da fonti utente, progetto, plugin o directory aggiuntive. I comandi vengono sostituiti con `[shell command execution disabled by policy]` invece di essere eseguiti. Gli skills bundled e gestiti non sono interessati. Molto utile nelle [impostazioni gestite](/it/permissions#managed-settings) dove gli utenti non possono ignorarla | `true` |
266| `disableWorkflows` | **Predefinito**: `false`. Disabilita i [flussi di lavoro dinamici](/docs/it/workflows#turn-workflows-off) e i comandi di flusso di lavoro bundled. Equivalente all'impostazione di `CLAUDE_CODE_DISABLE_WORKFLOWS` a `1` | `true` |
267| `editorMode` | **Predefinito**: `"normal"`. Modalità di scorciatoie da tastiera per il prompt di input: `"normal"` o `"vim"`. Appare in `/config` come **Editor mode** | `"vim"` |
268| `effortLevel` | Persisti il [livello di sforzo](/docs/it/model-config#adjust-effort-level) tra le sessioni. Accetta `"low"`, `"medium"`, `"high"`, o `"xhigh"`. Scritto automaticamente quando esegui `/effort` con uno di questi valori. `--effort` e [`CLAUDE_CODE_EFFORT_LEVEL`](/docs/it/env-vars) ignorano questo per una sessione. Vedi [Regola il livello di sforzo](/docs/it/model-config#adjust-effort-level) per i modelli supportati | `"xhigh"` |
269| `enableAllProjectMcpServers` | Approva automaticamente tutti i MCP server definiti nei file `.mcp.json` del progetto. A partire da v2.1.196, `claude mcp list` e `claude mcp get` onorano questa chiave in una cartella non attendibile solo dai [file di impostazioni che non vengono controllati nel repository](/docs/it/mcp#managing-your-servers) | `true` |
270| `enableArtifact` | Abilita o disabilita lo strumento [Artifact](/docs/it/artifacts) per questo utente. Quando non impostato, il predefinito segue la [disponibilità](/docs/it/artifacts#availability) della funzione per il tuo account. La riga **Artifacts** in `/config` scrive questa chiave. Un `disableArtifact` gestito e l'[impostazione di amministrazione](/docs/it/artifacts#manage-artifacts-for-your-organization) della tua organizzazione hanno la precedenza, e la chiave viene ignorata nelle impostazioni di progetto e locale (`.claude/settings.json`, `.claude/settings.local.json`), che un repository potrebbe altrimenti controllare. Richiede Claude Code v2.1.196 o successivo | `true` |
271| `enabledMcpjsonServers` | Elenco di MCP server specifici dai file `.mcp.json` da approvare. A partire da v2.1.196, `claude mcp list` e `claude mcp get` onorano questa chiave in una cartella non attendibile solo dai [file di impostazioni che non vengono controllati nel repository](/docs/it/mcp#managing-your-servers) | `["memory", "github"]` |
272| `enforceAvailableModels` | Estendi l'elenco di autorizzazione `availableModels` al modello Predefinito. Quando `true` nelle impostazioni gestite e `availableModels` è un array non vuoto, l'opzione Predefinito ricade alla prima voce nella lista di autorizzazione che è disponibile, ma solo quando il modello predefinito per il quale il modello Predefinito si risolverebbe (il [predefinito organizzativo](/docs/it/model-config#organization-default-model) quando uno si applica, altrimenti il predefinito del tipo di account) non è nell'elenco di autorizzazione; un predefinito nella lista di autorizzazione viene mantenuto così com'è. Non ha effetto quando `availableModels` non è impostato o è vuoto. Vedi [Applica l'elenco di autorizzazione al modello Predefinito](/docs/it/model-config#enforce-the-allowlist-for-the-default-model). Richiede Claude Code v2.1.175 o successivo | `true` |
273| `env` | Variabili di ambiente applicate a ogni sessione e ai sottoprocessi che Claude Code genera da essa. Imposta una variabile a `""` per ignorare un'esportazione della shell con una stringa vuota, che Claude Code tratta come non impostata per la selezione del provider. I sottoprocessi ereditano comunque il valore vuoto. `NO_COLOR` e `FORCE_COLOR` impostati qui raggiungono solo i sottoprocessi; per cambiare i colori dell'interfaccia di Claude Code stesso, impostali nella tua shell prima di lanciare `claude`. A partire da v2.1.195, le variabili di identità che gli ambienti di hosting di Claude Code impostano, ad esempio `CLAUDE_CODE_REMOTE` e `CLAUDE_CODE_ACCOUNT_UUID`, vengono ignorate quando impostate qui | `{"FOO": "bar"}` |
274| `fallbackModel` | Modello/i di fallback da provare in ordine quando il modello primario è sovraccarico o non disponibile. Claude Code passa al modello disponibile successivo nella catena per il resto del turno e mostra un avviso. `"default"` si espande al modello predefinito. Le catene sono limitate a tre modelli; le voci extra vengono ignorate. A differenza della maggior parte delle impostazioni di array, questa chiave non si unisce tra i file di impostazioni: il file con la precedenza più alta che la definisce fornisce l'intera catena. Il flag [`--fallback-model`](/docs/it/cli-reference#cli-flags) ignora questo per una sessione. Vedi [Catene di modelli di fallback](/docs/it/model-config#fallback-model-chains) | `["claude-sonnet-5", "claude-haiku-4-5"]` |
275| `fastMode` | Attiva la [modalità veloce](/docs/it/fast-mode) per le sessioni dove è disponibile. Attivare/disattivare con `/fast` scrive `true` qui nelle impostazioni utente e rimuove la chiave quando disattivi la modalità veloce | `true` |
276| `fastModePerSessionOptIn` | Quando `true`, la modalità veloce non persiste tra le sessioni. Ogni sessione inizia con la modalità veloce disattivata, richiedendo agli utenti di abilitarla con `/fast`. La preferenza della modalità veloce dell'utente viene comunque salvata. Vedi [Richiedi opt-in per sessione](/docs/it/fast-mode#require-per-session-opt-in) | `true` |
277| `feedbackSurveyRate` | Probabilità (0–1) che il [sondaggio sulla qualità della sessione](/docs/it/data-usage#session-quality-surveys) appaia quando idoneo. Imposta a `0` per sopprimere completamente, o imposta [`CLAUDE_CODE_DISABLE_FEEDBACK_SURVEY`](/docs/it/env-vars) in `env`. Utile quando si utilizza Amazon Bedrock, Google Cloud's Agent Platform, o Microsoft Foundry dove il tasso di campionamento predefinito non si applica | `0.05` |
278| `fileCheckpointingEnabled` | **Predefinito**: `true`. Snapshot dei file prima di ogni edit in modo che [`/rewind`](/docs/it/checkpointing) possa ripristinarli. Appare in `/config` come **Rewind code (checkpoints)**. Per disabilitare tramite variabile di ambiente, imposta [`CLAUDE_CODE_DISABLE_FILE_CHECKPOINTING`](/docs/it/env-vars) in `env` | `false` |
279| `fileSuggestion` | Configura uno script personalizzato per l'autocompletamento dei file `@`. Vedi [Impostazioni di suggerimento file](#file-suggestion-settings) | `{"type": "command", "command": "~/.claude/file-suggestion.sh"}` |
280| `footerLinksRegexes` | Renderizza badge cliccabili extra nel footer quando un regex corrisponde all'output del turno. Ogni voce ha un `pattern`, un modello di URL `url` con placeholder `{name}` riempiti dai gruppi di cattura denominati, e un `label` opzionale. Letto dalle impostazioni utente, dal flag `--settings`, e dalle impostazioni gestite solo. Vedi [Badge di link nel footer](#footer-link-badges) per i vincoli dell'URL, l'elenco di schemi consentiti, e i limiti. Richiede Claude Code v2.1.176 o successivo | `[{"type": "regex", "pattern": "\\b(?<key>PROJ-\\d+)\\b", "url": "https://issues.example.com/browse/{key}", "label": "{key}"}]` |
281| `forceLoginMethod` | Usa `claudeai` per limitare l'accesso agli account Claude.ai, `console` per limitare l'accesso agli account Claude Console, o `gateway` per limitare l'accesso a un gateway cloud; vedi [gateway di app Claude](/docs/it/claude-apps-gateway). Quando impostato a qualsiasi valore nelle impostazioni gestite, le sessioni autenticate tramite `ANTHROPIC_API_KEY`, `ANTHROPIC_AUTH_TOKEN`, o `apiKeyHelper` vengono bloccate all'avvio, poiché nessuno di questi valori può soddisfare il metodo di accesso richiesto. Le sessioni del provider di terze parti come Amazon Bedrock, Google Cloud's Agent Platform, e Microsoft Foundry non vengono bloccate: si autenticano rispetto al tuo provider cloud piuttosto che ad Anthropic | `claudeai` |
282| `forceLoginGatewayUrl` | Pre-compila e blocca l'URL del gateway nella schermata `/login` Cloud gateway. O questa chiave o `forceLoginMethod: "gateway"` visualizza quella schermata; imposta entrambi in modo che l'URL sia compilato. Onorato solo al livello di politica gestita; ignorato nelle impostazioni utente e di progetto. Vedi [gateway di app Claude](/docs/it/claude-apps-gateway#set-the-gateway-url) | `"https://claude-gateway.example.com"` |
283| `forceLoginOrgUUID` | Richiedi che l'accesso appartenga a un'organizzazione specifica di Anthropic. Accetta una singola stringa UUID, che pre-seleziona anche quell'organizzazione durante l'accesso, o un array di UUID dove qualsiasi organizzazione elencata è accettata senza pre-selezione. Quando impostato nelle impostazioni gestite, l'accesso fallisce se l'account autenticato non appartiene a un'organizzazione elencata, e le sessioni autenticate tramite `ANTHROPIC_API_KEY`, `ANTHROPIC_AUTH_TOKEN`, o `apiKeyHelper` vengono bloccate all'avvio poiché l'appartenenza all'organizzazione non può essere verificata per loro. Le sessioni del provider di terze parti come Amazon Bedrock, Google Cloud's Agent Platform, e Microsoft Foundry non vengono bloccate: usa il tuo IAM cloud per limitare quali account cloud possono essere utilizzati. Un array vuoto fallisce in modo chiuso e blocca l'accesso con un messaggio di errore di configurazione | `"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"` o `["xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx", "yyyyyyyy-yyyy-yyyy-yyyy-yyyyyyyyyyyy"]` |
284| `forceRemoteSettingsRefresh` | (Solo impostazioni gestite) Blocca l'avvio della CLI fino a quando le impostazioni gestite remote non vengono recuperate di recente dal server. Se il recupero fallisce, la CLI esce invece di continuare con le impostazioni memorizzate nella cache o senza impostazioni. Quando non impostato, l'avvio continua senza attendere le impostazioni remote. Vedi [applicazione fail-closed](/docs/it/server-managed-settings#enforce-fail-closed-startup) | `true` |
285| `gcpAuthRefresh` | Script personalizzato che aggiorna le credenziali predefinite dell'applicazione GCP quando scadono o non possono essere caricate. Vedi [configurazione avanzata delle credenziali](/docs/it/google-vertex-ai#advanced-credential-configuration) | `gcloud auth application-default login` |
286| `hooks` | Configura comandi personalizzati da eseguire agli eventi del ciclo di vita. Vedi [documentazione hooks](/docs/it/hooks) per il formato | Vedi [hooks](/docs/it/hooks) |
287| `httpHookAllowedEnvVars` | Elenco di autorizzazione dei nomi delle variabili di ambiente che gli hook HTTP possono interpolare nelle intestazioni. Quando impostato, l'`allowedEnvVars` effettivo di ogni hook è l'intersezione del suo elenco e di questa impostazione. Non definito = nessuna restrizione. Gli array si uniscono tra le fonti di impostazioni. Vedi [Configurazione hook](#hook-configuration) | `["MY_TOKEN", "HOOK_SECRET"]` |
288| `includeGitInstructions` | **Predefinito**: `true`. Includi le istruzioni integrate del flusso di lavoro di commit e PR e lo snapshot dello stato git nel prompt di sistema di Claude. Imposta a `false` per rimuovere entrambi, ad esempio quando utilizzi le tue skill di flusso di lavoro git. La variabile di ambiente `CLAUDE_CODE_DISABLE_GIT_INSTRUCTIONS` ha la precedenza su questa impostazione quando impostata | `false` |
289| `inputNeededNotifEnabled` | **Predefinito**: `false`. Quando il [Controllo remoto](/docs/it/remote-control) è connesso, invia una notifica push al tuo telefono quando un prompt di permesso o una domanda è in attesa del tuo input. Appare in `/config` come **Push when actions required**. Vedi [Notifiche push mobile](/docs/it/remote-control#mobile-push-notifications). Richiede Claude Code v2.1.119 o successivo | `true` |
290| `language` | Configura la lingua di risposta preferita di Claude (ad es., `"japanese"`, `"spanish"`, `"french"`). Claude risponderà in questa lingua per impostazione predefinita. Imposta anche la lingua della [dettatura vocale](/docs/it/voice-dictation#change-the-dictation-language) e dei titoli di sessione generati automaticamente. A partire da v2.1.176, quando non impostato, i titoli delle sessioni corrispondono alla lingua della tua conversazione | `"japanese"` |
291| `minimumVersion` | Floor che previene l'auto-aggiornamento in background e `claude update` dall'installazione di una versione al di sotto di questa. Passare dal canale `"latest"` a `"stable"` tramite `/config` ti chiede di rimanere sulla versione corrente o di consentire il downgrade. Scegliere di rimanere imposta questo valore. Utile anche nelle [impostazioni gestite](/docs/it/permissions#managed-settings) per fissare un minimo a livello organizzativo. Per un floor rigido che blocca completamente l'avvio, vedi `requiredMinimumVersion` | `"2.1.100"` |
292| `model` | Ignora il modello predefinito da utilizzare per Claude Code. `--model` e [`ANTHROPIC_MODEL`](/docs/it/model-config#environment-variables) ignorano questo per una sessione | `"claude-sonnet-5"` |
293| `modelOverrides` | Mappa gli ID dei modelli Anthropic agli ID dei modelli specifici del provider come gli ARN del profilo di inferenza Bedrock. Ogni voce del selettore di modello utilizza il suo valore mappato quando chiama l'API del provider. Vedi [Ignora gli ID dei modelli per versione](/docs/it/model-config#override-model-ids-per-version) | `{"claude-opus-4-6": "arn:aws:bedrock:..."}` |
294| `otelHeadersHelper` | Script per generare intestazioni OpenTelemetry dinamiche. Viene eseguito all'avvio e periodicamente. Imposta l'intervallo di aggiornamento con [`CLAUDE_CODE_OTEL_HEADERS_HELPER_DEBOUNCE_MS`](/docs/it/env-vars). Vedi [Intestazioni dinamiche](/docs/it/monitoring-usage#dynamic-headers) | `/bin/generate_otel_headers.sh` |
295| `outputStyle` | Configura uno stile di output per regolare il prompt di sistema. Vedi [documentazione degli stili di output](/docs/it/output-styles) | `"Explanatory"` |
296| `parentSettingsBehavior` | (Solo impostazioni gestite) **Predefinito**: `"first-wins"`. Controlla se le impostazioni gestite fornite programmaticamente da un processo host di incorporamento, come l'Agent SDK o un'estensione IDE, si applicano quando è presente anche un livello gestito distribuito da un amministratore. `"first-wins"`: le impostazioni fornite dal parent vengono eliminate e si applica solo il livello amministrativo. `"merge"`: le impostazioni fornite dal parent si applicano sotto il livello amministrativo, filtrate in modo che possano stringere la politica ma non allentarla. Non ha effetto quando non è distribuito alcun livello amministrativo. Richiede Claude Code v2.1.133 o successivo | `"merge"` |
297| `permissions` | Vedi la tabella sottostante per la struttura dei permessi. | |
298| `plansDirectory` | **Predefinito**: `~/.claude/plans`. Personalizza dove vengono archiviati i file di piano. Il percorso è relativo alla radice del progetto. | `"./plans"` |
299| `pluginSuggestionMarketplaces` | (Solo impostazioni gestite) Nomi dei marketplace i cui plugin possono apparire come suggerimenti di installazione contestuali. Nessun suggerimento dichiarato dal marketplace viene visualizzato senza questo elenco di autorizzazione; il suggerimento incorporato di design frontend di prima parte non è interessato. I suggerimenti provengono dalla dichiarazione `relevance` di ogni plugin nella sua voce del marketplace. Un nome ha effetto solo quando il marketplace è registrato sulla macchina e la sua fonte registrata è anche dichiarata nelle impostazioni gestite, come voce `extraKnownMarketplaces` per quel nome o come voce di `strictKnownMarketplaces`. Un marketplace registrato da una fonte diversa con un nome nella lista di autorizzazione viene ignorato. Il marketplace ufficiale è esente dal requisito della fonte: autorizzare il suo nome da solo è sufficiente, poiché quel nome può registrarsi solo dalla fonte Anthropic ufficiale. | `["acme-corp-plugins"]` |
300| `pluginTrustMessage` | (Solo impostazioni gestite) Messaggio personalizzato aggiunto all'avviso di fiducia del plugin mostrato prima dell'installazione. Usa questo per aggiungere contesto specifico dell'organizzazione, ad esempio per confermare che i plugin dal tuo marketplace interno sono controllati. | `"All plugins from our marketplace are approved by IT"` |
301| `policyHelper` | Eseguibile distribuito dall'amministratore che calcola le impostazioni gestite dinamicamente all'avvio. Onorato solo da MDM o da un file `managed-settings.json` di sistema. Vedi [Calcola le impostazioni gestite con un policy helper](#compute-managed-settings-with-a-policy-helper). Richiede Claude Code v2.1.136 o successivo | `{"path": "/usr/local/bin/claude-policy"}` |
302| `preferredNotifChannel` | **Predefinito**: `"auto"`. Metodo per le notifiche di completamento attività e prompt di permesso: `"auto"`, `"terminal_bell"`, `"iterm2"`, `"iterm2_with_bell"`, `"kitty"`, `"ghostty"`, o `"notifications_disabled"`. `"auto"` invia una notifica desktop in iTerm2, Ghostty e Kitty e non fa nulla in altri terminali. Imposta `"terminal_bell"` per suonare il carattere di campanello in qualsiasi terminale. Appare in `/config` come **Notifications**. Vedi [Ottieni un campanello del terminale o una notifica](/docs/it/terminal-config#get-a-terminal-bell-or-notification) | `"terminal_bell"` |
303| `prefersReducedMotion` | Riduci o disabilita le animazioni dell'interfaccia utente (spinner, shimmer, effetti flash) per l'accessibilità | `true` |
304| `prUrlTemplate` | Modello di URL per il badge PR mostrato nel footer e nei riassunti dei risultati degli strumenti. Sostituisce `{host}`, `{owner}`, `{repo}`, `{number}`, e `{url}` dall'URL PR segnalato da `gh`. Usa per puntare i link PR a uno strumento di revisione del codice interno invece di `github.com`. Non influisce sui link automatici `#123` nella prosa di Claude | `"https://reviews.example.com/{owner}/{repo}/pull/{number}"` |
305| `remoteControlAtStartup` | Connetti il [Controllo remoto](/docs/it/remote-control) automaticamente quando ogni sessione interattiva si avvia, invece di attendere `/remote-control`. Imposta a `true` per connettersi sempre automaticamente, `false` per non connettersi mai automaticamente, o lascia non impostato per seguire il predefinito della tua organizzazione. Appare in `/config` come **Enable Remote Control for all sessions**. Vedi [Abilita il Controllo remoto per tutte le sessioni](/docs/it/remote-control#enable-remote-control-for-all-sessions) | `false` |
306| `requiredMaximumVersion` | Solo impostazioni gestite. Versione massima di Claude Code consentita per l'avvio. Se la versione in esecuzione è più recente, Claude Code esce all'avvio e istruisce l'utente a installare una versione approvata tramite il metodo approvato dell'organizzazione; `claude install <version>` potrebbe anche funzionare. L'auto-aggiornamento in background e `claude update` saltano le versioni sopra il limite, quindi un'installazione in intervallo rimane in intervallo. `claude update`, `claude install`, e `claude doctor` continuano a funzionare sopra il limite in modo che gli utenti possano recuperare. Le versioni che precedono questa impostazione la ignorano | `"2.1.150"` |
307| `requiredMinimumVersion` | Solo impostazioni gestite. Versione minima di Claude Code richiesta per l'avvio. Se la versione in esecuzione è più vecchia, Claude Code esce all'avvio e istruisce l'utente ad aggiornare tramite il metodo approvato dell'organizzazione. `claude update`, `claude install`, e `claude doctor` continuano a funzionare sotto il limite in modo che gli utenti possano recuperare. Differisce da `minimumVersion`, che previene i downgrade ma non blocca mai l'avvio. Le versioni che precedono questa impostazione la ignorano | `"2.1.150"` |
308| `respectGitignore` | **Predefinito**: `true`. Controlla se il selettore di file `@` rispetta i modelli `.gitignore`. Quando `true`, i file che corrispondono ai modelli `.gitignore` sono esclusi dai suggerimenti | `false` |
309| `respondToBashCommands` | **Predefinito**: `true`. Se Claude risponde dopo l'esecuzione di un comando shell `!` della casella di input. Imposta a `false` per aggiungere l'output del comando al contesto senza una risposta. Vedi [Modalità shell con prefisso `!`](/docs/it/interactive-mode#shell-mode-with-prefix). Richiede Claude Code v2.1.186 o successivo | `false` |
310| `showClearContextOnPlanAccept` | **Predefinito**: `false`. Mostra l'opzione "cancella contesto" nella schermata di accettazione del piano. Imposta a `true` per ripristinare l'opzione | `true` |
311| `showThinkingSummaries` | **Predefinito**: `false`. Mostra i riassunti del [pensiero esteso](/docs/it/model-config#extended-thinking) nelle sessioni interattive. Quando non impostato o `false`, i blocchi di pensiero vengono redatti dall'API e mostrati come uno stub compresso. La redazione cambia solo quello che vedi, non quello che il modello genera: per ridurre la spesa di pensiero, [abbassa il budget o disabilita il pensiero](/docs/it/model-config#extended-thinking) invece. Questa impostazione non ha effetto in modalità non interattiva (`-p`), l'Agent SDK, o le estensioni IDE come VS Code | `true` |
312| `showTurnDuration` | **Predefinito**: `true`. Mostra i messaggi di durata del turno dopo le risposte, ad es. "Cooked for 1m 6s". Appare in `/config` come **Show turn duration** | `false` |
313| `skillListingBudgetFraction` | **Predefinito**: `0.01`. Frazione della finestra di contesto del modello riservata all'[elenco di skills](/docs/it/skills#skill-descriptions-are-cut-short) che Claude vede ogni turno, quindi il predefinito riserva l'1%. Quando l'elenco supera il budget, le descrizioni per gli skills meno utilizzati vengono eliminate e vengono elencati solo i loro nomi, in modo che Claude possa comunque invocarli ma non possa vedere cosa fanno. Aumenta per mantenere più descrizioni visibili al costo di più contesto per turno. `/doctor` stima il costo dell'elenco rispetto al budget | `0.02` |
314| `skillListingMaxDescChars` | **Predefinito**: `1536`. Limite di caratteri per skill sul testo combinato `description` e `when_to_use` nell'[elenco di skills](/docs/it/skills#skill-descriptions-are-cut-short) che Claude vede ogni turno. Il testo più lungo di questo viene troncato. Aumenta per mantenere le descrizioni lunghe intatte al costo di più contesto per turno; riduci per adattare più skills sotto [`skillListingBudgetFraction`](#available-settings) | `2048` |
315| `skillOverrides` | Override di visibilità per skill, con chiave il nome dello skill. Il valore è `"on"`, `"name-only"`, `"user-invocable-only"`, o `"off"`. Ti consente di nascondere o comprimere uno skill senza modificare il suo SKILL.md. Non si applica ai plugin skills, che vengono gestiti tramite `/plugin`. Il menu `/skills` scrive questi in `.claude/settings.local.json`. Vedi [Override della visibilità dello skill dalle impostazioni](/docs/it/skills#override-skill-visibility-from-settings). Richiede Claude Code v2.1.129 o successivo | `{"legacy-context": "name-only", "deploy": "off"}` |
316| `skipWebFetchPreflight` | Salta il [controllo di sicurezza del dominio WebFetch](/docs/it/data-usage#webfetch-domain-safety-check) che invia ogni hostname richiesto a `api.anthropic.com` prima del recupero. Imposta a `true` negli ambienti che bloccano il traffico verso Anthropic, come le distribuzioni Amazon Bedrock, Google Cloud's Agent Platform, o Microsoft Foundry con egress restrittivo. Quando saltato, WebFetch tenta qualsiasi URL senza consultare l'elenco di blocco | `true` |
317| `spinnerTipsEnabled` | **Predefinito**: `true`. Mostra suggerimenti nello spinner mentre Claude sta lavorando. Imposta a `false` per disabilitare i suggerimenti | `false` |
318| `spinnerTipsOverride` | Ignora i suggerimenti dello spinner con stringhe personalizzate. `tips`: array di stringhe di suggerimento. `excludeDefault`: se `true`, mostra solo suggerimenti personalizzati; se `false` o assente, i suggerimenti personalizzati vengono uniti ai suggerimenti incorporati | `{ "excludeDefault": true, "tips": ["Use our internal tool X"] }` |
319| `spinnerVerbs` | Personalizza i verbi di azione mostrati mentre un turno è in corso. Imposta `mode` a `"replace"` per utilizzare solo i tuoi verbi, o `"append"` per aggiungerli ai predefiniti | `{"mode": "append", "verbs": ["Pondering", "Crafting"]}` |
320| `sshConfigs` | Connessioni SSH da mostrare nel menu a discesa dell'ambiente [Desktop](/docs/it/desktop#pre-configure-ssh-connections-for-your-team). Ogni voce richiede `id`, `name` e `sshHost`; `sshPort`, `sshIdentityFile` e `startDirectory` sono facoltativi. Quando impostato nelle impostazioni gestite, le connessioni sono di sola lettura per gli utenti. Letto solo dalle impostazioni gestite e utente | `[{"id": "dev-vm", "name": "Dev VM", "sshHost": "user@dev.example.com"}]` |
321| `statusLine` | Configura una status line personalizzata per visualizzare il contesto. L'oggetto ha campi opzionali `padding`, `refreshInterval`, e `hideVimModeIndicator` che controllano la spaziatura, le ri-esecuzioni periodiche, e se l'indicatore della modalità vim incorporato sotto il prompt è nascosto. Vedi [documentazione `statusLine`](/docs/it/statusline#manually-configure-a-status-line) | `{"type": "command", "command": "~/.claude/statusline.sh"}` |
322| `strictKnownMarketplaces` | (Solo impostazioni gestite) Elenco di autorizzazione dei marketplace dei plugin. Non definito = nessuna restrizione, array vuoto = blocco. Applicato all'aggiunta del marketplace e all'installazione, aggiornamento, aggiornamento e auto-aggiornamento del plugin, quindi un marketplace aggiunto prima che la politica fosse impostata non può essere utilizzato per recuperare i plugin. Vedi [Restrizioni del marketplace gestito](/docs/it/plugin-marketplaces#managed-marketplace-restrictions) | `[{ "source": "github", "repo": "acme-corp/plugins" }]` |
323| `strictPluginOnlyCustomization` | (Solo impostazioni gestite) Blocca skills, agenti, hooks e MCP server dalle fonti utente e di progetto, in modo che possano provenire solo da plugin o impostazioni gestite. `true` blocca tutti e quattro; un array blocca solo quelli denominati. Vedi [`strictPluginOnlyCustomization`](#strictpluginonlycustomization) | `["skills", "hooks"]` |
324| `syntaxHighlightingDisabled` | Disabilita l'evidenziazione della sintassi nei diff, nei blocchi di codice e nelle anteprime dei file | `true` |
325| `teammateMode` | **Predefinito**: `in-process`. Come i compagni di squadra del [team di agenti](/docs/it/agent-teams) vengono visualizzati: `in-process`, `auto` (sceglie riquadri divisi in tmux o iTerm2, in-process altrimenti), `tmux` (sceglie riquadri divisi usando tmux o iTerm2, rilevato dal tuo terminale), o }`iterm2` (riquadri divisi nativi iTerm2 tramite la CLI `it2`, aggiunto in v2.1.186). Il predefinito è cambiato da `auto` in v2.1.179. `--teammate-mode` ignora questo per una sessione. Vedi [scegli una modalità di visualizzazione](/docs/it/agent-teams#choose-a-display-mode) | `"auto"` |
326| `terminalProgressBarEnabled` | **Predefinito**: `true`. Mostra la barra di avanzamento del terminale nei terminali supportati: ConEmu, Ghostty 1.2.0+, e iTerm2 3.6.6+. Appare in `/config` come **Terminal progress bar** | `false` |
327| `theme` | **Predefinito**: `"dark"`. Tema di colore per l'interfaccia: `"auto"`, `"dark"`, `"light"`, `"dark-daltonized"`, `"light-daltonized"`, `"dark-ansi"`, `"light-ansi"`, o un riferimento a tema personalizzato come `"custom:<slug>"` o `"custom:<plugin-name>:<slug>"`. Vedi [Crea un tema personalizzato](/docs/it/terminal-config#create-a-custom-theme). Appare in `/config` come **Theme** | `"dark"` |
328| `tui` | Renderer dell'interfaccia utente del terminale. Usa `"fullscreen"` per il renderer [alt-screen](/docs/it/fullscreen) senza sfarfallio con scrollback virtualizzato. Usa `"default"` per il renderer classico della schermata principale. Imposta tramite `/tui`. Puoi anche impostare la variabile di ambiente [`CLAUDE_CODE_NO_FLICKER`](/docs/it/env-vars) | `"fullscreen"` |
329| `ultracode` | Attiva [ultracode](/docs/it/workflows#let-claude-decide-with-ultracode) per la sessione. Questa chiave non viene letta da `settings.json`. Imposta tramite `/effort ultracode`, `--settings`, o una richiesta di controllo dell'Agent SDK. Per avviare una sessione con ultracode già attivo, avvia con `claude --effort ultracode`, che richiede Claude Code v2.1.203 o successivo | `true` |
330| `useAutoModeDuringPlan` | **Predefinito**: `true`. Se la modalità piano utilizza la semantica della modalità auto quando la modalità auto è disponibile. Non letto dalle impostazioni di progetto condivise. Appare in `/config` come "Use auto mode during plan" | `false` |
331| `verbose` | **Predefinito**: `false`. Mostra l'output completo dello strumento invece dei riassunti troncati. Appare in `/config` come **Verbose output**. Il flag `--verbose` ignora questo per una sessione | `true` |
332| `viewMode` | Modalità di visualizzazione della trascrizione predefinita all'avvio: `"default"`, `"verbose"`, o `"focus"`. Ignora la selezione sticky `/focus` quando impostato. Il flag `--verbose` ignora questo per una sessione | `"verbose"` |
333| `vimInsertModeRemaps` | Mappa sequenze INSERT-mode a due tasti a Escape nella [modalità editor vim](/docs/it/interactive-mode#vim-editor-mode). Ogni chiave è esattamente due caratteri stampabili digitati in sequenza, e `"<Esc>"` è l'unico target supportato; altre voci vengono ignorate. Letto dalle impostazioni utente, dal flag `--settings`, e dalle impostazioni gestite solo, in modo che le impostazioni controllate di un repository non possono rimappare i tuoi tasti. Non ha effetto a meno che `editorMode` non sia `"vim"`. Vedi [Rimappa sequenze di tasti INSERT-mode](/docs/it/interactive-mode#remap-insert-mode-key-sequences). Richiede Claude Code v2.1.208 o successivo | `{"jj": "<Esc>"}` |
334| `voice` | Impostazioni della [dettatura vocale](/docs/it/voice-dictation): `enabled` attiva la dettatura, `mode` seleziona `"hold"` o `"tap"`, e `autoSubmit` invia il prompt al rilascio del tasto in modalità hold. Scritto automaticamente quando esegui `/voice`. Richiede un account Claude.ai | `{ "enabled": true, "mode": "tap" }` |
335| `voiceEnabled` | Alias legacy per `voice.enabled`. Preferisci l'oggetto `voice` | `true` |
336| `wheelScrollAccelerationEnabled` | **Predefinito**: `true`. Nel [rendering fullscreen](/docs/it/fullscreen#mouse-wheel-scrolling), accelera la velocità di scorrimento della rotella del mouse durante gli scorrimenti veloci. Imposta a `false` per una velocità di scorrimento costante per tacca della rotella. Richiede Claude Code v2.1.174 o successivo | `false` |
337| `workflowKeywordTriggerEnabled` | **Predefinito**: `true`. Se la parola chiave `ultracode` in un prompt attiva un [flusso di lavoro dinamico](/docs/it/workflows#ask-for-a-workflow-in-your-prompt). Imposta a `false` per digitare la parola senza attivarne uno. L'impostazione ultracode, `/workflows`, e i comandi di flusso di lavoro salvati non sono interessati. Appare in `/config` come **Ultracode keyword trigger**. Aggiunto in v2.1.157; prima di v2.1.160 la parola chiave di attivazione era `workflow` | `false` |
338| `wslInheritsWindowsSettings` | (Solo impostazioni gestite Windows) Quando `true`, Claude Code su WSL legge le impostazioni gestite dalla catena di politiche Windows in aggiunta a `/etc/claude-code`, con le fonti Windows che hanno priorità. Onorato solo quando impostato nella chiave di registro HKLM o in `C:\Program Files\ClaudeCode\managed-settings.json`, entrambi richiedono privilegi di amministratore Windows per scrivere. Affinché la politica HKCU si applichi anche su WSL, il flag deve essere impostato anche in HKCU stesso. Non ha effetto su Windows nativo | `true` |
339
340<h3 id="global-config-settings">
341 Impostazioni di configurazione globale
342</h3>
343 495
344Queste impostazioni sono archiviate in `~/.claude.json` piuttosto che in `settings.json`. Aggiungerle a `settings.json` attiverà un errore di convalida dello schema.496Prima della v2.1.211, Claude Code manteneva il file nella directory di avvio. Legge ancora un file che una versione precedente ha lasciato lì insieme al file della radice; dove entrambi impostano la stessa chiave, il valore della radice si applica, e le regole di permesso da entrambi i file si applicano. L'helper [`resolveSettings()`](/docs/it/agent-sdk/typescript#resolvesettings) dell'Agent SDK legge sempre il file dalla directory di avvio.
345 497
346<Note>498Claude Code legge il `.claude/settings.json` condiviso dalla [directory di lavoro primaria](/docs/it/permissions#working-directories) della sessione, quindi per usare un file committato alla radice del repository, avviate Claude Code lì. Dopo che [spostate la sessione con `/cd`](/docs/it/permissions#move-the-session-to-another-directory), Claude Code legge entrambi i file di progetto dalla nuova directory invece, posizionando il file locale secondo le stesse regole. Leggerli dalla directory in cui vi siete spostati richiede Claude Code v2.1.246 o successivo.
347 Le versioni precedenti a v2.1.119 archiviano anche un numero di chiavi di preferenza `/config` qui invece che in `settings.json`, inclusi `theme`, `verbose`, `editorMode`, `autoCompactEnabled`, e `preferredNotifChannel`.
348</Note>
349 499
350| Chiave | Descrizione | Esempio |500<span id="managed-settings-delivery" />
351| :--------------------------- | :-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :--------- |
352| `autoConnectIde` | **Predefinito**: `false`. Connettiti automaticamente a un IDE in esecuzione quando Claude Code si avvia da un terminale esterno. Appare in `/config` come **Auto-connect to IDE (external terminal)** quando eseguito al di fuori di un terminale VS Code o JetBrains. La variabile di ambiente [`CLAUDE_CODE_AUTO_CONNECT_IDE`](/docs/it/env-vars) ignora questo quando impostata | `true` |
353| `autoInstallIdeExtension` | **Predefinito**: `true`. Installa automaticamente l'estensione IDE di Claude Code quando eseguito da un terminale VS Code. Appare in `/config` come **Auto-install IDE extension** quando eseguito all'interno di un terminale VS Code o JetBrains. Puoi anche impostare la variabile di ambiente [`CLAUDE_CODE_IDE_SKIP_AUTO_INSTALL`](/docs/it/env-vars) a `1` | `false` |
354| `externalEditorContext` | **Predefinito**: `false`. Prependi la risposta precedente di Claude come contesto commentato con `#` quando apri l'editor esterno con `Ctrl+G`. Appare in `/config` come **Show last response in external editor** | `true` |
355| `permissionExplainerEnabled` | **Predefinito**: `true`. Mostra una [spiegazione generata dal modello del comando](/docs/it/permissions#permission-system) quando premi `Ctrl+E` su un prompt di permesso Bash o PowerShell. Imposta a `false` per disattivare la scorciatoia | `false` |
356| `teammateDefaultModel` | Modello predefinito per i compagni di squadra del [team di agenti](/docs/it/agent-teams) quando il prompt di spawn non ne specifica uno. Imposta a un alias di modello come `"sonnet"`, o `null` per ereditare la selezione `/model` corrente del lead. Appare in `/config` come **Default teammate model** | `"sonnet"` |
357| `workflowSizeGuideline` | **Predefinito**: `unrestricted`, che non invia alcuna linea guida. Imposta il [numero di agenti che Claude mira](/docs/it/workflows#set-a-size-guideline) nei flussi di lavoro dinamici che scrive. Claude Code invia il valore a Claude come consiglio, non un limite applicato. Accetta `unrestricted`, `small`, `medium`, o `large`. Appare in `/config` come **Dynamic workflow size**. Puoi anche impostarlo direttamente con `/config workflowSizeGuideline=small`. Richiede Claude Code v2.1.202 o successivo. La linea guida del numero di agenti sostituisce anche la soglia predefinita per l'[avviso `Large workflow`](/docs/it/workflows#cost); quel comportamento richiede Claude Code v2.1.203 o successivo | `"small"` |
358
359<h3 id="worktree-settings">
360 Impostazioni worktree
361</h3>
362 501
363Configura come `--worktree` crea e gestisce i git worktrees.502<span id="precedence-within-the-managed-tier" />
364 503
365| Chiave | Descrizione | Esempio |504<span id="parent-settings-from-embedding-hosts" />
366| :---------------------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :------------------------------------ |
367| `worktree.baseRef` | Quale ref i nuovi worktrees si diramano da. `"fresh"` (predefinito) si dirama da `origin/<default-branch>` per un albero pulito che corrisponde al remoto. `"head"` si dirama dal tuo `HEAD` locale corrente, quindi i commit non spinti e lo stato del ramo di funzionalità sono presenti nel worktree. All'interno di un worktree collegato, `"head"` si risolve in quel worktree `HEAD`, non nel `HEAD` del checkout principale. Si applica a `--worktree`, lo strumento `EnterWorktree`, e l'isolamento del subagent | `"head"` |
368| `worktree.symlinkDirectories` | Directory da collegare simbolicamente dal repository principale in ogni worktree per evitare di duplicare grandi directory su disco. Nessuna directory viene collegata simbolicamente per impostazione predefinita | `["node_modules", ".cache"]` |
369| `worktree.sparsePaths` | Directory da estrarre in ogni worktree tramite git sparse-checkout. Solo i percorsi elencati più i file a livello di radice vengono scritti su disco, il che è più veloce nei grandi monorepo. Mentre esiste un worktree sparse, git abilita `extensions.worktreeConfig` nel `.git/config` condiviso del repository; vedi [Estrai solo le directory di cui hai bisogno](/docs/it/large-codebases#check-out-only-the-directories-you-need) | `["packages/my-app", "shared/utils"]` |
370| `worktree.bgIsolation` | Modalità di isolamento per le [sessioni in background](/docs/it/agent-view#how-file-edits-are-isolated). `"worktree"` (predefinito) blocca `Edit`/`Write` nel checkout principale fino a quando non viene chiamato `EnterWorktree`. Al di fuori di un repository git, un [`WorktreeCreate` hook](/docs/it/worktrees#non-git-version-control) che fallisce rilascia il blocco in modo che la sessione possa modificare la directory di lavoro in posizione; richiede Claude Code v2.1.203 o successivo. `"none"` consente ai lavori in background di modificare direttamente la copia di lavoro. Richiede Claude Code v2.1.143 o successivo | `"none"` |
371 505
372Per copiare file gitignored come `.env` nei nuovi worktrees, usa un file [`.worktreeinclude`](/docs/it/worktrees#copy-gitignored-files-into-worktrees) nella radice del tuo progetto invece di un'impostazione.506<span id="enforce-settings-for-an-organization" />
373 507
374<h3 id="permission-settings">508<span id="settings-your-organization-manages" />
375 Impostazioni di permesso
376</h3>
377 509
378| Chiavi | Descrizione | Esempio |510<h3 id="check-what-your-organization-enforces">
379| :---------------------------------- | :----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :--------------------------------------------------------------------- |511 Verificate cosa la vostra organizzazione applica
380| `allow` | Array di regole di permesso per consentire l'uso dello strumento. I glob dei nomi degli strumenti sono supportati solo nella posizione dello strumento dopo un prefisso letterale `mcp__<server>__`, come `mcp__github__get_*`; il segmento del server deve essere privo di glob. Vedi [Sintassi della regola di permesso](#permission-rule-syntax) sottostante per i dettagli della corrispondenza dei modelli | `[ "Bash(git diff *)" ]` |
381| `ask` | Array di regole di permesso per chiedere conferma all'uso dello strumento. Vedi [Sintassi della regola di permesso](#permission-rule-syntax) sottostante | `[ "Bash(git push *)" ]` |
382| `deny` | Array di regole di permesso per negare l'uso dello strumento. Usa questo per escludere file sensibili dall'accesso di Claude Code. I nomi degli strumenti accettano modelli glob: `"*"` nega ogni strumento e `"mcp__*"` nega tutti gli strumenti MCP. Vedi [Sintassi della regola di permesso](#permission-rule-syntax) e [Limitazioni dei permessi Bash](/docs/it/permissions#tool-specific-permission-rules) | `[ "WebFetch", "Bash(curl *)", "Read(./.env)", "Read(./secrets/**)" ]` |
383| `additionalDirectories` | [Directory di lavoro](/docs/it/permissions#working-directories) aggiuntive per l'accesso ai file. La maggior parte della configurazione `.claude/` [non viene scoperta](/docs/it/permissions#additional-directories-grant-file-access-not-configuration) da queste directory | `[ "../docs/" ]` |
384| `defaultMode` | [Modalità di permesso](/docs/it/permission-modes) predefinita quando si apre Claude Code. Valori validi: `default`, `acceptEdits`, `plan`, `auto`, `dontAsk`, `bypassPermissions`, e {{/* min-version: 2.1.200 */}}`manual` come alias per `default`, la modalità etichettata Manual nella CLI, nelle estensioni VS Code e JetBrains, e nell'app desktop. L'alias `manual` richiede Claude Code v2.1.200 o successivo. {{/* min-version: 2.1.142 */}}`auto` viene ignorato quando impostato nelle impostazioni di progetto o locale, in modo che un repository non possa concedere a se stesso la modalità auto; impostalo invece in `~/.claude/settings.json`. Prima di v2.1.142, le impostazioni di progetto potevano impostare `auto`. Il flag CLI `--permission-mode` ignora questa impostazione per una singola sessione | `"acceptEdits"` |
385| `disableBypassPermissionsMode` | Imposta a `"disable"` per prevenire l'attivazione della modalità `bypassPermissions`. Disabilita il flag della riga di comando `--dangerously-skip-permissions`. Molto utile nelle [impostazioni gestite](/docs/it/permissions#managed-settings) per applicare la politica organizzativa, ma funziona da qualsiasi ambito | `"disable"` |
386| `skipDangerousModePermissionPrompt` | Salta il prompt di conferma mostrato prima di entrare nella modalità bypass dei permessi tramite `--dangerously-skip-permissions` o `defaultMode: "bypassPermissions"`. Ignorato quando impostato nelle impostazioni di progetto (`.claude/settings.json`) per prevenire che i repository non attendibili ignorino automaticamente il prompt | `true` |
387
388<h3 id="permission-rule-syntax">
389 Sintassi della regola di permesso
390</h3>512</h3>
391 513
392Le regole di permesso seguono il formato `Tool` o `Tool(specifier)`. Le regole vengono valutate in ordine: prima le regole di negazione, poi di richiesta, poi di autorizzazione. La prima regola corrispondente determina il risultato indipendentemente dalla specificità della regola. Vedi l'[ordine di valutazione della regola di permesso](/docs/it/permissions#manage-permissions) per i dettagli.514Se la vostra organizzazione gestisce Claude Code, alcune impostazioni sono decise per voi e nulla di quello che mettete nei vostri file cambia. Per vedere quali, eseguite `/status`: la riga `Setting sources` nomina la fonte gestita che si applica a voi. Le impostazioni gestite si applicano ovunque Claude Code viene eseguito su questa macchina; [Cosa uno sviluppatore può modificare](/docs/it/managed-settings#what-a-developer-can-change) copre i diritti di amministratore locale e gli strumenti diversi da Claude Code.
393
394Esempi rapidi:
395
396| Regola | Effetto |
397| :----------------------------- | :------------------------------------------------ |
398| `Bash` | Corrisponde a tutti i comandi Bash |
399| `Bash(npm run *)` | Corrisponde ai comandi che iniziano con `npm run` |
400| `Read(./.env)` | Corrisponde alla lettura del file `.env` |
401| `WebFetch(domain:example.com)` | Corrisponde alle richieste di fetch a example.com |
402
403Per il riferimento completo della sintassi delle regole, incluso il comportamento dei caratteri jolly, i modelli specifici dello strumento per Read, Edit, WebFetch, MCP e Agent, e le limitazioni di sicurezza dei modelli Bash, vedi [Sintassi della regola di permesso](/docs/it/permissions#permission-rule-syntax).
404
405<h3 id="sandbox-settings">
406 Impostazioni sandbox
407</h3>
408 515
409Configura il comportamento avanzato del sandboxing. Il sandboxing isola i comandi bash dal tuo filesystem e dalla rete. Vedi [Sandboxing](/docs/it/sandboxing) per i dettagli.516Le impostazioni gestite vi raggiungono attraverso i [meccanismi di consegna](/docs/it/managed-settings#delivery-mechanisms) sulla pagina delle impostazioni gestite, più comunemente:
410
411| Chiavi | Descrizione | Esempio |
412| :------------------------------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :--------------------------------------------------- |
413| `enabled` | Abilita il sandboxing bash (macOS, Linux e WSL2). Predefinito: false | `true` |
414| `failIfUnavailable` | Esci con un errore all'avvio se `sandbox.enabled` è true ma la sandbox non può avviarsi (dipendenze mancanti, piattaforma non supportata). Quando false (predefinito), viene mostrato un avviso e i comandi vengono eseguiti senza sandbox. Destinato alle distribuzioni di impostazioni gestite che richiedono il sandboxing come gate rigido | `true` |
415| `autoAllowBashIfSandboxed` | Approva automaticamente i comandi bash quando sandboxed. Predefinito: true | `true` |
416| `excludedCommands` | Comandi che dovrebbero essere eseguiti al di fuori della sandbox | `["docker *"]` |
417| `allowUnsandboxedCommands` | Consenti ai comandi di essere eseguiti al di fuori della sandbox tramite il parametro `dangerouslyDisableSandbox`. Quando impostato a `false`, la scappatoia `dangerouslyDisableSandbox` è completamente disabilitata e tutti i comandi devono essere sandboxed (o essere in `excludedCommands`). Utile per le politiche aziendali che richiedono un sandboxing rigoroso. Predefinito: true | `false` |
418| `filesystem.allowWrite` | Percorsi aggiuntivi dove i comandi sandboxed possono scrivere. Gli array vengono uniti in tutti gli ambiti di impostazioni: i percorsi utente, progetto e gestiti vengono combinati, non sostituiti. Anche uniti con i percorsi dalle regole di permesso `Edit(...)` allow. Vedi [prefissi di percorso](#sandbox-path-prefixes) sottostante. | `["/tmp/build", "~/.kube"]` |
419| `filesystem.denyWrite` | Percorsi dove i comandi sandboxed non possono scrivere. Gli array vengono uniti in tutti gli ambiti di impostazioni. Anche uniti con i percorsi dalle regole di permesso `Edit(...)` deny. | `["/etc", "/usr/local/bin"]` |
420| `filesystem.denyRead` | Percorsi dove i comandi sandboxed non possono leggere. Gli array vengono uniti in tutti gli ambiti di impostazioni. Anche uniti con i percorsi dalle regole di permesso `Read(...)` deny. | `["~/.aws/credentials"]` |
421| `filesystem.allowRead` | Percorsi per consentire nuovamente la lettura all'interno delle regioni `denyRead`. Una voce `allowRead` riapre la lettura all'interno di una regione `denyRead` più ampia, e un percorso esatto in `denyRead` rimane bloccato all'interno di una regione `allowRead` più ampia; vedi la [tabella di sovrapposizione](/docs/it/sandboxing#configure-sandboxing) per gli esempi. Gli array vengono uniti in tutti gli ambiti di impostazioni. Usa questo per creare modelli di accesso in lettura solo per l'area di lavoro. | `["."]` |
422| `filesystem.allowManagedReadPathsOnly` | (Solo impostazioni gestite) Solo i percorsi `filesystem.allowRead` dalle impostazioni gestite sono rispettati. `denyRead` si unisce comunque da tutte le fonti. Predefinito: false | `true` |
423| `credentials.files` | File o directory di credenziali che i comandi sandboxed non possono leggere. Applica lo stesso blocco di lettura di `filesystem.denyRead`; la chiave separata mantiene i percorsi delle credenziali raggruppati con `credentials.envVars` e separati dalle regole generali del filesystem. Ogni voce è `{ "path": "...", "mode": "deny" }`, e `deny` è l'unica modalità supportata per i file. I percorsi utilizzano gli stessi [prefissi](#sandbox-path-prefixes) di `filesystem.*` impostazioni. Gli array vengono uniti in tutti gli ambiti di impostazioni. Richiede Claude Code v2.1.187 o successivo. | `[{ "path": "~/.aws/credentials", "mode": "deny" }]` |
424| `credentials.envVars` | Variabili di ambiente da [proteggere dai comandi sandboxed](/docs/it/sandboxing#protect-credentials). Ogni voce ha un `name` e una `mode`; il nome deve iniziare con una lettera o un underscore e contenere solo lettere, cifre e underscore. `deny` rimuove la variabile dall'ambiente dei comandi sandboxed. Richiede Claude Code v2.1.187 o successivo. {{/* min-version: 2.1.199 */}}`mask` sostituisce la variabile con un valore sentinella per sessione all'interno della sandbox mentre il proxy della sandbox sostituisce il valore reale sulle richieste in uscita a `injectHosts` di quella voce; richiede `network.tlsTerminate` e Claude Code v2.1.199 o successivo. Le voci `mask` vengono onorate solo dalle impostazioni utente, gestite, o CLI `--settings`, non da `.claude/settings.json` o `.claude/settings.local.json`. Gli array vengono uniti in tutti gli ambiti di impostazioni, e `deny` ha la precedenza quando la stessa variabile appare con entrambe le modalità. | `[{ "name": "GITHUB_TOKEN", "mode": "deny" }]` |
425| `credentials.envVars[].injectHosts` | Host dove il proxy della sandbox sostituisce il valore reale di una voce `mask`. Ogni host deve essere coperto anche da `network.allowedDomains`, esattamente o da un carattere jolly. Quando non impostato, il proxy sostituisce il valore sulle richieste a ogni host in `network.allowedDomains`. Accettato ma ignorato quando `mode` è `deny`. Richiede Claude Code v2.1.199 o successivo. {{/* min-version: 2.1.199 */}} | `["api.github.com"]` |
426| `credentials.allowPlaintextInject` | Consenti la sostituzione `mask` anche sulle richieste HTTP semplici oltre a HTTPS con TLS terminato. Su HTTP semplice l'identità upstream non è verificata e la credenziale viaggia in chiaro, quindi lascia questo disattivato al di fuori delle reti di test attendibili. Onorato solo dalle impostazioni utente, gestite, o CLI `--settings`, non da `.claude/settings.json` o `.claude/settings.local.json`. Predefinito: false. Richiede Claude Code v2.1.199 o successivo. {{/* min-version: 2.1.199 */}} | `true` |
427| `network.allowUnixSockets` | (Solo macOS) Percorsi dei socket Unix accessibili nella sandbox. Ignorato su Linux e WSL2, dove il filtro seccomp non può ispezionare i percorsi dei socket; usa `allowAllUnixSockets` invece. | `["~/.ssh/agent-socket"]` |
428| `network.allowAllUnixSockets` | Consenti tutte le connessioni ai socket Unix nella sandbox. Su Linux e WSL2 questo è l'unico modo per consentire i socket Unix, poiché salta il filtro seccomp che altrimenti blocca le chiamate `socket(AF_UNIX, ...)`. Predefinito: false | `true` |
429| `network.allowLocalBinding` | Consenti il binding alle porte localhost (solo macOS). Predefinito: false | `true` |
430| `network.allowMachLookup` | Nomi di servizi XPC/Mach aggiuntivi che la sandbox può cercare (solo macOS). Supporta un singolo `*` finale per la corrispondenza del prefisso. Necessario per gli strumenti che comunicano tramite XPC come il simulatore iOS o Playwright. | `["com.apple.coresimulator.*"]` |
431| `network.allowedDomains` | Array di domini da consentire per il traffico di rete in uscita. Supporta i caratteri jolly (ad es., `*.example.com`). | `["github.com", "*.npmjs.org"]` |
432| `network.deniedDomains` | Array di domini da bloccare per il traffico di rete in uscita. Supporta la stessa sintassi dei caratteri jolly di `allowedDomains`. Ha la precedenza su `allowedDomains` quando entrambi corrispondono. Unito da tutte le fonti di impostazioni indipendentemente da `allowManagedDomainsOnly`. | `["sensitive.cloud.example.com"]` |
433| `network.allowManagedDomainsOnly` | (Solo impostazioni gestite) Solo `allowedDomains` e le regole allow `WebFetch(domain:...)` dalle impostazioni gestite sono rispettate. I domini dalle impostazioni utente, progetto e locale vengono ignorati. I domini non consentiti vengono bloccati automaticamente senza richiedere all'utente. I domini negati vengono comunque rispettati da tutte le fonti. Predefinito: false | `true` |
434| `network.httpProxyPort` | Porta del proxy HTTP utilizzata se desideri portare il tuo proxy. Se non specificato, Claude eseguirà il suo proxy. | `8080` |
435| `network.socksProxyPort` | Porta del proxy SOCKS5 utilizzata se desideri portare il tuo proxy. Se non specificato, Claude eseguirà il suo proxy. | `8081` |
436| `network.tlsTerminate` | Sperimentale. Termina TLS all'interno del proxy della sandbox in modo che possa leggere i contenuti delle richieste HTTPS. Richiesto per la [sostituzione delle credenziali](/docs/it/sandboxing#protect-credentials) `mask`. Imposta `{}` per generare un'autorità di certificazione effimera per la sessione, o imposta `caCertPath` e `caKeyPath` per usare la tua. Onorato solo dalle impostazioni utente, gestite, o CLI `--settings`, non da `.claude/settings.json` o `.claude/settings.local.json`. Richiede Claude Code v2.1.199 o successivo. {{/* min-version: 2.1.199 */}} | `{}` |
437| `enableWeakerNestedSandbox` | Abilita una sandbox più debole per gli ambienti Docker senza privilegi (solo Linux e WSL2). **Riduce la sicurezza.** Predefinito: false | `true` |
438| `enableWeakerNetworkIsolation` | (Solo macOS) Consenti l'accesso al servizio di fiducia TLS del sistema (`com.apple.trustd.agent`) nella sandbox. Richiesto affinché gli strumenti basati su Go come `gh`, `gcloud` e `terraform` verifichino i certificati TLS quando si utilizza `httpProxyPort` con un proxy MITM e una CA personalizzata. **Riduce la sicurezza** aprendo un potenziale percorso di esfiltrazione dei dati. Predefinito: false | `true` |
439| `allowAppleEvents` | (Solo macOS) Consenti ai comandi sandboxed di inviare Apple Events. Richiesto per `open`, `osascript`, e strumenti che aprono URL in un browser, che altrimenti falliscono con errore `-600`. **Rimuove l'isolamento dell'esecuzione del codice.** I comandi sandboxed possono lanciare altre applicazioni senza sandbox senza prompt dell'utente; possono anche inviare comandi AppleScript alle applicazioni in esecuzione come Terminal, soggetto al prompt di consenso per-app macOS automation (TCC). Onorato solo dalle impostazioni utente, gestite, o CLI, non dalle impostazioni di progetto. Predefinito: false | `true` |
440| `bwrapPath` | (Solo impostazioni gestite, Linux/WSL2) Percorso assoluto al binario bubblewrap (`bwrap`). Ignora il rilevamento automatico tramite `PATH`. Onorato solo dalle [impostazioni gestite](/docs/it/settings#settings-files), non dalle impostazioni utente o di progetto. Utile quando `bwrap` è installato in una posizione non standard negli ambienti gestiti. | `/opt/admin/bwrap` |
441| `socatPath` | (Solo impostazioni gestite, Linux/WSL2) Percorso assoluto al binario `socat` utilizzato per il proxy di rete della sandbox. Ignora il rilevamento automatico tramite `PATH`. Onorato solo dalle impostazioni gestite. | `/opt/admin/socat` |
442
443<h4 id="sandbox-path-prefixes">
444 Prefissi di percorso sandbox
445</h4>
446 517
447I percorsi in `filesystem.allowWrite`, `filesystem.denyWrite`, `filesystem.denyRead`, `filesystem.allowRead`, e `credentials.files` supportano questi prefissi:518* [Impostazioni gestite dal server](/docs/it/server-managed-settings), che Claude Code recupera dalla console di amministrazione claude.ai o da un [gateway di app Claude](/docs/it/claude-apps-gateway) auto-ospitato
519* Politiche MDM o a livello di sistema operativo, e file `managed-settings.json` in una directory di sistema
520* Un host di incorporamento come Claude Desktop, attraverso l'opzione SDK `managedSettings`; vedere [Controlla la politica da un host di incorporamento](/docs/it/managed-settings#parent-settings-from-embedding-hosts)
448 521
449| Prefisso | Significato | Esempio |522In una sessione [Cowork](https://claude.com/docs/cowork/overview) che viene eseguita sulla vostra macchina nell'app Claude Desktop, Claude Code non recupera le impostazioni gestite dal server dalla console di amministrazione claude.ai, e legge la politica distribuita al vostro dispositivo a meno che la configurazione Claude Desktop della vostra organizzazione non imposti `requireCoworkFullVmSandbox`. [Dove e quando si applica una politica](/docs/it/managed-settings#where-and-when-a-policy-applies) copre Cowork e le sessioni cloud.
450| :--------------------- | :------------------------------------------------------------------------------------------------------------ | :-------------------------------------------------------------------------- |
451| `/` | Percorso assoluto dalla radice del filesystem | `/tmp/build` rimane `/tmp/build` |
452| `~/` | Relativo alla directory home | `~/.kube` diventa `$HOME/.kube` |
453| `./` o nessun prefisso | Relativo alla radice del progetto per le impostazioni di progetto, o a `~/.claude` per le impostazioni utente | `./output` in `.claude/settings.json` si risolve in `<project-root>/output` |
454 523
455Il prefisso più vecchio `//path` per i percorsi assoluti funziona ancora. Se in precedenza hai utilizzato il singolo slash `/path` aspettandoti una risoluzione relativa al progetto, passa a `./path`. Questa sintassi differisce dalle [regole di permesso Read e Edit](/docs/it/permissions#read-and-edit), che utilizzano `//path` per assoluto e `/path` per relativo al progetto. I percorsi del filesystem sandbox utilizzano convenzioni standard: `/tmp/build` è un percorso assoluto.524Se siete l'amministratore, [Configurate Claude Code per la vostra organizzazione](/docs/it/admin-setup) vi guida attraverso la scelta di cosa applicare, e [Distribuisci le impostazioni gestite](/docs/it/managed-settings) copre la consegna e come confermare che una politica è in vigore.
456 525
457**Esempio di configurazione:**526<h2 id="change-a-setting">
527 Modificate un'impostazione
528</h2>
458 529
459```json theme={null}530Potete modificare un'impostazione dal menu `/config`, modificando un file di impostazioni, o per una sessione dalla riga di comando.
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**Le restrizioni del filesystem e della rete** possono essere configurate in due modi che vengono uniti insieme:532<span id="system-prompt" />
482 533
483* **Impostazioni `sandbox.filesystem`** (mostrate sopra): Controllano i percorsi al confine della sandbox a livello di sistema operativo. Queste restrizioni si applicano a tutti i comandi dei sottoprocessi (ad es., `kubectl`, `terraform`, `npm`), non solo agli strumenti di file di Claude.534Il prompt di sistema di Claude Code non è pubblicato. Per dare a Claude istruzioni permanenti, usate i file [`CLAUDE.md`](/docs/it/memory) o il flag `--append-system-prompt`.
484* **Regole di permesso**: Usa le regole allow/deny `Edit` per controllare l'accesso dello strumento di file di Claude, le regole deny `Read` per bloccare le letture (una regola deny `Read` blocca anche lo strumento Edit sui percorsi corrispondenti), e le regole allow/deny `WebFetch` per controllare i domini di rete. I percorsi da queste regole vengono anche uniti nella configurazione della sandbox.
485 535
486<h3 id="attribution-settings">536<h3 id="use-the-/config-menu">
487 Impostazioni di attribuzione537 Usate il menu /config
488</h3>538</h3>
489 539
490Claude Code aggiunge attribuzione ai commit git e alle pull request. Questi vengono configurati separatamente:540Eseguite `/config` dentro Claude Code e aprite la scheda **Config**. Elenca un breve insieme di opzioni personali come tema, modalità editor e output dettagliato, non ogni chiave di impostazioni. Selezionate un'opzione per modificarla; Claude Code la salva per voi:
491 541
492* I commit utilizzano i [git trailers](https://git-scm.com/docs/git-interpret-trailers) (come `Co-Authored-By`) per impostazione predefinita, che possono essere personalizzati o disabilitati542* **La maggior parte delle opzioni**: `~/.claude/settings.json`
493* Le descrizioni delle pull request sono testo semplice543* **Poche opzioni, come Mostra suggerimenti**: `.claude/settings.local.json`
544* **Le [opzioni di configurazione globale](/docs/it/settings-reference#global-config-settings)**: `~/.claude.json`
494 545
495| Chiavi | Descrizione |546Per impostare un'opzione senza il menu, passate `key=value`, come `/config verbose=true`.
496| :----------- | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
497| `commit` | Attribuzione per i commit git, inclusi eventuali trailer. La stringa vuota nasconde l'attribuzione del commit |
498| `pr` | Attribuzione per le descrizioni delle pull request. La stringa vuota nasconde l'attribuzione della pull request |
499| `sessionUrl` | Se aggiungere il link della sessione claude.ai come trailer `Claude-Session` nei commit e un link nelle descrizioni delle pull request quando eseguito da una sessione web o Controllo remoto. Predefinito: `true`. Imposta a `false` per omettere il link |
500
501**Attribuzione predefinita del commit:**
502
503```text theme={null}
504Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
505```
506
507Il nome del modello nel trailer riflette il modello attivo per la sessione.
508
509**Attribuzione predefinita della pull request:**
510
511```text theme={null}
512🤖 Generated with [Claude Code](https://claude.com/claude-code)
513```
514
515**Esempio:**
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 L'impostazione `attribution` ha la precedenza sull'impostazione deprecata `includeCoAuthoredBy`. Per nascondere tutta l'attribuzione, imposta `commit` e `pr` a stringhe vuote e `sessionUrl` a `false`.549 `/config` fa parte dell'interfaccia del terminale. Il [pannello chat VS Code](/docs/it/vs-code) e l'[app desktop](/docs/it/desktop) non lo aprono; modificate le impostazioni lì modificando un file di impostazioni o attraverso le impostazioni di quelle app.
528</Note>550</Note>
529 551
530<h3 id="file-suggestion-settings">552<h3 id="edit-a-settings-file">
531 Impostazioni di suggerimento file553 Modificate un file di impostazioni
532</h3>554</h3>
533 555
534Configura un comando personalizzato per l'autocompletamento del percorso del file `@`. Il suggerimento di file incorporato utilizza l'attraversamento veloce del filesystem, ma i grandi monorepo potrebbero beneficiare dell'indicizzazione specifica del progetto come un indice di file pre-costruito o strumenti personalizzati.556Aprite il file di impostazioni per l'ambito che volete nel vostro editor e aggiungete o modificate una chiave. I file di impostazioni sono JSON rigoroso: un commento `//` o una virgola finale è un errore di sintassi, e Claude Code segnala il file come un [Errore di impostazioni](#fix-a-broken-settings-file) al prossimo avvio. Ad esempio, per permettere a Claude Code di eseguire i vostri comandi lint e test senza chiedere e impedirgli di leggere file `.env`, aggiungete questo a `~/.claude/settings.json`:
535
536```json theme={null}
537{
538 "fileSuggestion": {
539 "type": "command",
540 "command": "~/.claude/file-suggestion.sh"
541 }
542}
543```
544
545Il comando viene eseguito con le stesse variabili di ambiente degli [hooks](/docs/it/hooks), incluso `CLAUDE_PROJECT_DIR`. Riceve JSON tramite stdin con un campo `query`:
546
547```json theme={null}
548{"query": "src/comp"}
549```
550
551Restituisci i percorsi dei file separati da newline a stdout (attualmente limitati a 15):
552
553```text theme={null}
554src/components/Button.tsx
555src/components/Modal.tsx
556src/components/Form.tsx
557```
558
559**Esempio:**
560
561```bash theme={null}
562#!/bin/bash
563query=$(cat | jq -r '.query')
564# Sostituisci your-repo-file-index con il tuo comando di ricerca file
565your-repo-file-index --query "$query" | head -20
566```
567
568<h3 id="footer-link-badges">
569 Badge di link nel footer
570</h3>
571
572L'impostazione `footerLinksRegexes` renderizza badge cliccabili extra nel footer sotto la casella di input. Usalo per trasformare gli ID stampati dai CLI del progetto, come strumenti di revisione e tracker di problemi, in link di sessione.
573
574Ogni voce del `pattern` regex viene confrontata con l'output del turno: risultati degli strumenti, inclusi contenuti di file e pagine recuperate, e le risposte di Claude stesso. I placeholder `{name}` in `url` e `label` vengono riempiti dai gruppi di cattura denominati nel pattern.
575
576L'esempio seguente renderizza un badge ogni volta che appare una chiave di problema come `PROJ-1234` nell'output del turno. Il gruppo denominato `(?<key>...)` cattura la chiave, e `{key}` la sostituisce nell'URL e nell'etichetta:
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
591Con questo configurato, quando `PROJ-1234` appare in un risultato dello strumento o nella risposta di Claude, un chip `PROJ-1234` appare nel footer collegato a `https://issues.example.com/browse/PROJ-1234`.574Ogni voce sotto `permissions` è una regola che nomina uno strumento e cosa può fare; [Configura i permessi](/docs/it/permissions) spiega la sintassi. La riga `$schema` punta allo [schema JSON pubblicato](https://json.schemastore.org/claude-code-settings.json) per le impostazioni di Claude Code, che vi dà l'autocompletamento e la convalida inline in VS Code, Cursor e qualsiasi altro editor che supporta lo schema JSON. Lo schema può rimanere indietro rispetto ai rilasci CLI più recenti, quindi un avviso di convalida su una chiave documentata di recente non significa che la vostra configurazione non sia valida.
592
593I seguenti vincoli si applicano a ogni voce:
594 575
595| Vincolo | Comportamento |576Dopo aver salvato, eseguite `/status` dentro Claude Code per confermare che il file è stato caricato; [Conferma cosa è stato caricato](#check-what-loaded) dice cosa mostra la riga `Setting sources` e come un file rotto è segnalato.
596| :------------------ | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
597| Origine URL | I valori catturati sono codificati in URL e l'URL costruito deve condividere l'origine letterale del modello. Una cattura può riempire un segmento di percorso o un valore di query ma non può cambiare dove punta il link |
598| Lunghezza URL | Gli URL costruiti più lunghi di 2048 caratteri vengono eliminati |
599| Schema URL | Deve essere `https`, `http`, o uno schema di deep-link riconosciuto per editor o workspace: `vscode`, `vscode-insiders`, `cursor`, `windsurf`, `zed`, `jetbrains`, `idea`, `slack`, `linear`, `notion`, `figma` |
600| Etichetta | Predefinito al testo corrispondente e viene troncato a 28 colonne di visualizzazione |
601| Conteggio badge | Al massimo 5 badge vengono renderizzati. Il più vecchio viene spostato dai nuovi match e `/clear` li rimuove |
602| Ambito impostazioni | Letto dalle impostazioni utente, dal flag `--settings`, e dalle impostazioni gestite solo. Ignorato in `.claude/settings.json` e `.claude/settings.local.json` del progetto |
603 577
604Quando un turno si completa, Claude Code confronta ogni voce del `pattern` regex con l'output del turno sul thread principale, quindi un regex lento blocca l'interfaccia utente fino al completamento. I quantificatori annidati come `(a+)+$` possono richiedere un tempo esponenziale rispetto a certi input e bloccare la sessione, quindi mantieni ogni `pattern` lineare ed evita di annidare `+` o `*`.578Per un file personale completo, file team e file organizzativo, ognuno mostrato con un commento su ogni chiave che imposta, vedere i [file di impostazioni di esempio](/docs/it/settings-example).
605 579
606I badge del footer vengono renderizzati insieme a una [status line personalizzata](/docs/it/statusline) quando una è configurata; nessuno sostituisce l'altro. Usa una status line per una riga guidata da script che calcola il suo contenuto dai dati della sessione, e i badge del footer per trasformare gli ID dalla conversazione in link senza uno script.580<span id="pass-settings-for-one-session" />
607 581
608<h3 id="hook-configuration">582<h3 id="change-a-setting-for-one-session">
609 Configurazione hook583 Modificate un'impostazione per una sessione
610</h3>584</h3>
611 585
612Queste impostazioni controllano quali hook possono essere eseguiti e a cosa possono accedere gli hook HTTP. L'impostazione `allowManagedHooksOnly` può essere configurata solo nelle [impostazioni gestite](#settings-files). Gli elenchi di autorizzazione degli URL e delle variabili di ambiente possono essere impostati a qualsiasi livello di impostazioni e si uniscono tra le fonti.586Per provare un valore senza salvarlo, impostatelo quando avviate Claude Code. Il valore si applica a quella sessione e i vostri file di impostazioni rimangono come erano. Avete tre modi per farlo:
613
614**Comportamento quando `allowManagedHooksOnly` è `true`:**
615 587
616* Gli hook gestiti e gli hook SDK vengono caricati588* **`--settings`**: passate una chiave come JSON, inline o come percorso a un file. Claude Code la applica sopra i vostri file utente, progetto e locale e sotto le impostazioni gestite. Può impostare qualsiasi chiave che il vostro file di impostazioni utente può impostare; non può impostare chiavi `Managed` o `Global config`.
617* Gli hook dai plugin forzatamente abilitati nelle impostazioni gestite `enabledPlugins` vengono caricati. Questo consente agli amministratori di distribuire hook controllati tramite un marketplace organizzativo mentre blocca tutto il resto. La fiducia viene concessa dall'ID completo `plugin@marketplace`, quindi un plugin con lo stesso nome da un marketplace diverso rimane bloccato589* **Un flag per quella chiave**: alcune chiavi hanno il loro flag, come `--model` per `model` e `--effort` per `effortLevel` e `modelSettings`.
618* Gli hook utente, di progetto e di tutti gli altri plugin vengono bloccati590* **Una variabile di ambiente**: esportate la variabile accoppiata della chiave prima di eseguire `claude`, come `ANTHROPIC_MODEL` per `model`.
619 591
620**Limita gli URL degli hook HTTP:**592Ogni voce della chiave sulla [referenza delle impostazioni](/docs/it/settings-reference) elenca i suoi override per-sessione e quale ha la precedenza, quindi controllate la voce per la chiave che volete modificare.
621 593
622Limita quali URL gli hook HTTP possono indirizzare. Supporta `*` come carattere jolly per la corrispondenza. Quando l'array è definito, gli hook HTTP che indirizzano URL non corrispondenti vengono silenziosamente bloccati. La corrispondenza del nome host non distingue tra maiuscole e minuscole e ignora un punto FQDN finale, corrispondendo alla semantica DNS.594I comandi che eseguite dentro una sessione per lo più salvano la vostra scelta: quando modificate un'impostazione in `/config`, Claude Code la scrive nei vostri file di impostazioni, e `/model` salva il valore come vostro predefinito per le nuove sessioni.
623
624```json theme={null}
625{
626 "allowedHttpHookUrls": ["https://hooks.example.com/*", "http://localhost:*"]
627}
628```
629 595
630**Limita le variabili di ambiente degli hook HTTP:**596Se premete `s` nel selettore `/model`, Claude Code cambia il modello senza salvarlo come vostro predefinito utente. [Regola il livello di sforzo](/docs/it/model-config#adjust-effort-level) dice quali `/effort` Claude Code salva come vostro predefinito per il modello che state usando e quali si applicano solo alla sessione corrente.
631 597
632Limita quali nomi di variabili di ambiente gli hook HTTP possono interpolare nei valori delle intestazioni. L'`allowedEnvVars` effettivo di ogni hook è l'intersezione del suo elenco e di questa impostazione.598Ad esempio, per avviare una sessione su Opus senza modificare il vostro predefinito:
633 599
634```json theme={null}600```bash theme={null}
635{601claude --settings '{"model": "claude-opus-4-8"}'
636 "httpHookAllowedEnvVars": ["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 Calcola le impostazioni gestite con un policy helper605 Quando gli edits hanno effetto
642</h3>606</h3>
643 607
644L'impostazione `policyHelper` punta a un eseguibile che calcola le impostazioni gestite all'avvio, in modo che gli amministratori possono derivare la politica dalla postura del dispositivo, dall'identità o da un servizio remoto invece di un file statico. Configuralo da MDM o da un file `managed-settings.json` di sistema. Claude Code ignora `policyHelper` quando appare in qualsiasi altro ambito, incluse le impostazioni utente, le impostazioni di progetto, l'hive di registro HKCU, e le [impostazioni gestite dal server](/docs/it/server-managed-settings).608Claude Code osserva i vostri file di impostazioni e li ricarica quando cambiano, quindi applica la maggior parte degli edits alla sessione in esecuzione senza un riavvio, inclusi gli edits a `permissions`, `hooks` e helper di credenziali come `apiKeyHelper`. Il ricaricamento copre le impostazioni utente, progetto, locale e gestite, e Claude Code esegue l'[hook `ConfigChange`](/docs/it/hooks#configchange) per ogni modifica di file di impostazioni che rileva, non per le impostazioni gestite che arrivano da MDM o dalla console claude.ai. Le impostazioni gestite che arrivano attraverso MDM o dalla console claude.ai raggiungono una sessione in esecuzione secondo una pianificazione piuttosto che al salvataggio; la [tabella di consegna](/docs/it/managed-settings#choose-a-delivery-mechanism) la fornisce per fonte.
645
646L'impostazione accetta queste chiavi:
647 609
648| Chiave | Tipo | Descrizione |610Claude Code legge alcune chiavi solo una volta, all'avvio della sessione, quindi un edit a una di esse non raggiunge la sessione in esecuzione. Le chiavi lato amministratore che attendono anche un riavvio, come `requiredMinimumVersion`, sono elencate sotto [dove e quando si applica una politica](/docs/it/managed-settings#where-and-when-a-policy-applies). Quelle che è più probabile che modifichiate a metà sessione:
649| ------------------- | ------ | -------------------------------------------------------------------------------------------------------------------------- |
650| `path` | string | Percorso assoluto all'eseguibile helper |
651| `timeoutMs` | number | Quanto tempo attendere l'helper prima di trattare l'esecuzione come non riuscita |
652| `refreshIntervalMs` | number | Con quale frequenza ri-eseguire l'helper in background. Imposta a `0` per disabilitare l'aggiornamento, o a almeno `60000` |
653 611
654L'helper scrive un envelope JSON a stdout. Metti le impostazioni sotto una chiave `managedSettings` piuttosto che al livello superiore, poiché un oggetto di impostazioni nudo analizza con `managedSettings` non definito e non applica nulla:612* [`model`](/docs/it/settings-reference#model): usate [`/model`](/docs/it/model-config#setting-your-model) per cambiare a metà sessione. Ogni modello ha la sua cache di prompt, quindi la prima richiesta dopo un cambio rilegge l'intera conversazione senza cache; vedere [Cambio di modelli](/docs/it/prompt-caching#switching-models)
613* [`effortLevel`](/docs/it/settings-reference#effortlevel) e [`modelSettings`](/docs/it/settings-reference#modelsettings): usate [`/effort`](/docs/it/model-config#adjust-effort-level) per modificare lo sforzo a metà sessione
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
666Quando l'helper emette `managedSettings`, quell'oggetto diventa l'unica fonte di impostazioni gestite per l'esecuzione, prendendo la precedenza su fonti remote, MDM e basate su file. Quando l'helper esce con codice non zero all'avvio, Claude Code stampa l'errore e rifiuta di avviarsi, quindi un helper che ha bisogno di resilienza di interruzione dovrebbe servire dalla sua cache e uscire con `0`.617<span id="check-what-loaded" />
667 618
668<h3 id="settings-precedence">619<h3 id="confirm-what-loaded">
669 Precedenza delle impostazioni620 Confermate cosa è stato caricato
670</h3>621</h3>
671 622
672Le impostazioni si applicano in ordine di precedenza. Dal più alto al più basso:623Eseguite `/status` dentro Claude Code per vedere quali fonti di impostazioni sono attive. La scheda **Status** include una riga `Setting sources` che elenca ogni file di impostazioni che Claude Code ha caricato per la sessione corrente, come `User settings` o `Project local settings`. Quando le [impostazioni gestite](/docs/it/admin-setup#decide-how-settings-reach-devices) sono in vigore, la voce delle impostazioni gestite mostra tra parentesi come hanno raggiunto la vostra macchina.
673 624
6741. **Impostazioni gestite** ([gestite dal server](/docs/it/server-managed-settings), [politiche MDM/a livello di sistema operativo](#configuration-scopes), o [impostazioni gestite](/docs/it/settings#settings-files))625La riga conferma quali file Claude Code ha letto; non mostra quale file ha fornito ogni chiave. Per elencare le voci che Claude Code ha rifiutato, eseguite [`claude doctor`](/docs/it/debug-your-config); per un modello che le impostazioni di progetto o gestite impostano, l'intestazione di avvio nomina il file che lo ha impostato. `/status` e `/config` aprono lo stesso dialogo su schede diverse, e la scheda **Config** non è una visualizzazione dei contenuti del vostro `settings.json`.
675 * Politiche distribuite da IT tramite consegna dal server, profili di configurazione MDM, politiche di registro, o file di impostazioni gestite
676 * Non possono essere ignorate da nessun altro livello, inclusi gli argomenti della riga di comando
677 * All'interno del livello gestito, viene utilizzata una sola fonte gestita e le altre vengono ignorate piuttosto che unite. Precedenza, dal più alto al più basso:
678 * Output [`policyHelper`](#compute-managed-settings-with-a-policy-helper): quando configurato, questa è l'unica fonte gestita utilizzata
679 * Remoto (impostazioni gestite dal server di [claude.ai](/docs/it/server-managed-settings) o [gateway di app Claude](/docs/it/claude-apps-gateway)-consegnate)
680 * Politiche MDM/a livello di sistema operativo
681 * Basate su file (`managed-settings.d/*.json` e `managed-settings.json`, unite insieme)
682 * Registro HKCU (solo Windows)
683 * Alcuni tasti sono eccezioni, onorati quando qualsiasi fonte gestita controllata dall'amministratore li imposta piuttosto che solo la fonte vincente. La fonte del registro HKCU scrivibile dall'utente è esclusa. I tasti di eccezione sono:
684 * i tasti di blocco sandbox `sandbox.network.allowManagedDomainsOnly` e `sandbox.filesystem.allowManagedReadPathsOnly`, con i loro elenchi di autorizzazione associati
685 * `allowAllClaudeAiMcps`
686 * i percorsi binari sandbox `sandbox.bwrapPath` e `sandbox.socatPath`
687 * [`forceRemoteSettingsRefresh`](/docs/it/server-managed-settings)
688 * Gli host di incorporamento come Claude Desktop possono fornire politica tramite l'opzione SDK `managedSettings`. Per impostazione predefinita, questo viene ignorato quando è presente una fonte gestita distribuita da un amministratore: impostazioni gestite dal server, una politica MDM o a livello di sistema operativo, o un file di impostazioni gestite. Il fallback del registro HKCU scrivibile dall'utente non conta come una fonte gestita distribuita da un amministratore. Gli amministratori possono acconsentire impostando [`parentSettingsBehavior`](#available-settings) a `"merge"`. I valori dell'embedder vengono filtrati in modo che possano stringere la politica gestita ma non allentarla.
689 626
6902. **Argomenti della riga di comando**627<h3 id="fix-a-broken-settings-file">
691 * Override temporanei per una sessione specifica. JSON passato tramite `--settings <file-or-json>` si unisce con le impostazioni basate su file utilizzando le stesse regole degli altri livelli: una chiave impostata qui ignora la stessa chiave nelle impostazioni locale, di progetto o utente, e omettere una chiave lascia il valore del livello inferiore in posizione628 Riparate un file di impostazioni rotto
692 629</h3>
6933. **Impostazioni di progetto locale** (`.claude/settings.local.json`)
694 * Impostazioni personali specifiche del progetto
695 630
6964. **Impostazioni di progetto condivise** (`.claude/settings.json`)631Se digitate male JSON o impostate una chiave a un valore che Claude Code non accetta, Claude Code ve lo dice all'inizio di una sessione interattiva. Quello che mostra dipende da quanto del file è interessato:
697 * Impostazioni di progetto condivise dal team nel controllo del codice sorgente
698 632
6995. **Impostazioni utente** (`~/.claude/settings.json`)633* **Errore di impostazioni**: un file utente, progetto o locale ha JSON non valido o un valore che lo schema rifiuta. All'inizio di una sessione interattiva Claude Code mostra un dialogo che vi permette di riparare il file con l'aiuto di Claude, uscire, o continuare senza le impostazioni rotte.
700 * Impostazioni globali personali634* **Avviso di impostazioni**: solo le voci individuali falliscono, come una regola di permesso malformata o un nome di evento hook sconosciuto. Claude Code salta quei valori e mantiene il resto del file in vigore.
635* **Impostazioni gestite**: Claude Code continua a applicare il resto del file. [Voci non valide nelle impostazioni gestite](/docs/it/managed-settings#invalid-entries-in-managed-settings) dice cosa scarta e quali chiavi ricadono a un valore più rigoroso fino a quando non le riparate. Per un documento di impostazioni gestite che non è JSON valido, vedere [Il documento delle impostazioni gestite non potrebbe essere analizzato](/docs/it/errors#managed-settings-document-could-not-be-parsed).
636* **Errore di configurazione**: `~/.claude.json` non può essere analizzato. Claude Code copia il file rotto a `~/.claude/backups/.claude.json.corrupted.<timestamp>` e chiede se uscire e ripararlo manualmente o ripristinare la configurazione predefinita; un'esecuzione `-p` stampa l'errore e esce. Per recuperare il vostro stato precedente, copiate indietro uno dei cinque file `.claude.json.backup.<timestamp>` più recenti in `~/.claude/backups/`, che Claude Code salva prima di scrivere il file.
701 637
702Questa gerarchia garantisce che le politiche organizzative siano sempre applicate mentre consente comunque ai team e agli individui di personalizzare la loro esperienza. La stessa precedenza si applica se esegui Claude Code dalla CLI, dall'[estensione VS Code](/docs/it/vs-code), o da un [IDE JetBrains](/docs/it/jetbrains).638Dopo aver continuato, eseguite `/status` per vedere i file interessati e `claude doctor` per i dettagli di ogni errore.
703 639
704Ad esempio, se le tue impostazioni utente impostano `permissions.defaultMode` a `acceptEdits` e le impostazioni condivise di un progetto lo impostano a `default`, il valore del progetto si applica. L'esempio sottostante copre come le impostazioni con valore di array come le regole di permesso si combinano invece.640Un'esecuzione `-p` non mostra dialogo. A meno che [un documento di impostazioni gestite non possa essere analizzato](/docs/it/errors#managed-settings-document-could-not-be-parsed), Claude Code salta il file rotto o i valori e continua con il resto, quindi dopo un'esecuzione `-p` che ignora un'impostazione, eseguite `claude doctor` per vedere cosa ha scartato.
705 641
706<Note>642<span id="how-scopes-interact" />
707 **Le impostazioni di array si uniscono tra gli ambiti.** Quando la stessa impostazione con valore di array (come `sandbox.filesystem.allowWrite` o `permissions.allow`) appare in più ambiti, gli array vengono **concatenati e deduplicati**, non sostituiti. Ciò significa che gli ambiti con priorità inferiore possono aggiungere voci senza ignorare quelle impostate da ambiti con priorità più alta, e viceversa. Ad esempio, se le impostazioni gestite impostano `allowWrite` a `["/opt/company-tools"]` e un utente aggiunge `["~/.kube"]`, entrambi i percorsi sono inclusi nella configurazione finale.
708 643
709 Due impostazioni di array non si uniscono in questo modo:644<span id="key-points-about-the-configuration-system" />
710 645
711 * [`fallbackModel`](#available-settings) è una catena ordinata dove la posizione ha significato: il file con la precedenza più alta che la definisce fornisce l'intero valore.646<span id="which-value-claude-code-uses" />
712 * [`availableModels`](#available-settings): quando la [fonte gestita con la precedenza più alta](/docs/it/server-managed-settings#settings-precedence) la definisce, quella lista si applica così com'è e le voci utente, progetto e locale non possono estenderla. Tra gli ambiti non gestiti gli array si uniscono come al solito. Vedi [Comportamento di unione](/docs/it/model-config#merge-behavior).
713</Note>
714 647
715<h3 id="verify-active-settings">648<span id="which-value-wins" />
716 Verifica le impostazioni attive
717</h3>
718 649
719Esegui `/status` dentro Claude Code per vedere quali fonti di impostazioni sono attive. All'interno del menu, la scheda **Status** include una riga `Setting sources` che elenca ogni livello Claude Code ha caricato per la sessione corrente, come `User settings` o `Project local settings`. Quando le [impostazioni gestite](/docs/it/admin-setup#decide-how-settings-reach-devices) sono in vigore, la voce mostra il canale di distribuzione tra parentesi, ad esempio `Enterprise managed settings (remote)`, `(plist)`, `(HKLM)`, `(HKCU)`, o `(file)`. Il canale `remote` copre sia le impostazioni gestite dal server di claude.ai che le politiche consegnate dal [gateway di app Claude](/docs/it/claude-apps-gateway). Un livello appare nell'elenco solo quando quella fonte viene caricata con almeno una chiave, quindi un elenco vuoto significa che non sono state trovate fonti di impostazioni.650<h2 id="settings-precedence">
651 Precedenza delle impostazioni
652</h2>
720 653
721La riga `Setting sources` conferma quali fonti vengono lette. Non mostra quale livello ha fornito ogni singola chiave. La scheda **Config** nello stesso dialogo è un editor per un insieme fisso di interruttori come tema e output dettagliato, non una visualizzazione dei contenuti del tuo `settings.json`.654Quando la stessa chiave appare in più di un posto, Claude Code usa il valore dal livello più alto che la imposta. Lo stack sottostante mostra i livelli, il più alto in alto; una chiave a un livello più alto ignora la stessa chiave ovunque sotto.
722 655
723Se un file di impostazioni contiene errori, come JSON non valido o un valore che non supera la convalida, `/status` elenca i file interessati. Esegui `claude doctor` per i dettagli di ogni errore.656<SettingsPrecedence />
724 657
725<h3 id="key-points-about-the-configuration-system">658In ordine, precedenza più alta prima:
726 Punti chiave sul sistema di configurazione
727</h3>
728 659
729* **File di memoria (`CLAUDE.md`)**: Contengono istruzioni e contesto che Claude carica all'avvio6601. **Impostazioni gestite**: impostazioni che la vostra organizzazione distribuisce, da un file `managed-settings.json`, una politica MDM, o [impostazioni gestite dal server](/docs/it/server-managed-settings) dalla console claude.ai. Nulla di quello che impostate le ignora: una chiave che passate con `--settings` non ignora la stessa chiave gestita, e un flag come `--model` sceglie solo dai modelli che la vostra organizzazione consente. Un `model` gestito imposta il modello con cui ogni sessione inizia, e potete comunque cambiare con `/model`; il blocco è [`availableModels`](/docs/it/settings-reference#availablemodels), che vincola `/model`, `--model` e la chiave `model` nei vostri file. Quando la vostra organizzazione fornisce più di una fonte gestita, le regole per [precedenza all'interno del livello gestito](/docs/it/managed-settings#precedence-within-the-managed-tier) dicono cosa Claude Code legge da ognuna.
730* **File di impostazioni (JSON)**: Configurano permessi, variabili di ambiente e comportamento dello strumento6612. **Argomenti della riga di comando**: flag che passate quando avviate `claude` da un terminale, per una sessione; vedere [Modificate un'impostazione per una sessione](#change-a-setting-for-one-session). Claude Code unisce JSON che passate con `--settings <file-or-json>` con i vostri file di impostazioni secondo le stesse regole degli altri livelli: prende una chiave che impostate qui sopra la stessa chiave nelle impostazioni locale, progetto o utente, e mantiene il valore di livello inferiore per una chiave che omettete.
731* **Skills**: Prompt personalizzati che possono essere invocati con `/skill-name` o caricati automaticamente da Claude6623. **Impostazioni di progetto locale** (`.claude/settings.local.json`): le vostre impostazioni personali per questo progetto.
732* **MCP server**: Estendono Claude Code con strumenti e integrazioni aggiuntivi6634. **Impostazioni di progetto condivise** (`.claude/settings.json`): impostazioni che il vostro team controlla nel controllo del codice sorgente.
733* **Precedenza**: Le configurazioni di livello superiore (Managed) ignorano quelle di livello inferiore (User/Project)6645. **Impostazioni utente** (`~/.claude/settings.json`): le vostre impostazioni personali per ogni progetto.
734* **Ereditarietà**: Le impostazioni vengono unite tra gli ambiti; i valori scalari da ambiti con priorità più alta ignorano, e gli array si concatenano, con due eccezioni descritte nella [Nota di unione di array](#settings-precedence)
735 665
736<h3 id="system-prompt">666Le variabili di ambiente non sono un livello in questo stack. Quando un comportamento ha sia una variabile shell che una chiave di impostazioni, quale si applica è deciso per coppia, non per livello: `ANTHROPIC_MODEL` esportato nella vostra shell si applica sopra la chiave `model` da qualsiasi file, mentre `ANTHROPIC_DEFAULT_MODEL` si applica solo quando nessun file imposta `model`. La [referenza delle variabili di ambiente](/docs/it/env-vars#precedence) dice quali chiavi hanno una coppia e quale Claude Code legge prima. Un blocco `env` dentro un file di impostazioni è una chiave ordinaria e segue i livelli sopra.
737 Prompt di sistema
738</h3>
739 667
740Il prompt di sistema interno di Claude Code non è pubblicato. Per aggiungere istruzioni personalizzate, usa i file `CLAUDE.md` o il flag `--append-system-prompt`.668Per poche chiavi sensibili alla sicurezza, Claude Code onora un valore più rigoroso da un livello inferiore sopra un valore gestito; [Eccezioni alla precedenza delle impostazioni gestite](#exceptions-to-managed-settings-precedence) le elenca.
741 669
742<h3 id="exclude-sensitive-files">670<h3 id="lists-merge-instead-of-overriding">
743 Esclusione di file sensibili671 Gli elenchi si uniscono invece di ignorarsi
744</h3>672</h3>
745 673
746Per prevenire che Claude Code acceda a file contenenti informazioni sensibili come chiavi API, segreti e file di ambiente, usa l'impostazione `permissions.deny` nel tuo file `.claude/settings.json`:674Quando impostate la stessa chiave di elenco, come `permissions.allow`, in più di un file, Claude Code combina gli elenchi invece di sceglierne uno, quindi ogni file può aggiungere voci senza rimuovere quelle di un altro file. Quattro chiavi che contengono elenchi di modelli o voci per-modello seguono le loro regole:
747
748```json theme={null}
749{
750 "permissions": {
751 "deny": [
752 "Read(./.env)",
753 "Read(./.env.*)",
754 "Read(./secrets/**)",
755 "Read(./config/credentials.json)",
756 "Read(./build)"
757 ]
758 }
759}
760```
761
762Questo sostituisce la configurazione deprecata `ignorePatterns`. I file che corrispondono a questi modelli vengono esclusi dalla scoperta dei file e dai risultati della ricerca, e le operazioni di lettura su questi file vengono negate.
763
764<h2 id="subagent-configuration">
765 Configurazione subagent
766</h2>
767
768Claude Code supporta subagent AI personalizzati che possono essere configurati sia a livello utente che di progetto. Questi subagent vengono archiviati come file Markdown con frontmatter YAML:
769 675
770* **Subagent utente**: `~/.claude/agents/`, disponibili in tutti i tuoi progetti676* [`fallbackModel`](/docs/it/settings-reference#fallbackmodel) è una catena ordinata dove la posizione ha significato, quindi Claude Code prende l'intero valore dal file con la precedenza più alta che la definisce.
771* **Subagent di progetto**: `.claude/agents/`, specifici del tuo progetto e condivisibili con il tuo team677* [`modelPicker`](/docs/it/settings-reference#modelpicker) contiene un elenco ordinato di righe più un flag di sostituzione, quindi Claude Code non unisce mai righe da due fonti. Prende l'intero valore dal più alto tra le impostazioni gestite, `--settings` e le impostazioni utente che la definisce, e ignora la chiave nelle impostazioni di progetto e locale. Richiede Claude Code v2.1.242 o successivo.
678* [`availableModels`](/docs/it/settings-reference#availablemodels): quando le impostazioni gestite che Claude Code applica la definiscono, Claude Code applica quell'elenco così com'è e ignora le voci che aggiungete nelle impostazioni utente, progetto o locale, a meno che un'app che incorpora Claude Code non fornisca il suo elenco di modelli; vedere [Eccezioni alla precedenza delle impostazioni gestite](#exceptions-to-managed-settings-precedence). Tra le fonti gestite l'elenco non si unisce mai neanche; [come Claude Code combina le fonti gestite](/docs/it/managed-settings#how-claude-code-combines-managed-sources) dice quale elenco della fonte si applica. Tra gli ambiti non gestiti Claude Code unisce gli array come al solito.
679* [`modelSettings`](/docs/it/settings-reference#modelsettings): Claude Code lo risolve un modello alla volta, insieme a [`effortLevel`](/docs/it/settings-reference#effortlevel). La voce `modelSettings` dice quale file il valore si applica a un modello.
772 680
773I file subagent definiscono assistenti AI specializzati con prompt personalizzati e permessi degli strumenti. Scopri di più sulla creazione e l'utilizzo dei subagent nella [documentazione dei subagent](/docs/it/sub-agents).681<span id="examples" />
774 682
775<h2 id="plugin-configuration">683<h3 id="precedence-examples">
776 Configurazione plugin684 Esempi di precedenza
777</h2>
778
779Claude Code supporta un sistema di plugin che ti consente di estendere la funzionalità con skills, agenti, hooks e MCP servers. I plugin vengono distribuiti tramite marketplace e possono essere configurati sia a livello utente che di repository.
780
781<h3 id="plugin-settings">
782 Impostazioni plugin
783</h3>685</h3>
784 686
785Impostazioni relative ai plugin in `settings.json`:687Mentre Claude lavora, Claude Code mostra un suggerimento di una riga sotto lo spinner, come "Usate /config per modificare la vostra modalità di permesso predefinita (inclusa la modalità Piano)". Supponiamo che volete quei suggerimenti spenti, quindi impostate [`spinnerTipsEnabled`](/docs/it/settings-reference#spinnertipsenabled) a `false` in `~/.claude/settings.json`. Ogni scenario sottostante è qualcosa che può riattivarli, e cosa potete fare al riguardo.
786
787```json theme={null}
788{
789 "enabledPlugins": {
790 "formatter@acme-tools": true,
791 "deployer@acme-tools": true,
792 "analyzer@security-plugins": false
793 },
794 "extraKnownMarketplaces": {
795 "acme-tools": {
796 "source": {
797 "source": "github",
798 "repo": "acme-corp/claude-plugins"
799 }
800 }
801 }
802}
803```
804 688
805<h4 id="enabledplugins">689<h4 id="team-settings-override-personal-settings">
806 `enabledPlugins`690 Le impostazioni del team ignorano le impostazioni personali
807</h4>691</h4>
808 692
809Controlla quali plugin sono abilitati. Formato: `"plugin-name@marketplace-name": true/false`. Un plugin senza voce in nessun ambito ricade al suo valore [`defaultEnabled`](/docs/it/plugins-reference#default-enablement).693Il `.claude/settings.json` del vostro team lo imposta a `true`. Claude Code usa il valore del progetto perché il progetto condiviso si trova sopra l'utente, quindi vedete i suggerimenti in quel progetto e da nessun'altra parte.
810 694
811**Ambiti**:695Potete recuperare il vostro valore: aggiungete `"spinnerTipsEnabled": false` a `.claude/settings.local.json` in quel progetto. Il progetto locale si trova sopra il progetto condiviso, quindi le vostre sessioni lì smettono di mostrare i suggerimenti e le sessioni dei vostri compagni di squadra non cambiano.
812 696
813* **Impostazioni utente** (`~/.claude/settings.json`): Preferenze personali dei plugin697<h4 id="organization-settings-override-everything">
814* **Impostazioni di progetto** (`.claude/settings.json`): Plugin specifici del progetto condivisi con il team698 Le impostazioni dell'organizzazione ignorano tutto
815* **Impostazioni locali** (`.claude/settings.local.json`): Override per macchina, gitignored quando Claude Code lo crea
816* **Impostazioni gestite** (`managed-settings.json`): Override della politica a livello organizzativo che blocca l'installazione in tutti gli ambiti e nasconde il plugin dal marketplace
817
818<Note>
819 Le impostazioni di progetto hanno la precedenza sulle impostazioni utente, quindi impostare un plugin su `false` in `~/.claude/settings.json` non disabilita un plugin che le impostazioni `.claude/settings.json` del progetto abilitano. Per rinunciare a un plugin abilitato dal progetto sulla tua macchina, impostalo su `false` in `.claude/settings.local.json` invece.
820
821 I plugin forzatamente abilitati dalle impostazioni gestite non possono essere disabilitati in questo modo, poiché le impostazioni gestite ignorano le impostazioni locali.
822
823 L'abilitazione di un plugin da una fonte esterna come un repository GitHub o un pacchetto npm nelle impostazioni `.claude/settings.json` di un progetto non lo installa per altre persone. A partire da Claude Code v2.1.195, ogni percorso che carica i plugin chiede a ogni utente di [installare e fidarsi del plugin](/docs/it/discover-plugins#configure-team-marketplaces) prima che venga eseguito.
824</Note>
825
826**Esempio**:
827
828```json theme={null}
829{
830 "enabledPlugins": {
831 "code-formatter@team-tools": true,
832 "deployment-tools@team-tools": true,
833 "experimental-features@personal": false
834 }
835}
836```
837
838<h4 id="pluginconfigs">
839 `pluginConfigs`
840</h4>699</h4>
841 700
842Memorizza i valori delle opzioni non sensibili che la richiesta [`userConfig`](/docs/it/plugins-reference#user-configuration) di un plugin raccoglie, indicizzati per ID plugin. Claude Code scrive questa chiave nelle impostazioni utente quando compili la finestra di dialogo di configurazione del plugin, quindi non è necessario modificarla manualmente. Le opzioni sensibili vengono invece archiviate nel Portachiavi di macOS, oppure in `~/.claude/.credentials.json` su piattaforme senza un portachiavi supportato.701Le impostazioni gestite della vostra organizzazione lo impostano a `true`. Nulla di quello che mettete nelle impostazioni utente, progetto o locale spegne i suggerimenti, e neanche `--settings`. Gestito è il livello più alto.
843
844Questo esempio memorizza un'opzione per un plugin installato dal marketplace `acme-tools`:
845
846```json theme={null}
847{
848 "pluginConfigs": {
849 "deployer@acme-tools": {
850 "options": {
851 "api_endpoint": "https://api.example.com"
852 }
853 }
854 }
855}
856```
857 702
858`pluginConfigs` viene letto dalle impostazioni utente, dal flag `--settings` e dalle impostazioni gestite solo. Le voci nel file `.claude/settings.json` o `.claude/settings.local.json` di un progetto vengono ignorate, perché questi valori vengono sostituiti nelle configurazioni di hook, MCP e LSP del plugin, e un repository clonato non deve essere in grado di fornirli. Prima della v2.1.207, anche le impostazioni di progetto e locali venivano lette.703Non potete recuperare il vostro valore. Eseguite `/status` per vedere quale fonte gestita si applica, e chiedete al vostro amministratore se la politica dovrebbe cambiare.
859 704
860<h4 id="extraknownmarketplaces">705<h4 id="the-command-line-overrides-your-files-for-one-session">
861 `extraKnownMarketplaces`706 La riga di comando ignora i vostri file per una sessione
862</h4>707</h4>
863 708
864Definisce marketplace aggiuntivi che dovrebbero essere resi disponibili per il repository. Tipicamente utilizzato nelle impostazioni a livello di repository per garantire che i membri del team abbiano accesso alle fonti di plugin richieste.709Avete avviato la sessione con `claude --settings '{"spinnerTipsEnabled": true}'`. La riga di comando si trova sopra ogni file tranne gestito, quindi quella sessione mostra i suggerimenti anche se i vostri file dicono `false`.
865 710
866**Quando un repository include `extraKnownMarketplaces`**:711Recuperate il vostro valore nella sessione successiva; `--settings` dura una sessione e non scrive in alcun file.
867 712
8681. I membri del team vengono invitati a installare il marketplace quando fidano della cartella713<h4 id="a-flag-or-environment-variable-sets-the-same-thing">
8692. I membri del team vengono quindi invitati a installare i plugin da quel marketplace714 Un flag o una variabile di ambiente imposta la stessa cosa
8703. Gli utenti possono saltare i marketplace o i plugin indesiderati (archiviati nelle impostazioni utente)
8714. L'installazione rispetta i confini di fiducia e richiede il consenso esplicito
872
873**Esempio**:
874
875```json theme={null}
876{
877 "extraKnownMarketplaces": {
878 "acme-tools": {
879 "source": {
880 "source": "github",
881 "repo": "acme-corp/claude-plugins"
882 }
883 },
884 "security-plugins": {
885 "source": {
886 "source": "git",
887 "url": "https://git.example.com/security/plugins.git"
888 }
889 }
890 }
891}
892```
893
894**Tipi di fonte del marketplace**:
895
896* `github`: Repository GitHub (utilizza `repo`)
897* `git`: Qualsiasi URL git (utilizza `url`)
898* `directory`: Percorso del filesystem locale (utilizza `path`, solo per lo sviluppo)
899* `hostPattern`: Modello regex per abbinare gli host del marketplace (utilizza `hostPattern`)
900* `settings`: marketplace inline dichiarato direttamente in settings.json senza un repository ospitato separato (utilizza `name` e `plugins`)
901
902Il tipo di fonte `git` funziona con qualsiasi servizio di hosting git, inclusi GitLab e Bitbucket self-hosted. Claude Code clona il repository con la stessa autenticazione che `git clone` utilizzerebbe su quella macchina: helper di credenziali configurati o chiavi SSH. Un token di provider come `GITHUB_TOKEN` ha effetto solo tramite un helper di credenziali che lo legge. Vedi [Repository privati](/docs/it/plugin-marketplaces#private-repositories) per i dettagli di configurazione.
903
904Per le fonti `github` e `git`, imposta `"skipLfs": true` all'interno dell'oggetto `source` (insieme a `repo` o `url`) per saltare i download di Git LFS quando Claude Code clona o aggiorna il repository del marketplace. I file puntatore LFS rimangono come puntatori invece di scaricare il loro contenuto. Utilizza questa opzione quando il repository contiene grandi oggetti LFS non correlati al contenuto del plugin. Richiede Claude Code v2.1.153 o successivo.
905
906Ogni voce del marketplace accetta anche un Boolean `autoUpdate` facoltativo. Imposta `"autoUpdate": true` insieme a `source` per fare in modo che Claude Code aggiorni quel marketplace e aggiorni i suoi plugin installati in background dopo l'avvio. Se omesso, i marketplace ufficiali di Anthropic predefiniti a `true` e tutti gli altri marketplace predefiniti a `false`. Vedi [Configura gli aggiornamenti automatici](/docs/it/discover-plugins#configure-auto-updates).
907
908Usa `source: 'settings'` per dichiarare un piccolo set di plugin inline senza configurare un repository marketplace ospitato. I plugin elencati qui devono fare riferimento a fonti esterne come GitHub o npm. Devi comunque abilitare ogni plugin separatamente in `enabledPlugins`.
909
910```json theme={null}
911{
912 "extraKnownMarketplaces": {
913 "team-tools": {
914 "source": {
915 "source": "settings",
916 "name": "team-tools",
917 "plugins": [
918 {
919 "name": "code-formatter",
920 "source": {
921 "source": "github",
922 "repo": "acme-corp/code-formatter"
923 }
924 }
925 ]
926 }
927 }
928 }
929}
930```
931
932<h4 id="strictknownmarketplaces">
933 `strictKnownMarketplaces`
934</h4>715</h4>
935 716
936**Solo impostazioni gestite**: Controlla quali marketplace dei plugin gli utenti possono aggiungere e installare plugin da. Questa impostazione può essere configurata solo nelle [impostazioni gestite](/docs/it/settings#settings-files) e fornisce agli amministratori un controllo rigoroso sulle fonti del marketplace.717Alcune chiavi hanno un flag della riga di comando o una variabile di ambiente che ignora il valore delle impostazioni indipendentemente da quale file lo ha impostato: `ANTHROPIC_MODEL` ignora l'impostazione [`model`](/docs/it/settings-reference#model), e `--model` ignora entrambi per una sessione.
937
938**Posizioni dei file di impostazioni gestite**:
939
940* **macOS**: `/Library/Application Support/ClaudeCode/managed-settings.json`
941* **Linux e WSL**: `/etc/claude-code/managed-settings.json`
942* **Windows**: `C:\Program Files\ClaudeCode\managed-settings.json`
943
944**Caratteristiche chiave**:
945 718
946* Disponibile solo nelle impostazioni gestite (`managed-settings.json`)719Se potete recuperare il vostro valore dipende dalla chiave: annullate la variabile o eliminate il flag, e controllate la voce della chiave sulla [referenza delle impostazioni](/docs/it/settings-reference) e la riga della variabile sulla [referenza delle variabili di ambiente](/docs/it/env-vars) per quale Claude Code usa.
947* Non può essere ignorato da impostazioni utente o di progetto (precedenza più alta)
948* Applicato prima delle operazioni di rete e filesystem, quindi le fonti bloccate non vengono mai eseguite
949* Utilizza la corrispondenza esatta per le specifiche della fonte (incluso `ref`, `path` per le fonti git), tranne `hostPattern` e `pathPattern`, che utilizzano la corrispondenza regex
950 720
951**Comportamento dell'elenco di autorizzazione**:721<span id="keys-ignored-in-a-repository-file" />
952 722
953* `undefined` (predefinito): nessuna restrizione, quindi gli utenti possono aggiungere qualsiasi marketplace723<span id="keys-only-you-or-your-organization-can-set" />
954* Array vuoto `[]`: blocco completo, quindi gli utenti non possono aggiungere nuovi marketplace
955* Elenco di fonti: gli utenti possono aggiungere solo i marketplace che corrispondono esattamente
956
957**Tutti i tipi di fonte supportati**:
958
959L'elenco di autorizzazione supporta più tipi di fonte del marketplace. La maggior parte delle fonti utilizza la corrispondenza esatta, mentre `hostPattern` e `pathPattern` utilizzano la corrispondenza regex rispetto all'host del marketplace e al percorso del filesystem rispettivamente.
960
9611. **Repository GitHub**:
962
963```json theme={null}
964{ "source": "github", "repo": "acme-corp/approved-plugins" }
965{ "source": "github", "repo": "acme-corp/security-tools", "ref": "v2.0" }
966{ "source": "github", "repo": "acme-corp/plugins", "ref": "main", "path": "marketplace" }
967```
968
969Campi: `repo` (obbligatorio), `ref` (facoltativo: ramo o tag), `path` (facoltativo: sottodirectory)
970
9712. **Repository Git**:
972
973```json theme={null}
974{ "source": "git", "url": "https://gitlab.example.com/tools/plugins.git" }
975{ "source": "git", "url": "https://bitbucket.org/acme-corp/plugins.git", "ref": "production" }
976{ "source": "git", "url": "ssh://git@git.example.com/plugins.git", "ref": "v3.1", "path": "approved" }
977```
978
979Campi: `url` (obbligatorio), `ref` (facoltativo: ramo o tag), `path` (facoltativo: sottodirectory)
980
9813. **Marketplace basati su URL**:
982
983```json theme={null}
984{ "source": "url", "url": "https://plugins.example.com/marketplace.json" }
985{ "source": "url", "url": "https://cdn.example.com/marketplace.json", "headers": { "Authorization": "Bearer ${TOKEN}" } }
986```
987
988Campi: `url` (obbligatorio), `headers` (facoltativo: intestazioni HTTP per l'accesso autenticato)
989
990<Note>
991 I marketplace basati su URL scaricano solo il file `marketplace.json`. Non scaricano i file dei plugin dal server. I plugin nei marketplace basati su URL devono utilizzare fonti esterne (URL GitHub, npm o git) piuttosto che percorsi relativi. Per i plugin con percorsi relativi, utilizza un marketplace basato su Git. Vedi [Troubleshooting](/docs/it/plugin-marketplaces#plugins-with-relative-paths-fail-in-url-based-marketplaces) per i dettagli.
992</Note>
993
9944. **Pacchetti NPM**:
995
996```json theme={null}
997{ "source": "npm", "package": "@acme-corp/claude-plugins" }
998{ "source": "npm", "package": "@acme-corp/approved-marketplace" }
999```
1000 724
1001Campi: `package` (obbligatorio, supporta pacchetti con scope)725<span id="common-cases" />
1002 726
10035. **Percorsi di file**:727<span id="which-value-applies-in-common-situations" />
1004 728
1005```json theme={null}729<h3 id="troubleshoot-a-setting-that-doesn’t-apply">
1006{ "source": "file", "path": "/usr/local/share/claude/acme-marketplace.json" }730 Risolvete i problemi di un'impostazione che non si applica
1007{ "source": "file", "path": "/opt/acme-corp/plugins/marketplace.json" }731</h3>
1008```
1009
1010Campi: `path` (obbligatorio: percorso assoluto al file marketplace.json)
1011
10126. **Percorsi di directory**:
1013
1014```json theme={null}
1015{ "source": "directory", "path": "/usr/local/share/claude/acme-plugins" }
1016{ "source": "directory", "path": "/opt/acme-corp/approved-marketplaces" }
1017```
1018
1019Campi: `path` (obbligatorio: percorso assoluto alla directory contenente `.claude-plugin/marketplace.json`)
1020
10217. **Corrispondenza del modello host**:
1022
1023```json theme={null}
1024{ "source": "hostPattern", "hostPattern": "^github\\.example\\.com$" }
1025{ "source": "hostPattern", "hostPattern": "^gitlab\\.internal\\.example\\.com$" }
1026```
1027
1028Campi: `hostPattern` (obbligatorio: modello regex per abbinare l'host del marketplace)
1029
1030Utilizza la corrispondenza del modello host quando desideri consentire tutti i marketplace da un host specifico senza enumerare ogni repository individualmente. Questo è utile per le organizzazioni con server GitHub Enterprise o GitLab interni dove gli sviluppatori creano i loro marketplace.
1031
1032Estrazione dell'host per tipo di fonte:
1033
1034* `github`: corrisponde sempre a `github.com`
1035* `git`: estrae il nome host dall'URL (supporta sia i formati HTTPS che SSH)
1036* `url`: estrae il nome host dall'URL
1037* `npm`, `file`, `directory`: non supportati per la corrispondenza del modello host
1038
10398. **Corrispondenza del modello di percorso**:
1040
1041```json theme={null}
1042{ "source": "pathPattern", "pathPattern": "^/opt/approved/" }
1043{ "source": "pathPattern", "pathPattern": ".*" }
1044```
1045
1046Campi: `pathPattern` (obbligatorio: modello regex abbinato al campo `path` delle fonti `file` e `directory`)
1047
1048Utilizza la corrispondenza del modello di percorso per consentire marketplace basati su filesystem insieme alle restrizioni `hostPattern` per le fonti di rete. Imposta `".*"` per consentire tutti i percorsi locali, o un modello più ristretto per limitare a directory specifiche.
1049
1050**Esempi di configurazione**:
1051
1052Esempio: consenti solo marketplace specifici:
1053
1054```json theme={null}
1055{
1056 "strictKnownMarketplaces": [
1057 {
1058 "source": "github",
1059 "repo": "acme-corp/approved-plugins"
1060 },
1061 {
1062 "source": "github",
1063 "repo": "acme-corp/security-tools",
1064 "ref": "v2.0"
1065 },
1066 {
1067 "source": "url",
1068 "url": "https://plugins.example.com/marketplace.json"
1069 },
1070 {
1071 "source": "npm",
1072 "package": "@acme-corp/compliance-plugins"
1073 }
1074 ]
1075}
1076```
1077
1078Esempio: disabilita tutte le aggiunte del marketplace:
1079
1080```json theme={null}
1081{
1082 "strictKnownMarketplaces": []
1083}
1084```
1085
1086Esempio: consenti tutti i marketplace da un server git interno:
1087
1088```json theme={null}
1089{
1090 "strictKnownMarketplaces": [
1091 {
1092 "source": "hostPattern",
1093 "hostPattern": "^github\\.example\\.com$"
1094 }
1095 ]
1096}
1097```
1098
1099**Requisiti di corrispondenza esatta**:
1100
1101Le fonti del marketplace devono corrispondere esattamente affinché l'aggiunta di un utente sia consentita. Per le fonti basate su git (`github` e `git`), questo include tutti i campi facoltativi:
1102
1103* Il `repo` o `url` deve corrispondere esattamente
1104* Il campo `ref` deve corrispondere esattamente (o entrambi non essere definiti)
1105* Il campo `path` deve corrispondere esattamente (o entrambi non essere definiti)
1106
1107Esempi di fonti che non corrispondono:
1108
1109```json theme={null}
1110// Queste sono DIVERSE fonti:
1111{ "source": "github", "repo": "acme-corp/plugins" }
1112{ "source": "github", "repo": "acme-corp/plugins", "ref": "main" }
1113
1114// Anche queste sono DIVERSE:
1115{ "source": "github", "repo": "acme-corp/plugins", "path": "marketplace" }
1116{ "source": "github", "repo": "acme-corp/plugins" }
1117```
1118
1119**Confronto con `extraKnownMarketplaces`**:
1120
1121| Aspetto | `strictKnownMarketplaces` | `extraKnownMarketplaces` |
1122| ------------------------ | ---------------------------------------------------- | ----------------------------------------------- |
1123| **Scopo** | Applicazione della politica organizzativa | Comodità del team |
1124| **File di impostazioni** | Solo `managed-settings.json` | Qualsiasi file di impostazioni |
1125| **Comportamento** | Blocca le aggiunte non nell'elenco di autorizzazione | Installa automaticamente i marketplace mancanti |
1126| **Quando applicato** | Prima delle operazioni di rete/filesystem | Dopo il prompt di fiducia dell'utente |
1127| **Può essere ignorato** | No (precedenza più alta) | Sì (da impostazioni con precedenza più alta) |
1128| **Formato della fonte** | Oggetto fonte diretto | Marketplace denominato con fonte nidificata |
1129| **Caso d'uso** | Conformità, restrizioni di sicurezza | Onboarding, standardizzazione |
1130
1131**Differenza di formato**:
1132
1133`strictKnownMarketplaces` utilizza oggetti fonte diretti:
1134
1135```json theme={null}
1136{
1137 "strictKnownMarketplaces": [
1138 { "source": "github", "repo": "acme-corp/plugins" }
1139 ]
1140}
1141```
1142 732
1143`extraKnownMarketplaces` richiede marketplace denominati:733Quando impostate una chiave e Claude Code non si comporta come se l'aveste fatto, iniziate con `/status` per vedere quali file ha caricato, quindi trovate il vostro sintomo sottostante. [Debug della vostra configurazione](/docs/it/debug-your-config) copre i controlli più ampi, incluso un test di configurazione pulita.
1144 734
1145```json theme={null}735<h4 id="a-value-you-set-is-ignored">
1146{736 Un valore che impostate è ignorato
1147 "extraKnownMarketplaces": {737</h4>
1148 "acme-tools": {
1149 "source": { "source": "github", "repo": "acme-corp/plugins" }
1150 }
1151 }
1152}
1153```
1154 738
1155**Utilizzo di entrambi insieme**:739Qualcos'altro imposta la stessa chiave, il file non può impostare quel valore, o il file non è stato caricato:
1156 740
1157`strictKnownMarketplaces` è un gate di politica: controlla cosa gli utenti possono aggiungere ma non registra alcun marketplace. Per limitare e pre-registrare un marketplace per tutti gli utenti, imposta entrambi in `managed-settings.json`:741* **Un livello più alto lo imposta.** Un altro file di impostazioni, un flag `--settings`, o una fonte gestita imposta la chiave sopra la vostra; lo [stack](#settings-precedence) dice quale. Un flag o una variabile di ambiente può anche ignorare la chiave per conto suo, deciso chiave per chiave; la voce della chiave sulla [referenza delle impostazioni](/docs/it/settings-reference) dice quale Claude Code usa, e la voce [`env`](/docs/it/settings-reference#env) copre un valore `env` gestito rispetto a un'esportazione shell.
742* **Una chiave di sicurezza mantiene il suo valore rigoroso.** Per poche chiavi Claude Code onora il valore restrittivo da qualsiasi file, quindi un progetto `true` per [`disableClaudeAiConnectors`](/docs/it/settings-reference#disableclaudeaiconnectors) rimane acceso; vedere [Eccezioni alla precedenza delle impostazioni gestite](#exceptions-to-managed-settings-precedence).
743* **Il file non può impostare quel valore.** I valori [`permissions.defaultMode`](/docs/it/settings-reference#permissions-defaultmode) `auto` e `bypassPermissions` non hanno effetto dalle impostazioni di progetto o locale; impostateli nelle impostazioni utente o gestite invece, o passate `--permission-mode` per una sessione. Prima della v2.1.257, `bypassPermissions` aveva effetto da qualsiasi file.
744* **Il file è rotto.** JSON non valido o un valore rifiutato fa sì che Claude Code salti il file o la voce; vedere [Riparate un file di impostazioni rotto](#fix-a-broken-settings-file).
1158 745
1159```json theme={null}746<h4 id="a-change-you-made-in-claude-code-is-lost-in-new-sessions">
1160{747 Una modifica che avete fatto in Claude Code è persa nelle nuove sessioni
1161 "strictKnownMarketplaces": [748</h4>
1162 { "source": "github", "repo": "acme-corp/plugins" }
1163 ],
1164 "extraKnownMarketplaces": {
1165 "acme-tools": {
1166 "source": { "source": "github", "repo": "acme-corp/plugins" }
1167 }
1168 }
1169}
1170```
1171 749
1172Con solo `strictKnownMarketplaces` impostato, gli utenti possono comunque aggiungere il marketplace consentito manualmente tramite `/plugin marketplace add`, ma non è disponibile automaticamente.750Quando salvate una scelta per le nuove sessioni da dentro Claude Code, come un modello predefinito con `/model`, Claude Code la scrive nel vostro file di impostazioni utente, `~/.claude/settings.json`. Se non potete scrivere in quel file, ad esempio perché un altro strumento lo genera o lo collega a una copia di sola lettura, la modifica si applica alla sessione corrente e è persa nella successiva. Impostate la chiave nello strumento che genera il file, o sostituite il file con uno in cui potete scrivere.
1173 751
1174**Note importanti**:752Se potete scrivere nel file e la modifica comunque non dura, controllate se la modifica era [solo per una sessione](#change-a-setting-for-one-session) o [un livello più alto imposta la stessa chiave](#a-value-you-set-is-ignored). Per la chiave `model`, [Una nuova sessione inizia su un modello diverso da quello che avete scelto](/docs/it/model-config#a-new-session-starts-on-a-different-model-than-you-picked) elenca più cause.
1175 753
1176* Le restrizioni vengono controllate prima di qualsiasi richiesta di rete o operazione del filesystem754<h4 id="a-managed-change-hasn’t-reached-you">
1177* Quando bloccato, gli utenti vedono messaggi di errore chiari che indicano che la fonte è bloccata dalla politica gestita755 Una modifica gestita non vi ha raggiunto
1178* La restrizione si applica all'aggiunta del marketplace e all'installazione, aggiornamento, aggiornamento e auto-aggiornamento dei plugin. Un marketplace aggiunto prima che la politica fosse impostata non può essere utilizzato per installare o aggiornare plugin una volta che la sua fonte non corrisponde più all'elenco di autorizzazione756</h4>
1179* Le impostazioni gestite hanno la precedenza più alta e non possono essere ignorate
1180 757
1181Vedi [Restrizioni del marketplace gestito](/docs/it/plugin-marketplaces#managed-marketplace-restrictions) per la documentazione rivolta agli utenti.758Le fonti gestite raggiungono una sessione in esecuzione secondo la pianificazione nella [tabella di consegna](/docs/it/managed-settings#choose-a-delivery-mechanism), quindi riavviate prima la sessione. Se `/status` allora nomina una fonte diversa da quella che il vostro amministratore ha modificato, una fonte con priorità più alta si applica; [Come Claude Code combina le fonti gestite](/docs/it/managed-settings#how-claude-code-combines-managed-sources) fornisce l'ordine.
1182 759
1183<h4 id="strictpluginonlycustomization">760<h4 id="a-committed-key-doesn’t-reach-teammates">
1184 `strictPluginOnlyCustomization`761 Una chiave committata non raggiunge i compagni di squadra
1185</h4>762</h4>
1186 763
1187**Solo impostazioni gestite**: blocca skills, agenti, hooks e MCP servers da fonti utente e di progetto, in modo che possano provenire solo da plugin o impostazioni gestite. Combinalo con `strictKnownMarketplaces` per controllare l'intera catena di approvvigionamento della personalizzazione: l'elenco di autorizzazione del marketplace controlla quali plugin gli utenti possono installare, e questa impostazione blocca tutto ciò che non proviene da un plugin o dalle impostazioni gestite.764Due cose impediscono a una chiave in `.claude/settings.json` di applicarsi per tutti coloro che la clonano:
1188
1189Il valore è `true` per bloccare tutte e quattro le superfici, oppure un array che nomina le superfici da bloccare:
1190 765
1191```json theme={null}766* **Claude Code ignora la chiave in un file di repository.** Cercate `User, local, or managed`, `User or managed`, `Managed`, o `Global config` nella colonna Scope dell'[indice delle impostazioni](/docs/it/settings-reference#settings-index); quelle chiavi non si applicano mai dal file condiviso, a parte [`autoContinueAtUsageLimit`](/docs/it/settings-reference#autocontinueatusagelimit), che un file di repository può comunque spegnere: mentre il file imposta la chiave e nessun valore utente, `--settings` o gestito lo fa, Claude Code legge l'impostazione come spenta. Le chiavi `Global config` si applicano solo da `~/.claude.json`.
1192{767* **La chiave attende la fiducia.** Le regole `permissions.allow`, `permissions.additionalDirectories`, `extraKnownMarketplaces` e la maggior parte dei valori [`env`](/docs/it/settings-reference#env) si applicano solo dopo che ogni compagno di squadra [fidia della cartella](/docs/it/permissions#project-allow-rules-and-workspace-trust). Fino ad allora vedono comunque i prompt e non ottengono i plugin da un marketplace che il file dichiara. Le regole `deny` e `ask` si applicano subito.
1193 "strictPluginOnlyCustomization": ["skills", "hooks"]
1194}
1195```
1196 768
1197Per ogni superficie bloccata, Claude Code salta le fonti a livello utente e di progetto e carica solo le fonti fornite da plugin e gestite:769<h4 id="permission-rules-combine-differently-than-you-expected">
770 Le regole di permesso si combinano diversamente da come vi aspettate
771</h4>
1198 772
1199| Superficie | Bloccato quando bloccato | Continua a caricare |773* **Avete scelto "Sì, e non chiedere di nuovo" su un prompt di permesso ma ricevete comunque il prompt per lo stesso strumento.** Quella scelta ha salvato una regola `allow` nel vostro file locale, e una regola `allow` lì non supera una regola `ask` da un file di progetto o gestito; [come le regole di permesso si combinano](/docs/it/permissions#settings-precedence) spiega l'ordine. Nell'estensione VS Code la scheda di approvazione vi permette di scegliere il file di destinazione, incluso il file condiviso del progetto, che cambia la regola per tutti; nella CLI, Claude Code scrive solo nel vostro file locale.
1200| :--------- | :---------------------------------------------- | :----------------------------------------------------------------------------- |774* **Le regole allow della vostra organizzazione si applicano comunque insieme alle vostre.** È previsto: Claude Code unisce [`permissions.allow`](/docs/it/settings-reference#permissions-allow) tra gli ambiti, a meno che la vostra organizzazione non imposti [`allowManagedPermissionRulesOnly`](/docs/it/settings-reference#allowmanagedpermissionrulesonly).
1201| `skills` | `~/.claude/skills/`, `.claude/skills/` | Plugin skills, skills in bundle, skills nella directory della politica gestita |
1202| `agents` | `~/.claude/agents/`, `.claude/agents/` | Plugin agents, agenti integrati, agenti nella directory della politica gestita |
1203| `hooks` | Hooks in user, project, e local `settings.json` | Plugin hooks, hooks nelle impostazioni gestite |
1204| `mcp` | Server in `~/.claude.json` e `.mcp.json` | Plugin MCP servers, server [`managed-mcp.json`](/docs/it/managed-mcp) |
1205 775
1206I nomi di superficie che una versione di Claude Code non riconosce vengono ignorati piuttosto che causare un errore nel file di impostazioni, quindi puoi aggiungere nuovi nomi di superficie prima che tutti i client si aggiornino.776<span id="security-keys-where-the-stricter-value-applies" />
1207 777
1208<h3 id="manage-plugins">778<h3 id="exceptions-to-managed-settings-precedence">
1209 Gestione dei plugin779 Eccezioni alla precedenza delle impostazioni gestite
1210</h3>780</h3>
1211 781
1212Usa il comando `/plugin` per gestire i plugin in modo interattivo:782Per poche chiavi sensibili alla sicurezza, Claude Code onora un valore restrittivo da un ambito che altrimenti non potrebbe ignorare le impostazioni gestite. Trovate la chiave in questa tabella per vedere quale valore onora e da dove.
1213 783
1214* Sfoglia i plugin disponibili dai marketplace784| Chiave | Valore che Claude Code onora | Note |
1215* Installa/disinstalla plugin785| :------------------------------------------------------------------------------ | :---------------------------------------------------------------------------------------------------------------------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
1216* Abilita/disabilita plugin786| [`disableClaudeAiConnectors`](/docs/it/settings-reference#disableclaudeaiconnectors) | `true` da qualsiasi ambito | Onorato anche quando una fonte gestita imposta `false` |
1217* Visualizza i dettagli del plugin (skills, agenti, hooks forniti)787| [`enableArtifact`](/docs/it/settings-reference#enableartifact) | `false` da qualsiasi ambito, e `disableArtifact: true` da qualsiasi ambito | Onorato anche quando una fonte gestita imposta `true`; nulla riattiva lo [strumento Artifact](/docs/it/artifacts#disable-artifacts). Richiede Claude Code v2.1.242 o successivo |
1218* Aggiungi/rimuovi marketplace788| [`isolatePeerMachines`](/docs/it/settings-reference#isolatepeermachines) | `true` da qualsiasi ambito | Onorato anche quando una fonte gestita imposta `false` |
789| [`remoteControlAtStartup`](/docs/it/settings-reference#remotecontrolatstartup) | `false` da `.claude/settings.json` o `.claude/settings.local.json` | Onorato anche quando una fonte gestita imposta `true`; un progetto o locale `true` è ignorato |
790| [`crossSessionInbound`](/docs/it/settings-reference#crosssessioninbound) | Un valore più rigoroso da `.claude/settings.json` o `.claude/settings.local.json`, sulla scala `accept` \< `hold` \< `refuse` | Onorato sopra i valori gestiti, `--settings` e utente; un valore di progetto o locale che non è più rigoroso è ignorato |
791| [`useAutoModeDuringPlan`](/docs/it/settings-reference#useautomodeduringplan) | `false` da qualsiasi fonte gestita, `--settings`, `~/.claude/settings.json` o `.claude/settings.local.json` | Onorato anche quando la fonte gestita vincente imposta `true`; un `false` in `.claude/settings.json` è ignorato |
792| [`syncClaudeAiSkills`](/docs/it/settings-reference#syncclaudeaiskills) | `false` da qualsiasi fonte gestita, `--settings`, `~/.claude/settings.json` o `.claude/settings.local.json` | Onorato anche quando la fonte gestita vincente imposta `true`; un `false` in `.claude/settings.json` è ignorato |
1219 793
1220Scopri di più sul sistema di plugin nella [documentazione dei plugin](/docs/it/plugins).794Un'app che esegue Claude Code dentro se stessa e imposta [`CLAUDE_CODE_PROVIDER_MANAGED_BY_HOST`](/docs/it/env-vars) è anche un'eccezione. Claude Code prende la configurazione del modello di quell'app sopra le chiavi `model`, `fallbackModel` e `modelOverrides` da ogni fonte gestita, e sopra le variabili di selezione del modello in un blocco `env` gestito, come `ANTHROPIC_MODEL` e la famiglia `ANTHROPIC_DEFAULT_*_MODEL`. Claude Code mantiene un [`availableModels`](/docs/it/settings-reference#availablemodels) gestito in vigore a meno che l'app non fornisca il suo.
1221 795
1222<h2 id="environment-variables">796<h2 id="settings-in-cloud-sessions">
1223 Variabili di ambiente797 Impostazioni nelle sessioni cloud
1224</h2>798</h2>
1225 799
1226Le variabili di ambiente consentono di controllare il comportamento di Claude Code senza modificare i file di impostazioni. Qualsiasi variabile può anche essere configurata in [`settings.json`](#available-settings) sotto la chiave `env` per applicarla a ogni sessione o distribuirla al vostro team.800Una sessione cloud, su [Claude Code sul web](/docs/it/claude-code-on-the-web) o da [`claude --cloud`](/docs/it/claude-code-on-the-web#from-terminal-to-web), viene eseguita in un [ambiente cloud](/docs/it/cloud-environments) su un clone fresco del vostro repository, non sulla vostra macchina. Questo cambia quali impostazioni la raggiungono:
1227
1228Consultare il [riferimento delle variabili di ambiente](/docs/it/env-vars) per l'elenco completo.
1229
1230<h2 id="tools-available-to-claude">
1231 Strumenti disponibili per Claude
1232</h2>
1233 801
1234Claude Code ha accesso a un set di strumenti per leggere, modificare, cercare, eseguire comandi e orchestrare subagent. I nomi degli strumenti sono le stringhe esatte che utilizzi nelle regole di permesso e nei matcher degli hook.802* **Impostazioni di progetto condivise** (`.claude/settings.json`): lette, perché il file fa parte del clone. Committate un'impostazione lì per applicarla nelle sessioni cloud.
803* **Impostazioni utente e di progetto locale** (`~/.claude/settings.json` e `.claude/settings.local.json`): non lette. Entrambe rimangono sulla vostra macchina, e il file locale non è nel clone.
804* **Impostazioni gestite**: solo le [impostazioni gestite dal server](/docs/it/server-managed-settings) raggiungono una sessione cloud; un file `managed-settings.json` o un profilo MDM sul vostro dispositivo no. Un [ambiente auto-ospitato](/docs/it/self-hosted-environments) legge anche il file di impostazioni gestite nella sua immagine di runner. [Come Claude Code combina le fonti gestite](/docs/it/managed-settings#how-claude-code-combines-managed-sources) dice quando quel file si applica.
805* **`/config`**: sul web, apre la sezione Claude Code delle vostre impostazioni claude.ai invece di modificare un valore. Per modificare un'impostazione per una sessione cloud, impostate una [variabile di ambiente](/docs/it/cloud-environments#set-environment-variables) sull'ambiente o committate la chiave al `.claude/settings.json` del repository.
1235 806
1236Vedi il [riferimento degli strumenti](/docs/it/tools-reference) per l'elenco completo e i dettagli del comportamento dello strumento Bash.807[Cosa si trasporta dalla vostra configurazione](/docs/it/cloud-environments#what-carries-over-from-your-setup) elenca il resto: `CLAUDE.md`, skills, MCP server, plugin e credenziali.
1237 808
1238<h2 id="see-also">809<h2 id="what’s-next">
1239 Vedi anche810 Cosa c'è dopo
1240</h2>811</h2>
1241 812
1242* [Permissions](/docs/it/permissions): sistema di permessi, sintassi delle regole, modelli specifici dello strumento e politiche gestite813* [Tutte le impostazioni](/docs/it/settings-reference): ogni chiave, con dove la impostate e un esempio
1243* [Authentication](/docs/it/authentication): configura l'accesso degli utenti a Claude Code814* [File di impostazioni di esempio](/docs/it/settings-example): un file personale, un file team e un file gestito di un'organizzazione
1244* [Debug your configuration](/docs/it/debug-your-config): diagnostica il motivo per cui un'impostazione, un hook o un server MCP non sta avendo effetto815* [Configura i permessi](/docs/it/permissions): regole allow, ask e deny, e cosa Claude Code esegue senza chiedere
1245* [Troubleshoot installation and login](/docs/it/troubleshoot-install): installazione, autenticazione e problemi di piattaforma816* [Variabili di ambiente](/docs/it/env-vars): le variabili che Claude Code legge e il blocco `env`
817* [Debug della vostra configurazione](/docs/it/debug-your-config): quando un'impostazione non si applica
818* [Referenza della directory Claude](/docs/it/claude-directory): ogni file che Claude Code legge, inclusi subagent, MCP server, plugin e `CLAUDE.md`