SpyBara
Go Premium

settings-reference.md 2026-09-11 23:01 UTC to 2026-09-12 03:02 UTC

This page contains 6509 additions and 0 deletions.

2026
Sat 12 03:02 Mon 14 22:58 Fri 18 23:58 Mon 21 22:59 Tue 22 23:59 Thu 24 22:57 Fri 25 23:58

Tutte le impostazioni

Riferimento completo per ogni chiave settings.json di Claude Code: dove va ciascuna, il suo tipo e valore predefinito, e un esempio pronto da incollare, con un indice di ogni chiave.

export const BackToIndex = ({href = '#all-settings', label = 'Back to index'}) => { const [show, setShow] = useState(false); useEffect(() => { const onScroll = () => setShow(window.scrollY > window.innerHeight); onScroll(); window.addEventListener('scroll', onScroll, { passive: true }); return () => window.removeEventListener('scroll', onScroll); }, []); return

<a className={'bti-btn' + (show ? ' bti-show' : '')} href={href} aria-hidden={!show} tabIndex={show ? 0 : -1}> {label}
; };

export const ReferenceFilter = ({placeholder, noun, facets, facetOrder, columnHelp, children}) => { const useLive = init => { const [v, setV] = useState(init); const ref = useRef(init); return [v, ref, x => { ref.current = x; setV(x); }]; }; const cap = s => s.charAt(0).toUpperCase() + s.slice(1); const plural = s => s.endsWith('y') ? s.slice(0, -1) + 'ies' : s + 's'; const facetNames = facets || ['category', 'topic', 'scope', 'where']; const orderOf = {}; Object.keys(facetOrder || ({})).forEach(k => { orderOf[k] = facetOrder[k].map(x => String(x).toLowerCase()); }); const rankIn = (col, v) => { const list = orderOf[col]; if (!list) return -1; const i = list.indexOf(String(v).toLowerCase()); return i < 0 ? list.length : i; }; const cmpValues = col => (a, b) => { const ra = rankIn(col, a); const rb = rankIn(col, b); if (ra !== rb) return ra - rb; return a < b ? -1 : a > b ? 1 : 0; }; const help = columnHelp || ({}); const FIRST_COL_HELP = 'Click an entry to open it.'; const optionLabel = (f, c) => c === 'All' ? 'All ' + plural(f.label.toLowerCase()) : c; const nounText = noun || 'entries'; const placeholderText = placeholder || 'Filter this reference'; const rootRef = useRef(null); const tablesRef = useRef(null); const searchRef = useRef(null); const menuRef = useRef({}); const [q, qRef, setQ] = useLive(''); const [sel, selRef, setSel] = useLive({}); const [sortBy, sortRef, setSortBy] = useLive(null); const [menuOpen, menuOpenRef, setMenu] = useLive(null); const [facetList, setFacetList] = useState([]); const [firstHead, setFirstHead] = useState(''); const [counts, setCounts] = useState({ shown: 0, total: 0 }); const [disabled, setDisabled] = useState(false); const menuBtn = name => menuRef.current[name] ? menuRef.current[name].querySelector(':scope > button') : null; const menuList = name => menuRef.current[name] ? menuRef.current[name].querySelector('[role="listbox"]') : null; const closeMenu = name => { setMenu(null); const btn = menuBtn(name); if (btn) btn.focus(); }; const focusSelected = name => { const list = menuList(name); if (!list) return; const btn = list.querySelector('button[aria-selected="true"]') || list.querySelector('button'); if (btn) btn.focus(); }; const setFacet = (name, value) => { setSel(Object.assign({}, selRef.current, { [name]: value })); apply(qRef.current); closeMenu(name); }; const sortTables = by => { (tablesRef.current || []).forEach(tab => { const t = tab.el; const idx = tab.heads.indexOf(by); const body = t.querySelector('tbody'); if (idx < 0 || !body) return; const rows = [...body.querySelectorAll('tr')]; const keyOf = r => r.children[idx] ? r.children[idx].textContent.trim().toLowerCase() : ''; const cmp = cmpValues(by); rows.map((r, i) => ({ r, i: Number(r.dataset.sfIndex !== undefined ? r.dataset.sfIndex : i), k: keyOf(r) })).sort((a, b) => cmp(a.k, b.k) || a.i - b.i).forEach(x => body.appendChild(x.r)); [...t.querySelectorAll('thead th')].forEach((h, i) => { const sortable = tab.heads[i] === tab.heads[0] || facetNames.indexOf(tab.heads[i]) > -1; if (sortable) h.setAttribute('aria-sort', i === idx ? 'ascending' : 'none'); else h.removeAttribute('aria-sort'); }); }); }; const scan = () => { const tables = []; let el = rootRef.current ? rootRef.current.nextElementSibling : null; while (el) { if (el.tagName === 'H2' || el.querySelector(':scope > h2')) break; const found = el.tagName === 'TABLE' ? [el] : [...el.querySelectorAll('table')]; found.forEach(t => { const headCells = [...t.querySelectorAll('thead th, thead td')]; const heads = headCells.map(h => h.textContent.trim().toLowerCase()); if (heads.length === 0) return; const facetIdx = {}; heads.forEach((h, i) => { if (facetNames.indexOf(h) > -1) facetIdx[h] = i; }); if (!t.dataset.sfDecorated) { t.dataset.sfDecorated = '1'; headCells.forEach((h, i) => { const text = i === 0 ? help[heads[0]] || FIRST_COL_HELP : help[heads[i]]; if (text) h.title = text; }); } const rows = [...t.querySelectorAll('tbody tr')].map((r, i) => { if (r.dataset.sfIndex === undefined) r.dataset.sfIndex = String(i); const cells = r.querySelectorAll('td'); const fv = {}; Object.keys(facetIdx).forEach(h => { fv[h] = cells[facetIdx[h]] ? cells[facetIdx[h]].textContent.trim() : ''; }); return { el: r, text: [...cells].map(c => c.textContent).join(' ').toLowerCase(), facets: fv, anchors: [...r.querySelectorAll('a[href^="#"]')].map(a => a.getAttribute('href').slice(1)), ids: [...r.querySelectorAll('[id]')].map(n => n.id) }; }); tables.push({ el: t, box: t.closest('[data-table-wrapper]') || t, rows, heads }); }); el = el.nextElementSibling; } tablesRef.current = tables; if (sortRef.current) sortTables(sortRef.current); return tables; }; const apply = query => { let tables = tablesRef.current || scan(); if (tables.some(t => !t.el.isConnected)) tables = scan(); const needle = query.trim().toLowerCase(); const sel = selRef.current; const activeFacets = Object.keys(sel).filter(h => sel[h] && sel[h] !== 'All'); const show = (el, on) => { const want = on ? '' : 'none'; if (el.style.display !== want) el.style.display = want; }; let total = 0; let shown = 0; const visibleTargets = new Set(); tables.forEach(t => { let tableVisible = 0; t.rows.forEach(row => { total += 1; const catOk = activeFacets.every(h => { const v = row.facets[h]; return v === sel[h] || v === '' || v === undefined; }); const match = catOk && (needle === '' || row.text.includes(needle)); show(row.el, match); if (match) { tableVisible += 1; row.anchors.forEach(a => visibleTargets.add(a)); } }); show(t.box, !(t.rows.length > 0 && tableVisible === 0)); shown += tableVisible; }); if (shown < total && visibleTargets.size > 0) { tables.forEach(t => { t.rows.forEach(row => { if (row.el.style.display === 'none' && row.ids.some(id => visibleTargets.has(id))) { show(row.el, true); show(t.box, true); shown += 1; } }); }); } setCounts({ shown, total }); return total; }; const deriveFacets = tables => { const seen = {}; tables.forEach(t => t.rows.forEach(r => { Object.keys(r.facets).forEach(h => { if (!seen[h]) seen[h] = []; if (r.facets[h] && seen[h].indexOf(r.facets[h]) === -1) seen[h].push(r.facets[h]); }); })); const list = facetNames.filter(h => seen[h] && seen[h].length > 0).map(h => ({ name: h, label: cap(h), values: seen[h].sort(cmpValues(h)) })); setFacetList(list); const first = tables[0] ? tables[0].heads[0] : ''; setFirstHead(first); if (!sortRef.current && first) { setSortBy(first); sortTables(first); } const init = {}; list.forEach(f => { init[f.name] = selRef.current[f.name] || 'All'; }); setSel(init); }; const onChange = value => { setQ(value); apply(value); }; const clearAll = () => { const next = {}; Object.keys(selRef.current).forEach(k => { next[k] = 'All'; }); setSel(next); setQ(''); apply(''); if (searchRef.current) searchRef.current.focus(); }; useEffect(() => { const tables = scan(); deriveFacets(tables); const total = apply(''); let retryTimer; if (total === 0) { retryTimer = setTimeout(() => { tablesRef.current = null; if (apply(qRef.current) > 0) deriveFacets(tablesRef.current); else setDisabled(true); }, 500); } const onKey = e => { if (e.key === 'Escape' && menuOpenRef.current !== null) closeMenu(menuOpenRef.current); if (!searchRef.current) return; if (e.metaKey || e.ctrlKey || e.altKey) return; const active = document.activeElement; const tag = active && active.tagName; const editable = active && active.isContentEditable; const interactive = tag === 'INPUT' || tag === 'TEXTAREA' || tag === 'SELECT' || tag === 'BUTTON' || tag === 'A' || editable || active && active.getAttribute && active.getAttribute('role'); if (e.key === '/' && !interactive) { const r = rootRef.current ? rootRef.current.getBoundingClientRect() : null; if (r && r.bottom > 0 && r.top < (window.innerHeight || 0)) { e.preventDefault(); setMenu(null); searchRef.current.focus(); } } if (e.key === 'Escape' && menuOpenRef.current === null && active === searchRef.current) { onChange(''); searchRef.current.blur(); } }; const onDocClick = e => { const open = menuOpenRef.current; if (open !== null && menuRef.current[open] && !menuRef.current[open].contains(e.target)) setMenu(null); }; window.addEventListener('keydown', onKey); document.addEventListener('mousedown', onDocClick); return () => { if (retryTimer) clearTimeout(retryTimer); window.removeEventListener('keydown', onKey); document.removeEventListener('mousedown', onDocClick); (tablesRef.current || []).forEach(t => { t.box.style.display = ''; t.rows.forEach(row => { row.el.style.display = ''; }); }); }; }, []); useEffect(() => { if (menuOpen !== null) focusSelected(menuOpen); }, [menuOpen]); if (disabled) return null; const facetActive = Object.keys(sel).some(h => sel[h] && sel[h] !== 'All'); const sortOptions = [firstHead].concat(facetList.map(f => f.name)).filter((h, i, a) => h && a.indexOf(h) === i); return <> <div ref={rootRef} className="sf-root" style={{ margin: '16px 0 8px' }}> <div style={{ display: 'flex', gap: '8px', flexWrap: 'wrap', alignItems: 'center' }}> <div style={{ position: 'relative', flex: '1 1 260px', maxWidth: '480px' }}> <input ref={searchRef} value={q} onChange={e => onChange(e.target.value)} placeholder={placeholderText} aria-label={placeholderText} style={{ width: '100%', padding: '8px 56px 8px 12px', borderRadius: '8px', border: '1px solid var(--sf-border)', background: 'var(--sf-bg)', color: 'var(--sf-text)', fontSize: '14px', outline: 'none', boxSizing: 'border-box' }} /> {q ? <button type="button" onClick={() => { onChange(''); if (searchRef.current) searchRef.current.focus(); }} aria-label="Clear text" className="sf-end sf-x"> × : <span className="sf-end" style={{ fontFamily: 'var(--font-mono, ui-monospace, monospace)', fontSize: '11px', color: 'var(--sf-text-4)', border: '1px solid var(--sf-border)', borderRadius: '3px', padding: '0 5px', pointerEvents: 'none' }}> / }

{facetList.map(f => { const cur = sel[f.name] || 'All'; const isOpen = menuOpen === f.name; return <div key={f.name} ref={el => { menuRef.current[f.name] = el; }} style={{ position: 'relative' }}> <button type="button" onClick={() => setMenu(isOpen ? null : f.name)} onKeyDown={e => { if (e.key === 'ArrowDown') { e.preventDefault(); if (!isOpen) setMenu(f.name); else focusSelected(f.name); } }} aria-haspopup="listbox" aria-expanded={isOpen} style={{ display: 'flex', alignItems: 'center', gap: '8px', padding: cur !== 'All' ? '8px 30px 8px 12px' : '8px 12px', borderRadius: '8px', border: '1px solid ' + (cur !== 'All' ? 'var(--sf-accent)' : 'var(--sf-border)'), background: 'var(--sf-bg)', color: cur === 'All' ? 'var(--sf-text-3)' : 'var(--sf-text)', fontSize: '13.5px', cursor: 'pointer', whiteSpace: 'nowrap', maxWidth: '260px' }}> <span style={{ overflow: 'hidden', textOverflow: 'ellipsis' }}> {f.label + ': ' + optionLabel(f, cur)} <span aria-hidden="true" style={{ fontSize: '9px', color: 'var(--sf-text-4)', transform: isOpen ? 'rotate(180deg)' : 'none', transition: 'transform 120ms' }}> ▼ {cur !== 'All' && <button type="button" onClick={() => setFacet(f.name, 'All')} aria-label={'Clear ' + f.label + ' filter'} title={'Clear ' + f.label + ' filter'} className="sf-end sf-x"> × } {isOpen && <div role="listbox" aria-label={f.label} onKeyDown={e => { const items = [...e.currentTarget.querySelectorAll('button')]; const idx = items.indexOf(document.activeElement); if (e.key === 'ArrowDown') { e.preventDefault(); (items[idx + 1] || items[0]).focus(); } else if (e.key === 'ArrowUp') { e.preventDefault(); (items[idx - 1] || items[items.length - 1]).focus(); } else if (e.key === 'Home') { e.preventDefault(); if (items[0]) items[0].focus(); } else if (e.key === 'End') { e.preventDefault(); if (items[items.length - 1]) items[items.length - 1].focus(); } else if (e.key === 'Tab') { closeMenu(f.name); } }} style={{ position: 'absolute', top: 'calc(100% + 6px)', left: 0, zIndex: 1000, minWidth: '260px', maxHeight: '340px', overflowY: 'auto', background: 'var(--sf-bg)', border: '1px solid var(--sf-border)', borderRadius: '10px', boxShadow: '0 8px 24px rgba(0,0,0,0.12)', padding: '5px' }}> {['All'].concat(f.values).map(c => { const selected = cur === c; return <button key={c} role="option" aria-selected={selected} tabIndex={-1} onClick={() => setFacet(f.name, c)} style={{ display: 'flex', alignItems: 'center', gap: '8px', width: '100%', textAlign: 'left', padding: '7px 10px', borderRadius: '6px', border: 'none', background: 'transparent', color: selected ? 'var(--sf-accent)' : 'var(--sf-text)', fontWeight: selected ? 600 : 400, fontSize: '13.5px', cursor: 'pointer' }}> <span aria-hidden="true" style={{ width: '14px', color: 'var(--sf-accent)', flexShrink: 0 }}> {selected ? '✓' : ''} {optionLabel(f, c)} ; })}
}
; })} {sortOptions.length > 1 && <div role="group" aria-label="Sort by" style={{ display: 'flex', alignItems: 'center', gap: '4px', fontSize: '13px', color: 'var(--sf-text-3)', whiteSpace: 'nowrap' }}> <span style={{ marginRight: '4px' }}>Sort by {sortOptions.map(o => { const on = sortBy === o; return <button key={o} type="button" aria-pressed={on} onClick={() => { setSortBy(o); sortTables(o); }} style={{ padding: '6px 10px', borderRadius: '8px', border: '1px solid ' + (on ? 'var(--sf-accent)' : 'var(--sf-border)'), background: 'var(--sf-bg)', color: on ? 'var(--sf-text)' : 'var(--sf-text-3)', fontSize: '13px', cursor: 'pointer' }}> {o.charAt(0).toUpperCase() + o.slice(1)} ; })} } <div aria-live="polite" style={{ margin: '8px 0 0', fontSize: '13px', color: 'var(--sf-text-3)', minHeight: '1px' }}> {q.trim() === '' && !facetActive ? <>{counts.total} {nounText}</> : counts.shown === 0 ? <> {q.trim() === '' ? 'No ' + nounText + ' match the selected filters.' : facetActive ? 'No ' + nounText + ' match \u201c' + q + '\u201d with the selected filters.' : 'No ' + nounText + ' match \u201c' + q + '\u201d.'}{' '} <button type="button" onClick={clearAll} style={{ background: 'none', border: 'none', padding: 0, color: 'var(--sf-accent)', cursor: 'pointer', font: 'inherit', textDecoration: 'underline' }}> Clear filters {children ? <> {children}</> : null} </> : <> Showing {counts.shown} of {counts.total} {nounText} </>} </>; };

Questa pagina di riferimento elenca ogni chiave che Claude Code legge da un file di impostazioni, più il breve gruppo di chiavi che mantiene in ~/.claude.json invece. Per scegliere un file, o controllare la precedenza, inizia con File di impostazioni e precedenza.

Indice delle impostazioni

Ogni chiave sottostante è collegata alla sua voce. Scope elenca i file in cui può trovarsi: User è ~/.claude/settings.json, Project è .claude/settings.json, Local è .claude/settings.local.json, e Managed è quello che la vostra organizzazione distribuisce. Any file significa tutti e quattro, e Global config significa ~/.claude.json.

<ReferenceFilter noun="settings" placeholder="Filter settings by key or purpose" facetOrder={{ scope: ["Any file", "User, local, or managed", "User or managed", "Managed", "Global config"] }} columnHelp={{ topic: "The section of this page that holds the entry. Use Sort by to group the table by topic.", scope: "Which settings files can set the key: user (~/.claude/settings.json), project (.claude/settings.json), local (.claude/settings.local.json), or managed (deployed by your organization). Global config keys are in ~/.claude.json instead.", }} />

Chiave Descrizione Argomento Scope
advisorModel Scegliere quale modello risponde quando Claude chiede lo strumento advisor Modello e risposte Any file
agent Avviare ogni sessione come un subagent denominato con il suo prompt, strumenti e modello Agenti, sessioni e worktrees Any file
agentPushNotifEnabled Consentire a Claude di inviare una notifica push al vostro telefono quando lo decide Remoto, desktop e notifiche Any file
allowAllClaudeAiMcps Caricare i connettori claude.ai che Claude Code recupera da solo insieme a un managed-mcp.json distribuito MCP Managed
allowedChannelPlugins Sostituire l'elenco di autorizzazione predefinito dei plugin di canale che possono inviare messaggi Plugin e skill Managed
allowedHttpHookUrls Limitare gli URL che gli hook HTTP possono raggiungere Hook e automazione Any file
allowedMcpServers Elenco di autorizzazione dei server MCP che gli utenti possono aggiungere MCP Any file
allowManagedHooksOnly Eseguire solo gli hook che la vostra organizzazione distribuisce Hook e automazione Managed
allowManagedMcpServersOnly Rendere l'elenco di autorizzazione MCP gestito l'unico che si applica MCP Managed
allowManagedPermissionRulesOnly Rendere le impostazioni gestite l'unica fonte di impostazioni delle regole di autorizzazione Impostazioni di autorizzazione Managed
alwaysThinkingEnabled Disattivare il pensiero esteso per ogni sessione Modello e risposte Any file
apiKeyHelper Generare le credenziali API con il vostro comando Autenticazione e provider Any file
askUserQuestionTimeout Consentire a una domanda senza risposta di continuare automaticamente dopo il tempo di inattività Interfaccia e terminale User or managed
attribution Personalizzare l'attribuzione che Claude Code aggiunge ai commit e alle pull request Git e attribuzione Any file
attribution.commit Modificare o nascondere il trailer che Claude Code aggiunge ai commit Git e attribuzione Any file
attribution.pr Modificare o nascondere la riga di attribuzione nelle descrizioni delle pull request Git e attribuzione Any file
attribution.sessionUrl Omettere il collegamento della sessione claude.ai dai commit di cloud e Remote Control Git e attribuzione Any file
autoCompactEnabled Disattivare o attivare la compattazione automatica Memoria e contesto Any file
autoCompactWindow Impostare quanto pieno il contesto diventa prima che Claude Code compatti Memoria e contesto Any file
autoConnectIde Connettersi automaticamente a un IDE VS Code o JetBrains in esecuzione da un terminale esterno Impostazioni di configurazione globale Global config
autoContinueAtUsageLimit Attendere nella sessione aperta e continuare l'attività automaticamente dopo il ripristino di un limite di utilizzo di claude.ai Interfaccia e terminale User or managed
autoInstallIdeExtension Disattivare l'installazione automatica dell'estensione IDE da un terminale VS Code Impostazioni di configurazione globale Global config
autoMemoryDirectory Archiviare la memoria automatica in una directory a vostra scelta Memoria e contesto Any file
autoMemoryEnabled Disattivare o attivare la memoria automatica Memoria e contesto Any file
autoMode Aggiungere le vostre regole di autorizzazione e negazione al classificatore della modalità automatica Impostazioni di autorizzazione User or managed
autoMode.classifyAllShell Inviare ogni comando shell attraverso il classificatore della modalità automatica, anche quelli che corrispondono a una regola di autorizzazione ristretta Impostazioni di autorizzazione User or managed
autoScrollEnabled Seguire il nuovo output fino in fondo nel rendering a schermo intero Interfaccia e terminale Any file
autoUpdatesChannel Seguire il canale di rilascio stabile invece del più recente Aggiornamenti e versioning Any file
availableModels Limitare quali modelli le persone possono scegliere Modello e risposte Any file
awaySummaryEnabled Disattivare il riepilogo della sessione mostrato quando tornate al terminale Remoto, desktop e notifiche Any file
awsAuthRefresh Aggiornare le credenziali Bedrock scadute in .aws con il vostro comando Autenticazione e provider Any file
awsCredentialExport Fornire le credenziali Bedrock come JSON dal vostro comando Autenticazione e provider Any file
axScreenReader Eseguire il rendering dell'output compatibile con lo screen reader Interfaccia e terminale Any file
bashOutputMaxChars Impostare quanto output di un comando riuscito Claude riceve inline Memoria e contesto Any file
blockedMarketplaces Bloccare le fonti del marketplace dei plugin per la vostra organizzazione Plugin e skill Managed
browserExternalPageTools Mantenere gli strumenti di Claude disattivati sulle pagine esterne nel riquadro desktop Browser Strumenti Managed
channelsEnabled Consentire i canali per la vostra organizzazione Plugin e skill Managed
claudeMd Iniettare le istruzioni CLAUDE.md a livello di organizzazione dalle impostazioni gestite Memoria e contesto Managed
claudeMdExcludes Saltare i file CLAUDE.md specifici quando la memoria si carica Memoria e contesto Any file
cleanupPeriodDays Scegliere quanti giorni Claude Code mantiene i trascritti prima di eliminarli Privacy e telemetria Any file
companyAnnouncements Mostrare gli annunci della vostra organizzazione all'avvio Interfaccia e terminale Any file
copyOnSelect Disattivare la copia automatica del testo selezionato con il mouse nel rendering a schermo intero e nella visualizzazione agente Impostazioni di configurazione globale Global config
crossSessionInbound Scegliere se Claude Code consegna i messaggi dalle vostre altre sessioni, mostra un avviso senza consegnarli, o li rifiuta Agenti, sessioni e worktrees Any file
defaultShell Scegliere se Bash o PowerShell esegue i comandi shell che digitate con il prefisso ! Interfaccia e terminale Any file
deniedMcpServers Bloccare specifici server MCP per URL, comando o nome MCP Any file
desktopSessionCleanupPeriodDays Impostare un limite di età in giorni per i trascritti di Claude Desktop e Cowork Privacy e telemetria User or managed
dialogExpiry Impostare quanto tempo Claude Code attende che Remote Control o un host SDK risponda a una finestra di dialogo inoltrata prima di annullarla Interfaccia e terminale User or managed
diffTool Scegliere se le modifiche ai file proposte da Claude si aprono nel visualizzatore diff di VS Code o JetBrains o rimangono nel terminale Impostazioni di configurazione globale Global config
disableAgentView Disattivare gli agenti in background e la visualizzazione agente Agenti, sessioni e worktrees Any file
disableAllHooks Disattivare gli hook, una riga di stato personalizzata, e un comando di suggerimento file @ personalizzato tutto in una volta Hook e automazione Any file
disableArtifact Deprecato; usare enableArtifact per disattivare lo strumento Artifact Remoto, desktop e notifiche Any file
disableAutoMode Rimuovere la modalità automatica dal ciclo della modalità di autorizzazione Impostazioni di autorizzazione Any file
disableBrowserExternalNavigation Limitare il riquadro desktop Browser a localhost per le persone e Claude Strumenti Managed
disableBundledSkills Disattivare le skill e i workflow inclusi con Claude Code Plugin e skill Any file
disableClaudeAiConnectors Disattivare i connettori claude.ai in modo che Claude Code non li recuperi MCP Any file
disableCommandPluginSources Bloccare i plugin che si installano eseguendo un comando dichiarato dal marketplace Plugin e skill Managed
disableDeepLinkRegistration Impedire a Claude Code di registrare il gestore claude-cli:// Remoto, desktop e notifiche Any file
disableDesktopLocalSessions Disattivare le sessioni Desktop Code che vengono eseguite sul dispositivo, lasciando SSH ad altri host e al cloud Remoto, desktop e notifiche Managed
disabledMcpjsonServers Rifiutare server specifici dal .mcp.json di un progetto MCP Any file
disableMobileSimulatorTools Bloccare gli strumenti di Claude nel riquadro desktop iOS Simulator Strumenti Managed
disableRemoteControl Disattivare Remote Control ovunque possa iniziare Remoto, desktop e notifiche Any file
disableSideloadFlags Rifiutare i flag CLI che caricano lateralmente i plugin, i subagent, e i server MCP Impostazioni aziendali e gestite Managed
disableSkillShellExecution Impedire alle skill e ai comandi personalizzati di eseguire shell inline Plugin e skill Any file
disableWorkflows Disattivare i workflow dinamici per tutti; usare enableWorkflows per voi stessi Hook e automazione Any file
editorMode Usare le scorciatoie da tastiera vim nel prompt di input Interfaccia e terminale Any file
effortLevel Impostare un livello di sforzo predefinito per i modelli senza un livello salvato proprio Modello e risposte Any file
emojiCompletionEnabled Disattivare i suggerimenti e la sostituzione emoji :shortcode: nell'input del prompt Interfaccia e terminale Any file
enableAllProjectMcpServers Approvare ogni server nei file .mcp.json del progetto senza un prompt MCP Any file
enableArtifact Disattivare lo strumento Artifact con un false in qualsiasi file; nessun file può riattivarlo Remoto, desktop e notifiche Any file
enabledMcpjsonServers Approvare server specifici dal .mcp.json di un progetto MCP Any file
enabledPlugins Attivare o disattivare i singoli plugin per scope Plugin e skill Any file
enableWorkflows Attivare o disattivare i workflow dinamici rispetto al valore predefinito del vostro piano Hook e automazione Any file
enforceAvailableModels Mantenere la scelta predefinita di /model all'interno dell'elenco di autorizzazione availableModels Modello e risposte Any file
env Impostare le variabili di ambiente per ogni sessione e i suoi sottoprocessi Memoria e contesto Any file
externalEditorContext Mostrare l'ultima risposta di Claude come commenti quando premete Ctrl+G per modificare Impostazioni di configurazione globale Global config
extraKnownMarketplaces Registrare i marketplace per un repository o un'organizzazione Plugin e skill Any file
fallbackModel Nominare i modelli di backup per quando il primario è sovraccarico Modello e risposte Any file
fastMode Attivare la modalità veloce per le sessioni in cui è disponibile Modello e risposte Any file
fastModePerSessionOptIn Richiedere alle persone di attivare la modalità veloce ogni sessione Modello e risposte Any file
feedbackDrafts Controllare se Claude mette in coda le bozze di feedback per voi da rivedere Privacy e telemetria User or managed
feedbackSurveyRate Modificare la frequenza con cui appare il sondaggio sulla qualità della sessione Privacy e telemetria Any file
fileCheckpointingEnabled Disattivare o attivare gli snapshot di file che /rewind ripristina Memoria e contesto Any file
fileSuggestion Fornire l'autocompletamento file @ dal vostro comando Interfaccia e terminale Any file
footerLinksRegexes Rendere gli ID di problema o revisione nell'output in link cliccabili sotto la casella di input Interfaccia e terminale User or managed
forceLoginGatewayUrl Impostare l'URL del gateway a cui si connette la schermata di accesso Autenticazione e provider Managed
forceLoginMethod Limitare l'accesso a claude.ai, Claude Console, o un gateway cloud Autenticazione e provider Any file
forceLoginOrgUUID Fissare gli accessi a claude.ai alla vostra organizzazione; solo una fonte gestita lo applica Autenticazione e provider Any file
forceRemoteSettingsRefresh Bloccare l'avvio fino a quando le impostazioni gestite dal server non vengono recuperate di recente Impostazioni aziendali e gestite Managed
gcpAuthRefresh Aggiornare le credenziali Google Cloud con il vostro comando Autenticazione e provider Any file
hooks Eseguire i vostri comandi come hook nei punti del ciclo di vita di Claude Code Hook e automazione Any file
httpHookAllowedEnvVars Limitare quali variabili di ambiente gli hook HTTP possono inserire nelle intestazioni Hook e automazione Any file
includeCoAuthoredBy Deprecato; usare attribution per nascondere o modificare l'attribuzione di commit e PR Git e attribuzione Any file
includeGitInstructions Rimuovere le istruzioni di commit e PR integrate dal prompt di sistema Git e attribuzione Any file
inputNeededNotifEnabled Ricevere una notifica push quando Claude sta aspettando voi Remoto, desktop e notifiche Any file
isolatePeerMachines Chiedere prima che Claude messaggi una delle vostre sessioni su un'altra macchina Agenti, sessioni e worktrees Any file
keybindingFlavor Deprecato e non ha effetto; le scorciatoie di modifica delle parole seguono sempre le convenzioni readline Interfaccia e terminale Any file
language Fare in modo che Claude risponda in una lingua diversa dall'inglese Modello e risposte Any file
managedMcpServers Fornire server MCP remoti a ogni utente insieme a quelli che aggiungono MCP Managed
managedSourcesBehavior Comporre ogni fonte gestita che distribuite invece di usare solo quella con la priorità più alta Impostazioni aziendali e gestite Managed
maxEffortLevel Limitare il livello di sforzo per ogni modello o per modello, su ogni provider Modello e risposte Any file
minimumVersion Mantenere gli aggiornamenti automatici dall'installare qualsiasi cosa al di sotto di una versione Aggiornamenti e versioning Any file
model Modificare il modello con cui Claude Code inizia Modello e risposte Any file
modelOverrides Mappare gli ID dei modelli agli ID del vostro provider, come gli ARN di Bedrock Modello e risposte Any file
modelPicker Scegliere quali modelli il selezionatore /model elenca, nel vostro ordine e con le vostre etichette Modello e risposte User or managed
modelPricing Segnalare la spesa alle tariffe contrattuali della vostra organizzazione invece del prezzo di listino Modello e risposte Managed
modelSettings Mantenere un livello di sforzo salvato per modello, o limitare lo sforzo di un modello Modello e risposte Any file
otelHeadersHelper Generare intestazioni OpenTelemetry rotanti con il vostro comando Autenticazione e provider Any file
outputStyle Modificare il ruolo, il tono e il formato di output di Claude con uno stile di output Modello e risposte Any file
parentSettingsBehavior Applicare o eliminare le restrizioni che un host SDK o IDE passa quando distribuite le impostazioni gestite Impostazioni aziendali e gestite Managed
permissionExplainerEnabled Rimosso nella v2.1.257, insieme al comando di spiegazione Ctrl+E sui prompt di autorizzazione shell Impostazioni di configurazione globale Global config
permissions Impostare le regole di autorizzazione, domanda e negazione e la modalità di autorizzazione iniziale Impostazioni di autorizzazione Any file
permissions.additionalDirectories Dare a Claude accesso ai file alle directory al di fuori di quella corrente Impostazioni di autorizzazione Any file
permissions.allow Approvare gli usi dello strumento elencati senza un prompt Impostazioni di autorizzazione Any file
permissions.ask Sempre chiedere prima degli usi dello strumento elencati Impostazioni di autorizzazione Any file
permissions.blockReadsOutsideWorkingDirectories Fare in modo che gli strumenti di file rifiutino le letture al di fuori delle directory di lavoro in ogni modalità di autorizzazione Impostazioni di autorizzazione Any file
permissions.defaultMode Impostare la modalità di autorizzazione in cui iniziano le nuove sessioni Impostazioni di autorizzazione Any file
permissions.deny Bloccare gli usi dello strumento elencati, incluse le letture di file che contengono segreti Impostazioni di autorizzazione Any file
permissions.disableBypassPermissionsMode Impedire a chiunque di entrare nella modalità bypassPermissions Impostazioni di autorizzazione Any file
plansDirectory Scegliere dove la modalità piano scrive i file di piano Memoria e contesto Any file
pluginConfigs Archiviare le risposte che avete dato alla finestra di dialogo di configurazione di un plugin Plugin e skill User or managed
pluginSuggestionMarketplaces Scegliere quali marketplace possono far emergere i suggerimenti di installazione dei plugin in /plugin Plugin e skill Managed
pluginTrustMessage Aggiungere il vostro testo all'avviso di fiducia del plugin Plugin e skill Managed
policyHelper Eseguire un eseguibile che calcola le impostazioni gestite all'avvio Impostazioni aziendali e gestite Managed
policyHelper.path Nominare l'eseguibile helper che Claude Code esegue Impostazioni aziendali e gestite Managed
policyHelper.refreshIntervalMs Eseguire nuovamente l'helper in background a intervalli Impostazioni aziendali e gestite Managed
policyHelper.timeoutMs Impostare quanto tempo Claude Code attende l'helper Impostazioni aziendali e gestite Managed
preferredNotifChannel Scegliere un campanello del terminale o una notifica desktop per il completamento dell'attività Remoto, desktop e notifiche Any file
prefersReducedMotion Ridurre o disattivare le animazioni di spinner, shimmer e flash Interfaccia e terminale Any file
processWrapper Eseguire i processi in background di Claude Code attraverso un launcher aziendale su macOS e Linux Agenti, sessioni e worktrees User or managed
promptCacheTtl Scegliere la durata della cache del prompt per la conversazione principale Modello e risposte Any file
promptSuggestionEnabled Nascondere i suggerimenti di prompt in grigio nella casella di input Interfaccia e terminale Any file
prUrlTemplate Puntare i link PR a uno strumento di revisione del codice interno invece di github.com Git e attribuzione Any file
remote.defaultEnvironmentId Scegliere l'ambiente cloud predefinito per claude --cloud; un ID ccpool_ auto-ospitato è di sola lettura dalle impostazioni utente e gestite e --settings Remoto, desktop e notifiche Any file
remoteControlAtStartup Connettersi a Remote Control automaticamente quando una sessione inizia Remoto, desktop e notifiche Any file
requiredMaximumVersion Rifiutare di avviare su una versione più recente di quella che la vostra organizzazione consente Aggiornamenti e versioning Managed
requiredMinimumVersion Rifiutare di avviare su una versione più vecchia di quella che la vostra organizzazione richiede Aggiornamenti e versioning Managed
respectGitignore Mantenere i file ignorati da git fuori dal selezionatore file @ Interfaccia e terminale Any file
respondToBashCommands Impedire a Claude di rispondere dopo l'esecuzione di un comando shell ! Interfaccia e terminale Any file
sandbox Isolare i comandi Bash dal vostro filesystem e dalla rete su macOS, Linux e WSL2 Impostazioni sandbox Any file
sandbox.allowAppleEvents Consentire ai comandi in sandbox di inviare Apple Events su macOS Impostazioni sandbox User or managed
sandbox.allowUnsandboxedCommands Consentire a Claude di riprovare un comando bloccato al di fuori della sandbox, o vietarlo Impostazioni sandbox Any file
sandbox.autoAllowBashIfSandboxed Eseguire i comandi in sandbox senza un prompt di autorizzazione Impostazioni sandbox Any file
sandbox.bwrapPath Puntare la sandbox a un binario bubblewrap al di fuori di PATH Impostazioni sandbox Managed
sandbox.credentials Nascondere o mascherare i file e le variabili di credenziale all'interno della sandbox Impostazioni sandbox Any file
sandbox.credentials.allowPlaintextInject Consentire alle credenziali mascherate di raggiungere i servizi HTTP semplici su reti di test affidabili Impostazioni sandbox User or managed
sandbox.credentials.awsPairs Collegare le variabili di chiave AWS con nome personalizzato in una credenziale per la ri-firma Impostazioni sandbox User or managed
sandbox.credentials.envVars Annullare o mascherare una variabile di ambiente all'interno della sandbox Impostazioni sandbox Any file
sandbox.credentials.files Bloccare o mascherare le letture di un file di credenziale all'interno della sandbox Impostazioni sandbox Any file
sandbox.credentials.sigv4 Scegliere se le richieste AWS streaming, presigned, o SigV4A falliscono o passano Impostazioni sandbox User or managed
sandbox.enabled Attivare il sandboxing Bash su macOS, Linux e WSL2 Impostazioni sandbox Any file
sandbox.enableWeakerNestedSandbox Eseguire la sandbox Linux all'interno di un contenitore senza privilegi Impostazioni sandbox Any file
sandbox.enableWeakerNetworkIsolation Consentire a gh, gcloud, e terraform di verificare TLS dietro un proxy MITM all'interno della sandbox su macOS Impostazioni sandbox Any file
sandbox.excludedCommands Nominare i comandi che vengono sempre eseguiti al di fuori della sandbox Impostazioni sandbox Any file
sandbox.failIfUnavailable Rifiutare di avviare quando la sandbox non può, invece di eseguire senza sandbox Impostazioni sandbox Any file
sandbox.filesystem Controllare quali percorsi i comandi in sandbox possono leggere e scrivere Impostazioni sandbox Any file
sandbox.filesystem.allowManagedReadPathsOnly Impedire agli sviluppatori di riaprire i percorsi di lettura che la vostra organizzazione ha bloccato Impostazioni sandbox Managed
sandbox.filesystem.allowRead Riaprire la lettura all'interno di una regione che denyRead blocca Impostazioni sandbox Any file
sandbox.filesystem.allowWrite Aggiungere percorsi che i comandi in sandbox possono scrivere Impostazioni sandbox Any file
sandbox.filesystem.denyRead Bloccare i comandi in sandbox dalla lettura di percorsi specifici Impostazioni sandbox Any file
sandbox.filesystem.denyWrite Bloccare i comandi in sandbox dalla scrittura in percorsi specifici Impostazioni sandbox Any file
sandbox.filesystem.disabled Disattivare l'isolamento del filesystem mantenendo l'isolamento della rete Impostazioni sandbox User or managed
sandbox.ignoreViolations Silenziare i rapporti di violazione per i percorsi che un comando dovrebbe sondare Impostazioni sandbox Any file
sandbox.network Controllare quali host, porte e socket i comandi in sandbox raggiungono Impostazioni sandbox Any file
sandbox.network.allowAllUnixSockets Consentire ai comandi in sandbox di connettersi a ogni socket Unix Impostazioni sandbox Any file
sandbox.network.allowedDomains Pre-autorizzare i domini in modo che i comandi in sandbox non chiedano per loro Impostazioni sandbox Any file
sandbox.network.allowLocalBinding Consentire ai comandi in sandbox di associarsi alle porte localhost su macOS Impostazioni sandbox Any file
sandbox.network.allowMachLookup Consentire ai strumenti in sandbox macOS come iOS Simulator o Playwright di raggiungere i loro servizi XPC Impostazioni sandbox Any file
sandbox.network.allowManagedDomainsOnly Bloccare l'elenco di autorizzazione della rete alle impostazioni gestite Impostazioni sandbox Managed
sandbox.network.allowUnixSockets Elencare i percorsi dei socket Unix che i comandi in sandbox possono usare su macOS Impostazioni sandbox Any file
sandbox.network.deniedDomains Bloccare i domini per i comandi in sandbox, anche all'interno di un wildcard consentito Impostazioni sandbox Any file
sandbox.network.httpProxyPort Instradare il traffico HTTP della sandbox attraverso il vostro proxy Impostazioni sandbox Any file
sandbox.network.socksProxyPort Instradare il traffico SOCKS della sandbox attraverso il vostro proxy Impostazioni sandbox Any file
sandbox.network.strictAllowlist Negare gli host al di fuori dell'elenco di autorizzazione invece di chiedere Impostazioni sandbox User or managed
sandbox.network.tlsTerminate Fare in modo che la sandbox proxy termini TLS in modo che possa leggere le richieste HTTPS Impostazioni sandbox User or managed
sandbox.ripgrep Usare il vostro binario ripgrep all'interno della sandbox Impostazioni sandbox User or managed
sandbox.socatPath Puntare il proxy della sandbox a un binario socat al di fuori di PATH Impostazioni sandbox Managed
showClearContextOnPlanAccept Mostrare un'opzione "cancella contesto" sulla schermata di accettazione del piano Interfaccia e terminale Any file
showThinkingSummaries Vedere i riassunti del pensiero di Claude invece di uno stub compresso Modello e risposte Any file
showTurnDuration Nascondere la durata "Cooked for" dopo ogni risposta Interfaccia e terminale Any file
skillListingBudgetFraction Riservare più o meno contesto per l'elenco di skill Memoria e contesto Any file
skillListingMaxDescChars Limitare la lunghezza della descrizione di ogni skill nell'elenco di skill Memoria e contesto Any file
skillOverrides Nascondere o comprimere una skill senza modificare il suo SKILL.md Plugin e skill Any file
skipAutoPermissionPrompt Saltare l'avviso una tantum che Claude Code mostra quando entrate per la prima volta nella modalità automatica voi stessi piuttosto che attraverso il valore predefinito integrato Impostazioni di autorizzazione User or managed
skipDangerousModePermissionPrompt Saltare la finestra di dialogo di conferma prima della modalità bypassPermissions Impostazioni di autorizzazione User, local, or managed
skipWebFetchPreflight Saltare il controllo del nome host WebFetch quando Anthropic non è raggiungibile Privacy e telemetria Any file
spellcheck Sottolineare le parole scritte male nell'input del prompt con un correttore ortografico che installate Interfaccia e terminale User or managed
spinnerTipsEnabled Nascondere i suggerimenti nello spinner mentre Claude lavora Interfaccia e terminale Any file
spinnerTipsOverride Aggiungere i vostri suggerimenti alla rotazione dello spinner, o sostituire i suggerimenti integrati Interfaccia e terminale Any file
spinnerVerbs Aggiungere o sostituire i verbi mostrati mentre un turno viene eseguito Interfaccia e terminale Any file
sshConfigs Aggiungere connessioni SSH al menu a discesa dell'ambiente Desktop Remoto, desktop e notifiche User or managed
sshHostAllowlist Limitare quali host le sessioni SSH Desktop possono raggiungere Remoto, desktop e notifiche Managed
statusLine Eseguire il vostro comando per eseguire il rendering di una riga di stato sotto il prompt Interfaccia e terminale Any file
strictKnownMarketplaces Elenco di autorizzazione delle fonti del marketplace che gli utenti possono aggiungere e installare Plugin e skill Managed
strictPluginOnlyCustomization Bloccare le skill, gli agenti, gli hook, e i server MCP dalle fonti utente e progetto Plugin e skill Managed
strictPluginOnlyCustomization.agents Bloccare gli agenti alle fonti plugin e gestite Plugin e skill Managed
strictPluginOnlyCustomization.hooks Bloccare gli hook alle fonti plugin e gestite Plugin e skill Managed
strictPluginOnlyCustomization.mcp Bloccare i server MCP alle fonti plugin e gestite Plugin e skill Managed
strictPluginOnlyCustomization.skills Bloccare le skill alle fonti plugin e gestite Plugin e skill Managed
subagentPromptCacheTtl Scegliere la durata della cache del prompt per i subagent e altre richieste al di fuori della conversazione principale Modello e risposte Any file
subagentStatusLine Riscrivere le righe nella visualizzazione del subagent con il vostro comando Interfaccia e terminale Any file
switchModelsOnFlag Cambiare i modelli automaticamente o mettere in pausa quando un classificatore di sicurezza contrassegna una richiesta Modello e risposte Any file
syncClaudeAiSkills Smettere di scaricare le skill abilitate sul vostro account claude.ai e nascondere quelle già sincronizzate Plugin e skill User, local, or managed
syntaxHighlightingDisabled Disattivare l'evidenziazione della sintassi nei diff e nei blocchi di codice Interfaccia e terminale Any file
taskOutputMaxChars Impostare quanto output di un compito in background Claude riceve inline Memoria e contesto Any file
teammateDefaultModel Rimosso nella v2.1.234; vedere Specificare i compagni di squadra e i modelli per come Claude Code sceglie il modello di un compagno di squadra Impostazioni di configurazione globale Global config
teammateMode Scegliere come i compagni di squadra del team di agenti vengono visualizzati Agenti, sessioni e worktrees Any file
terminalProgressBarEnabled Nascondere la barra di avanzamento del terminale nei terminali che la supportano Interfaccia e terminale Any file
terminalTitleFromRename Impedire a /rename e --name di modificare il titolo della scheda del terminale Interfaccia e terminale Any file
theme Scegliere il tema colore dell'interfaccia, integrato o personalizzato Interfaccia e terminale Any file
timeFormat Mostrare i tempi nell'interfaccia su un orologio a 12 ore o 24 ore, in UTC, o con un modello strftime Interfaccia e terminale Any file
timeZone Mostrare i tempi nell'interfaccia in un fuso orario diverso da quello del vostro sistema Interfaccia e terminale Any file
tui Scegliere il renderer fullscreen o terminale classico Interfaccia e terminale Any file
ultracode Fare in modo che Claude pianifichi un workflow per ogni compito sostanziale senza essere chiesto Modello e risposte Any file
useAutoModeDuringPlan Consentire al classificatore della modalità automatica di rivedere i comandi shell nella modalità piano; impostare false per ottenere i prompt invece Impostazioni di autorizzazione User, local, or managed
verbose Mostrare l'output completo dello strumento invece dei riassunti troncati; viewMode ha la precedenza quando entrambi sono impostati Interfaccia e terminale Any file
viewMode Avviare ogni sessione nella visualizzazione predefinita, dettagliata o focalizzata Interfaccia e terminale Any file
vimInsertModeRemaps Mappare una sequenza in modalità INSERT a due tasti come jj a Escape Interfaccia e terminale User or managed
voice Attivare la dettatura vocale e scegliere la modalità di mantenimento o tocco Interfaccia e terminale Any file
voiceEnabled Attivare la dettatura vocale con il modulo a chiave singola più vecchio Interfaccia e terminale Any file
wheelScrollAccelerationEnabled Disattivare l'accelerazione della rotella del mouse nel rendering a schermo intero Interfaccia e terminale Any file
workflowKeywordTriggerEnabled Consentire alla parola ultracode in un prompt di avviare un workflow; impostare false per digitarla senza avviarne uno Hook e automazione Any file
workflowSizeGuideline Impostare il numero di agenti che Claude mira in workflow dinamici Hook e automazione Any file
worktree Configurare come Claude Code crea git worktrees Agenti, sessioni e worktrees Any file
worktree.baseRef Creare un ramo dei nuovi worktrees dal ramo predefinito remoto o dal vostro HEAD locale Agenti, sessioni e worktrees Any file
worktree.bgIsolation Consentire alle sessioni in background di modificare la copia di lavoro senza un worktree Agenti, sessioni e worktrees Any file
worktree.sparsePaths Estrarre solo le directory di cui avete bisogno in ogni worktree Agenti, sessioni e worktrees Any file
worktree.symlinkDirectories Creare symlink delle directory di grandi dimensioni in ogni worktree invece di duplicarle Agenti, sessioni e worktrees Any file
wslInheritsWindowsSettings Fare in modo che WSL legga le impostazioni gestite dalla catena di criteri di Windows Impostazioni aziendali e gestite Managed

Modello e risposte

Scegliere quali modelli Claude Code utilizza e come risponde. Per informazioni su come queste impostazioni interagiscono con il comando /model e le variabili di ambiente, vedere Configurazione del modello.

`advisorModel`

Scegliere quale modello risponde quando Claude chiama lo strumento advisor lato server. Lasciarlo non impostato per disattivare l'advisor. L'advisor deve essere almeno altrettanto capace del modello principale; quando non lo è, Claude Code invia richieste senza l'advisor. Vedere Scegliere un modello advisor.

Di solito non si modifica questa chiave manualmente. Eseguire /advisor per aprire un selettore che mostra la scelta corrente, i modelli che possono fornire consulenza e No advisor. Claude Code salva la scelta in questa chiave in ~/.claude/settings.json. Se si sceglie da un client Remote Control o in una sessione collegata a un worker remoto, la scelta si applica solo a quella sessione e non modifica questa chiave.

Se l'account richiede il consenso usage-credits, accettarlo prima eseguendo /model fable. Fino a quando non lo si fa, scegliere Fable in /advisor non salva nulla e Claude Code comunica di eseguire prima /model fable.

  • Scope: Any file
  • Type: string, uno degli alias "fable", "opus" o "sonnet", che si risolvono nella versione predefinita corrente di Claude Code di quella famiglia di modelli, oppure un ID modello completo come "claude-opus-5"
  • Default: non impostato, quindi l'advisor è disattivato
  • Per-session overrides: --advisor ha la precedenza su questa chiave per una sessione. CLAUDE_CODE_DISABLE_ADVISOR_TOOL disattiva l'advisor e questa chiave non può riattivarlo
{
  "advisorModel": "opus"
}

La chiave non ha effetto su provider dove l'advisor non è disponibile, come Amazon Bedrock e Claude Platform su AWS. "fable" richiede accesso a Fable.

`alwaysThinkingEnabled`

Disattivare il pensiero esteso per ogni sessione impostando questo su false. Il pensiero è attivato per impostazione predefinita, quindi true non cambia nulla. La maggior parte delle persone imposta questo tramite /config piuttosto che modificando il file.

Su modelli che pensano sempre, come i modelli Fable, false non ha effetto. Su provider di terze parti Claude Code omette il parametro thinking invece di disattivare il pensiero, quindi i modelli di ragionamento adattivo potrebbero comunque pensare. Con il pensiero disattivato sull'API Anthropic, Claude Code invia effort high invece di un livello superiore ai modelli che sa non accettano quella combinazione, come Opus 5.

  • Scope: Any file
  • Type: Boolean
    • true: nessun effetto; il pensiero è già attivato
    • false: Claude Code disattiva il pensiero esteso per ogni sessione
  • Default: non impostato, quindi il pensiero è attivato per i modelli che lo supportano
  • Per-session overrides: MAX_THINKING_TOKENS ha la precedenza su questa chiave per una sessione: 0 disattiva il pensiero, con gli stessi limiti di modello e provider di false, e un valore positivo attiva il pensiero anche quando questa chiave è false. Su modelli di ragionamento adattivo il numero stesso viene ignorato
{
  "alwaysThinkingEnabled": false
}

`availableModels`

Limitare quali modelli le persone possono selezionare per la sessione principale, subagenti, skills e l'advisor. Un elenco gestito vincola /model, --model e la chiave model nei file propri dello sviluppatore; un modello al di fuori di esso non può essere selezionato. Di per sé questo non tocca l'opzione Default; abbinarlo a enforceAvailableModels per quello.

  • Scope: Any file. Distribuirlo nelle impostazioni gestite per applicarlo a un'organizzazione.
  • Type: array di alias di modelli o ID
  • Default: non impostato, quindi ogni modello è disponibile

Questo esempio consente alle persone di selezionare solo modelli Sonnet e Haiku:

{
  "availableModels": ["sonnet", "haiku"]
}

Vedere Limitare la selezione del modello.

`effortLevel`

Impostare un livello di effort predefinito per i modelli per i quali non è stato salvato un livello. I livelli inferiori sono più veloci e meno costosi su compiti semplici, e i livelli superiori ragionano più profondamente su problemi complessi.

Quando si esegue /effort low, medium, high o xhigh in una sessione interattiva sulla propria macchina, Claude Code salva il livello per il modello attivo sotto modelSettings piuttosto che scrivere questa chiave. Prima della v2.1.251, /effort scriveva questa chiave.

All'interno dello stesso file di impostazioni, Claude Code utilizza il livello salvato di un modello piuttosto che questa chiave. modelSettings indica la precedenza tra file.

In una sessione collegata a un worker remoto, /effort si applica solo a quella sessione. In un'esecuzione -p o nell'Agent SDK si applica anche solo a quella sessione, a meno che non sia in vigore un blocco sul livello di effort predefinito del modello. Regolare il livello di effort elenca le scelte interattive che si applicano anche solo a quella sessione. Il messaggio che /effort stampa dice quale è accaduto.

  • Scope: Any file
  • Type: string, uno di:
    • "low": il ragionamento minimo, per compiti brevi, circoscritti, sensibili alla latenza che non sono sensibili all'intelligenza
    • "medium": riduce l'utilizzo di token per il lavoro sensibile ai costi che può scambiare un po' di intelligenza
    • "high": bilancia l'utilizzo di token e l'intelligenza
    • "xhigh": ragionamento più profondo con spesa di token più elevata
  • Default: non impostato
  • Per-session overrides: --effort ha la precedenza su questa chiave per una sessione, e CLAUDE_CODE_EFFORT_LEVEL ha la precedenza su entrambi
{
  "effortLevel": "xhigh"
}

Su Opus 4.7, Opus 4.8 e Fable 5, Claude Code mantiene il livello di effort predefinito di quel modello, impostato dall'organizzazione o integrato; Regolare il livello di effort indica quali modi di impostare un livello terminano il blocco e quali lo mantengono in vigore. Una volta che il blocco termina, Claude Code risolve l'effort secondo la precedenza indicata in modelSettings.

`enforceAvailableModels`

Il selettore /model ha un'opzione Default che si risolve nel modello predefinito dell'organizzazione quando uno si applica, e altrimenti al predefinito del tipo di account. Un elenco availableModels limita i modelli che è possibile nominare, ma di per sé lascia Default da solo, quindi Default può comunque risolversi in un modello al di fuori dell'elenco. Questa chiave colma quel divario. Richiede Claude Code v2.1.175 o successivo.

Quando l'organizzazione distribuisce impostazioni gestite, Claude Code legge questa chiave solo dalla fonte gestita e la ignora negli altri file.

  • Scope: Any file
  • Type: Boolean
    • true: quando Default si risolverebbe in un modello al di fuori di availableModels, Claude Code lo risolve nel primo modello disponibile nell'elenco
    • false: Default si risolve come al solito, anche in un modello al di fuori di availableModels
  • Default: false

Questo esempio limita le selezioni nominate ai modelli Sonnet e Haiku e fa sì che Default si risolva nel primo di essi disponibile:

{
  "availableModels": ["sonnet", "haiku"],
  "enforceAvailableModels": true
}

Questa chiave non ha effetto quando availableModels non è impostato o è vuoto. Vedere Applicare l'elenco consentito al modello Default. Richiede Claude Code v2.1.175 o successivo.

`fallbackModel`

Nominare modelli di backup per Claude Code da provare, in ordine, quando il modello principale è sovraccarico o non disponibile. Claude Code passa al modello disponibile successivo nella catena per il resto del turno e mostra un avviso. Senza una catena, Claude Code ritenta lo stesso modello e quindi visualizza l'errore del server, e si ritenta o si cambiano i modelli manualmente.

Un cambio significa un turno con una prompt cache fredda sul modello di fallback; il messaggio successivo ritenta il modello principale per primo.

  • Scope: Any file
  • Type: array di alias di modelli o ID; "default" si espande al modello predefinito
  • Default: non impostato, quindi una richiesta non riuscita non viene ritentata su un altro modello
  • Per-session overrides: --fallback-model ha la precedenza su questa chiave per una sessione

Questo esempio prova Sonnet 5 per primo, poi Haiku 4.5, quando il modello principale non riesce:

{
  "fallbackModel": ["claude-sonnet-5", "claude-haiku-4-5"]
}

A differenza della maggior parte delle impostazioni di array, questa chiave non si unisce tra file di impostazioni: il file con la precedenza più alta che la definisce fornisce l'intera catena. Se il file del progetto imposta ["claude-sonnet-5"] e il file dell'utente imposta ["claude-haiku-4-5"], la catena è solo ["claude-sonnet-5"]. Claude Code mantiene al massimo tre modelli consentiti distinti dall'elenco e ignora il resto. Vedere Catene di modelli di fallback.

`fastMode`

Attivare la modalità veloce per sessioni dove è disponibile, per il lavoro interattivo come l'iterazione rapida o il debug dal vivo dove si desidera velocità a un costo più elevato per token. Di solito non si modifica questa chiave manualmente: eseguire /fast scrive fastMode: true in ~/.claude/settings.json, e eseguirlo di nuovo per disattivare la modalità veloce rimuove la chiave. La modalità veloce funziona solo su Opus 5 e Opus 4.8: attivarla da un altro modello passa a Opus, e passare a un modello non supportato la disattiva. Vedere Cambiare modelli mentre la modalità veloce è attiva.

  • Scope: Any file
  • Type: Boolean
    • true: Claude Code attiva la modalità veloce per sessioni dove è disponibile
    • false: la modalità veloce rimane disattivata
  • Default: non impostato, quindi la modalità veloce è disattivata
  • Per-session overrides: CLAUDE_CODE_DISABLE_FAST_MODE disattiva la modalità veloce per una sessione, e questa chiave non può riattivarlo
{
  "fastMode": true
}

`fastModePerSessionOptIn`

Normalmente, eseguire /fast salva fastMode nelle impostazioni utente di una persona, quindi la modalità veloce è attiva all'inizio di ogni sessione successiva. Impostare questa chiave su true per fermare questo: un fastMode: true salvato non attiva più la modalità veloce all'inizio della sessione, e ogni persona deve eseguire /fast in ogni sessione in cui la desidera. Claude Code lascia la chiave fastMode nel file, quindi disattivare questa chiave ripristina il comportamento precedente. I proprietari su piani Team o Enterprise possono distribuirlo a livello di organizzazione tramite impostazioni gestite dal server.

  • Scope: Any file
  • Type: Boolean
    • true: un fastMode: true salvato non attiva più la modalità veloce all'inizio della sessione, quindi ogni persona esegue /fast in ogni sessione in cui la desidera; un fastMode: true passato con --settings conta comunque per quella sessione a meno che le impostazioni gestite non impostino questa chiave
    • false: un fastMode: true salvato attiva la modalità veloce all'inizio di ogni sessione successiva
  • Default: false
{
  "fastModePerSessionOptIn": true
}

Vedere Richiedere il consenso per sessione.

`language`

Fare in modo che Claude risponda in una lingua diversa dall'inglese per impostazione predefinita. Non esiste un elenco fisso per le risposte: Claude Code aggiunge il valore verbatim al prompt di sistema come istruzione per rispondere sempre in quella lingua, quindi qualsiasi nome di lingua che Claude può leggere funziona. Claude Code non controlla il valore, quindi un nome scritto male raggiunge Claude così come scritto piuttosto che produrre un errore. Lo stesso valore imposta la lingua per la dettatura vocale, che ha un elenco fisso di lingue di dettatura supportate, e per i titoli di sessione generati automaticamente.

  • Scope: Any file
  • Type: string, qualsiasi nome di lingua, come "japanese", "spanish" o "french"; Claude Code non lo convalida
  • Default: non impostato; i titoli di sessione corrispondono quindi alla lingua della conversazione
{
  "language": "japanese"
}

`maxEffortLevel`

Limitare il livello di effort che una sessione può utilizzare, lasciando disponibili i livelli inferiori. Qualsiasi livello superiore funziona al limite, incluso uno da /effort, il selettore /model, --effort, CLAUDE_CODE_EFFORT_LEVEL, il frontmatter effort di una skill o subagente, o il predefinito del modello stesso. Claude Code applica il limite stesso prima di ogni richiesta, quindi vale su ogni provider, inclusi Amazon Bedrock, Google Cloud's Agent Platform e Microsoft Foundry. Richiede Claude Code v2.1.267 o successivo.

  • Scope: Any file. Distribuirlo nelle impostazioni gestite per applicarlo a un'organizzazione. Quando più scope impostano un limite, si applica il più basso, quindi un limite impostato in uno scope non può essere aumentato da un altro
  • Type: string, uno di "low", "medium", "high", "xhigh" o "max". Un valore "max" non imposta alcun limite
  • Default: non impostato, quindi non si applica alcun limite
  • Effect on ultracode: un limite inferiore a xhigh rende ultracode non disponibile sui modelli a cui si applica il limite
  • Per-model caps: aggiungere maxEffortLevel alla voce modelSettings di un modello. Quella voce sostituisce questa chiave solo per il modello all'interno della fonte di impostazioni che imposta entrambi, come le impostazioni utente o una fonte gestita. Impostare "max" lì per esentare il modello dal limite di quella fonte; Claude Code applica comunque i limiti da altre fonti

Questo esempio limita ogni modello a medium ed esenenta Sonnet 4.6:

{
  "maxEffortLevel": "medium",
  "modelSettings": {
    "claude-sonnet-4-6": {
      "maxEffortLevel": "max"
    }
  }
}

Quando l'organizzazione imposta anche un limite di effort per un modello, si applica il limite inferiore dei due.

`model`

Impostare il modello che ogni nuova sessione utilizza, quindi non è necessario sceglierne uno con /model ogni volta. Impostarlo qui non impedisce di cambiare modello a metà sessione. Se l'amministratore ha impostato un modello predefinito dell'organizzazione per ignorare la selezione dell'utente, si ottiene quel modello anche quando si imposta questa chiave nelle impostazioni utente, progetto o locali.

  • Scope: Any file
  • Type: string, un alias di modello o ID modello completo
  • Default: non impostato, quindi Claude Code utilizza il modello predefinito dell'account
  • Per-session overrides: --model ha la precedenza su ANTHROPIC_MODEL, e entrambi hanno la precedenza su questa chiave per una sessione, incluso su un model gestito; un elenco availableModels si applica comunque alla scelta
{
  "model": "claude-sonnet-5"
}

Un valore qui supera ANTHROPIC_DEFAULT_MODEL, che Claude Code utilizza solo quando nient'altro seleziona un modello.

`modelOverrides`

Mappare gli ID dei modelli Anthropic agli ID dei modelli specifici del provider, come gli ARN del profilo di inferenza di Amazon Bedrock. Ogni voce del selettore di modelli utilizza quindi il suo valore mappato quando chiama l'API del provider. Gli amministratori lo utilizzano su Amazon Bedrock, Google Cloud's Agent Platform e Microsoft Foundry per instradare ogni versione del modello a un profilo di inferenza specifico, nome di versione o distribuzione per governance, allocazione dei costi o instradamento regionale.

  • Scope: Any file
  • Type: object che mappa l'ID del modello all'ID del modello del provider
  • Default: non impostato

Questo esempio instrada ogni chiamata per Opus 4.6 al profilo di inferenza Bedrock denominato:

{
  "modelOverrides": {
    "claude-opus-4-6": "arn:aws:bedrock:us-east-1:123456789012:inference-profile/example"
  }
}

Vedere Ignorare gli ID dei modelli per versione.

`modelPicker`

Elencare i modelli che il selettore /model offre, nell'ordine in cui li si scrive e sotto le etichette che si scelgono, quindi il selettore elenca i modelli che l'organizzazione esegue, dopo la lineup integrata o al suo posto. Il model di ogni riga viene preso verbatim, quindi accetta qualsiasi cosa accetti --model: un alias come opus, un ID modello Anthropic, o un ID in formato provider per Amazon Bedrock, Google Cloud's Agent Platform, Microsoft Foundry, o un gateway LLM. Richiede Claude Code v2.1.242 o successivo.

  • Scope: User or managed. Claude Code legge la chiave dalle impostazioni gestite, --settings e impostazioni utente, e la ignora nelle impostazioni progetto e locali quindi un repository che si clona non può rietichettare il selettore. Il più alto dei tre che imposta la chiave fornisce l'intera lineup, e Claude Code non combina mai lineup da due fonti.
  • Type: object con un array options di righe e un Boolean replaceBuiltInOptions opzionale
  • Default: non impostato, quindi il selettore mostra la lineup integrata

Questo esempio aggiunge due distribuzioni Bedrock dopo la lineup integrata, sotto nomi che il team riconosce:

{
  "modelPicker": {
    "options": [
      { "model": "us.anthropic.claude-opus-4-8", "label": "Opus (production)" },
      {
        "model": "us.anthropic.claude-sonnet-4-6",
        "label": "Sonnet (production)",
        "description": "Day-to-day work"
      }
    ]
  }
}

Campi per `modelPicker`

La chiave accetta due campi, uno per le righe stesse e uno per se sostituiscono la lineup integrata o la aggiungono.

Field Type What it does
options array di righe, ognuna con un model obbligatorio e un label e description opzionali Le righe che il selettore mostra, in questo ordine, tranne che una riga disattivata si sposta in fondo. Senza un label, Claude Code intitola la riga con il nome integrato per un modello che conosce, o l'ID del modello altrimenti, e senza una description scrive una seconda riga generica
replaceBuiltInOptions Boolean, default false Impostarlo su true per mostrare solo queste righe, Default e una riga per il modello che la sessione sta già utilizzando. Lasciarlo non impostato per aggiungere queste righe dopo la lineup integrata

Con replaceBuiltInOptions attivato, Claude Code nasconde ogni altra riga: la lineup integrata, le righe che aggiunge per le voci availableModels, i modelli che la scoperta del gateway ha trovato, e ANTHROPIC_CUSTOM_MODEL_OPTION. Con esso disattivato, Claude Code salta un modello elencato che la lineup integrata copre già. Un'etichetta cambia ciò che il selettore mostra, non quale modello Claude Code esegue.

Un elenco availableModels si applica comunque a queste righe. Prima di aggiungere un modello elencato all'elenco consentito, leggere Comportamento di unione: un ID modello specifico restringe la voce wildcard della sua famiglia. Claude Code controlla anche ogni riga rispetto alla sessione prima di mostrare il selettore:

  • Dropped: una riga che Claude Code non può servire, come un modello ritirato o un modello a cui l'organizzazione non ha accesso
  • Grayed out: una riga che non è possibile selezionare ancora, mostrata con il motivo
  • No row survives: Claude Code mantiene la lineup integrata, filtrata dall'elenco consentito come al solito

Claude Code elimina una riga che non può analizzare e mantiene il resto. Vedere Correggere un file di impostazioni rotto.

`modelPricing`

Segnalare la spesa alle tariffe che l'organizzazione paga invece del prezzo di listino. Impostarlo quando l'organizzazione ha tariffe contrattuali, quindi le cifre in dollari che gli sviluppatori vedono corrispondono alla fattura. Claude Code applica le tariffe in /usage, la riga di stato, l'total_cost_usd dell'Agent SDK, il limite --max-budget-usd e la metrica di costo OpenTelemetry e gli eventi. Si forniscono le tariffe: Claude Code non le legge dal contratto o dalla Claude Console. Richiede Claude Code v2.1.242 o successivo.

  • Scope: Managed. Distribuire la chiave tramite impostazioni gestite dal server, una politica MDM, un file managed-settings.json o un helper di politica. Claude Code la ignora nelle impostazioni utente, progetto e locali, in --settings e su Windows nel registro HKCU scrivibile dall'utente. Con impostazioni gestite dal server, ogni sessione segnala i costi al prezzo di listino fino a quando il fetch delle impostazioni di quella sessione non ha confermato l'impostazione. Un'applicazione host che incorpora Claude Code e imposta CLAUDE_CODE_PROVIDER_MANAGED_BY_HOST può fornire una tabella propria tramite l'opzione SDK managedSettings, che Claude Code utilizza solo quando nessuna fonte gestita imposta la chiave e solo in Claude Code v2.1.246 o successivo.
  • Type: object con un multiplier opzionale e una mappa overrides opzionale
  • Default: non impostato, quindi Claude Code segnala il prezzo di listino a meno che un'applicazione host non fornisca una tabella

Questo esempio imposta tariffe contrattuali per Sonnet 4.6 e quindi riduce ogni cifra, la riga Sonnet inclusa, del 15%. Impostare multiplier da solo per uno sconto fisso, overrides da solo per tariffe per modello, o entrambi:

{
  "modelPricing": {
    "multiplier": 0.85,
    "overrides": {
      "claude-sonnet-4-6": {
        "input": 2.4,
        "output": 12,
        "cacheRead": 0.24,
        "cacheWrite": 3
      }
    }
  }
}

Per i passaggi, incluso come confermare che le tariffe sono in vigore, vedere Segnalare la spesa alle tariffe contrattuali.

Campi per `modelPricing`

Field Type What it does
multiplier numero maggiore di 0 e al massimo 1 Scala ogni costo che Claude Code calcola, indipendentemente dal fatto che una riga overrides lo copra
overrides mappa di ID modello a un oggetto di tariffa con input, output, cacheRead e cacheWrite, ognuno da 0 a 10000 Le tariffe USD-per-milione-token per quel modello, tutti e quattro obbligatori. cacheWrite copre sia le scritture della cache di cinque minuti che di un'ora. Vedere Quali modelli si applica una riga modelPricing

Claude Code utilizza le tariffe di una riga esattamente come le si è scritte, senza aggiungere il supplemento della modalità veloce o la tariffa di inferenza solo negli Stati Uniti. Se si imposta anche multiplier, Claude Code lo applica in aggiunta alle tariffe della riga. Claude Code elimina una riga con una tariffa che non può analizzare, o un multiplier che non può analizzare, e mantiene il resto; vedere Correggere un file di impostazioni rotto.

Quali modelli si applica una riga `modelPricing`

Claude Code decide quali modelli si applica una riga dalla chiave della riga:

  • L'ID di un modello integrato: una chiave che Claude Code stesso utilizza per un modello integrato, indipendentemente dal fatto che quella chiave sia l'ID del modello stesso, come claude-sonnet-4-6, o il suo ID Bedrock, Agent Platform o Foundry. Claude Code applica la riga a ogni ID snapshot datato e ID specifico del provider di quel modello.
  • Qualsiasi altra chiave: una chiave che non è l'ID di un modello integrato, come un alias di modello gateway. Claude Code applica la riga solo a quell'ID. Quando un ID modello corrisponde esattamente a una delle chiavi e rientra anche in una riga con chiave dall'ID di un modello integrato, Claude Code utilizza la corrispondenza esatta.
  • Un profilo di inferenza dell'applicazione Bedrock: una volta che Claude Code ha risolto il profilo al modello a cui instrada, tramite la mappa modelOverrides o la ricerca bedrock:GetInferenceProfile, Claude Code applica la riga di quel modello al profilo.

`modelSettings`

Salvare un livello di effort per ogni modello che si utilizza. In una sessione interattiva sulla propria macchina, quando si salva low, medium, high o xhigh come predefinito con /effort o il cursore di effort del selettore /model, Claude Code scrive quel livello qui sotto il modello che si sta utilizzando, quindi raramente si modifica questa chiave manualmente. La voce effortLevel elenca le sessioni dove /effort si applica solo a quella sessione. Richiede Claude Code v2.1.251 o successivo.

Modificare la chiave manualmente per cambiare o rimuovere un livello salvato.

Un effortLevel di un modello qui ha la precedenza sul effortLevel di livello superiore nello stesso file di impostazioni. Tra file, Claude Code risolve ogni modello separatamente: il file di impostazioni con la precedenza più alta che imposta un effortLevel per quel modello o il effortLevel di livello superiore decide, quindi un effortLevel nelle impostazioni gestite supera un livello salvato nelle impostazioni utente. Regolare il livello di effort elenca cos'altro può ignorare un livello salvato, come --effort al lancio.

Per limitare l'effort di un modello piuttosto che impostare il suo livello, aggiungere un campo maxEffortLevel alla voce modelSettings di quel modello. Il campo richiede Claude Code v2.1.267 o successivo.

  • Scope: Any file
  • Type: object che mappa un nome di modello a un object con un campo effortLevel, uno di "low", "medium", "high" o "xhigh", un campo maxEffortLevel o entrambi
  • Default: non impostato

Claude Code scrive ogni voce sotto il nome canonico del modello, come claude-opus-5, e corrisponde all'alias di quel modello, con suffisso di data, [1m] e ID specifici del provider riconosciuti alla stessa voce.

Questo esempio mantiene Opus 5 a medium mentre altri modelli utilizzano i loro livelli salvati o predefiniti:

{
  "modelSettings": {
    "claude-opus-5": {
      "effortLevel": "medium"
    }
  }
}

Eseguire /effort auto per cancellare il livello salvato per il modello che si sta utilizzando. Claude Code lascia le altre voci e qualsiasi effortLevel di livello superiore in vigore.

`outputStyle`

Selezionare uno stile di output per nome. Uno stile di output è un insieme salvato di istruzioni che cambia il ruolo, il tono e il formato di output di Claude, come gli stili Explanatory e Learning integrati o uno che si è scritto.

Se si cambia questa chiave durante una sessione, Claude utilizza il nuovo stile a partire dal messaggio successivo. Per il costo di quella cache di prompt, vedere Cambiare lo stile di output. Prima della v2.1.251, la modifica si applicava solo dopo aver eseguito /clear o avviato una nuova sessione.

  • Scope: Any file
  • Type: string, il nome di uno stile di output integrato o personalizzato
  • Default: non impostato, quindi Claude Code utilizza lo stile predefinito

Questo esempio seleziona lo stile Explanatory integrato, che aggiunge approfondimenti educativi tra i compiti:

{
  "outputStyle": "Explanatory"
}

`promptCacheTtl`

Scegliere quanto tempo la prompt cache mantiene la conversazione principale. Questa chiave si applica ai turni interattivi, -p e Agent SDK, insieme agli helper che Claude Code esegue inline con essi. La durata di un'ora mantiene la cache calda durante pause più lunghe, e l'API fattura ogni scrittura della cache a una tariffa più elevata rispetto alla durata di cinque minuti. Richiede Claude Code v2.1.242 o successivo.

Questo esempio mantiene la conversazione principale sulla durata di un'ora e lascia i subagenti su cinque minuti:

{
  "promptCacheTtl": "1h",
  "subagentPromptCacheTtl": "5m"
}

Per il costo di ogni durata, vedere Durata della cache.

`showThinkingSummaries`

Vedere i riassunti del pensiero esteso di Claude nelle sessioni interattive. Impostarlo se si desidera i riassunti completi quando si espande il pensiero con Ctrl+O. Quando non impostato o false, l'API Anthropic redige i blocchi di pensiero e Claude Code mostra uno stub compresso; i provider di terze parti non redigono.

  • Scope: Any file
  • Type: Boolean
    • true: si vedono i riassunti completi del pensiero quando si espande il pensiero con Ctrl+O
    • false: l'API Anthropic redige i blocchi di pensiero e Claude Code mostra uno stub compresso
  • Default: false
{
  "showThinkingSummaries": true
}

La redazione cambia solo ciò che si vede, non ciò che il modello genera. Per ridurre la spesa di pensiero, abbassare il budget o disattivare il pensiero invece.

`subagentPromptCacheTtl`

Scegliere quanto tempo la prompt cache mantiene le richieste che Claude Code effettua al di fuori della conversazione principale. Questa chiave si applica a subagenti, workflows e le richieste di background e helper proprie di Claude Code, come la compattazione e i titoli di sessione. La durata di un'ora mantiene la cache calda durante pause più lunghe, e l'API fattura ogni scrittura della cache a una tariffa più elevata rispetto alla durata di cinque minuti. Richiede Claude Code v2.1.242 o successivo.

Questo esempio fornisce ai subagenti e alle altre richieste al di fuori della conversazione principale la durata di un'ora:

{
  "subagentPromptCacheTtl": "1h"
}

Questa chiave copre le richieste che promptCacheTtl non copre, quindi impostare entrambi per scegliere una durata per ogni richiesta che Claude Code effettua. Per come la cache di un subagente differisce da quella della conversazione principale, vedere Subagenti e la cache.

`switchModelsOnFlag`

Scegliere cosa accade quando un classificatore di sicurezza contrassegna una richiesta: passare al modello di fallback e continuare, o mettere in pausa in modo da poter scegliere tra passare e modificare il prompt.

  • Scope: Any file. Appare in /config come Switch models when a message is flagged.
  • Type: Boolean
    • true: Claude Code passa al modello di fallback e continua
    • false: in una sessione interattiva Claude Code mette in pausa in modo da poter scegliere tra passare e modificare il prompt; dove nessuna finestra di dialogo può mostrare, come un'esecuzione -p, la richiesta contrassegnata termina come errore
  • Default: true, passa automaticamente
{
  "switchModelsOnFlag": false
}

Vedere Chiedere prima di passare.

`ultracode`

Avviare sessioni con ultracode attivato. Con esso attivato, Claude pianifica un workflow per ogni compito sostanziale invece di aspettare che lo si chieda. Claude pianifica workflow solo quando i workflow dinamici sono abilitati per l'utente, il modello supporta xhigh effort, e nessun limite di effort inferiore a xhigh si applica. In ogni caso, ultracode: true esegue la sessione a xhigh effort, o al limite quando un limite di effort è inferiore. Claude Code legge questa chiave ma non la scrive mai: /effort ultracode attiva ultracode solo per la sessione corrente.

  • Scope: Any file
  • Type: Boolean
    • true: le sessioni iniziano a xhigh effort, con ultracode attivato quando i workflow dinamici sono abilitati per l'utente, il modello supporta xhigh e nessun limite di effort è inferiore a xhigh
    • false: le sessioni iniziano con ultracode disattivato
  • Default: non impostato, quindi ultracode è disattivato
  • Per-session overrides: /effort ultracode attiva ultracode per una sessione senza questa chiave. Lo fa anche --effort ultracode, che richiede Claude Code v2.1.203 o successivo
{
  "ultracode": true
}

Ultracode esegue la sessione a xhigh effort e ha la precedenza su effortLevel e voci modelSettings. Se un limite di effort inferiore a xhigh si applica al modello, come un'impostazione maxEffortLevel, la sessione funziona al limite e ultracode rimane disattivato. Claude quindi non pianifica workflow da solo, e /effort non offre ultracode. Una richiesta di controllo apply_flag_settings dell'Agent SDK accetta anche la chiave.

Impostazioni di autorizzazione

Decidi cosa Claude può fare senza chiedere, quale modalità di autorizzazione una sessione inizia e cosa consente il classificatore della modalità automatica. Per la sintassi delle regole e il modello di autorizzazione, vedere Configurare le autorizzazioni.

`allowManagedPermissionRulesOnly`

Rendi le impostazioni gestite l'unica fonte di impostazioni delle regole di autorizzazione. Claude Code ignora quindi le regole allow, ask e deny nei file utente, progetto, locale e --settings, ignora --allowedTools, nasconde le scelte sempre-consenti nei prompt di autorizzazione e smette di salvare nuove regole.

Quando le impostazioni padre da un host di incorporamento si applicano, Claude Code le tratta come parte del livello gestito: mantiene le loro regole deny e ask e scarta le loro regole allow e additionalDirectories.

Le regole --disallowedTools e le regole deny e ask della sessione corrente si applicano ancora, anche dopo che Claude Code ricarica le impostazioni a metà sessione. Poiché solo limitano, non possono ampliare ciò che le regole gestite concedono. Prima della v2.1.257, Claude Code scartava quelle regole da riga di comando e di sessione al primo ricaricamento delle impostazioni.

  • Ambito: Managed
  • Tipo: Booleano
    • true: le impostazioni gestite diventano l'unica fonte di impostazioni delle regole di autorizzazione
    • false: Claude Code applica le regole di autorizzazione dai file utente, progetto, locale e --settings oltre a quelle gestite
  • Predefinito: non impostato, quindi Claude Code applica le regole di autorizzazione dalle impostazioni utente, progetto e locale e da --settings, oltre a quelle gestite
{
  "allowManagedPermissionRulesOnly": true
}

Questa chiave non blocca l'elenco di autorizzazione del server MCP; per farlo, imposta allowManagedMcpServersOnly. Vedere Impostazioni solo gestite.

`autoMode`

Aggiungi le tue regole a ciò che il classificatore della modalità automatica blocca e consente. Usalo per dire al classificatore quali repository, bucket e domini la tua organizzazione ritiene affidabili, in modo che smetta di bloccare le operazioni interne di routine. Il classificatore viene fornito con regole di autorizzazione e negazione integrate. Includi la stringa letterale "$defaults" in un array per mantenere quelle regole integrate in quella posizione e aggiungere le tue intorno; omettila per sostituirle con le tue.

  • Ambito: User or managed
  • Tipo: oggetto con array environment, allow, soft_deny e hard_deny di regole in prosa, più il Booleano classifyAllShell
  • Predefinito: non impostato, quindi il classificatore utilizza solo le sue regole integrate

Questo esempio mantiene le regole soft_deny integrate, tramite "$defaults", e aggiunge un'altra che blocca terraform apply:

{
  "autoMode": {
    "soft_deny": ["$defaults", "Never run terraform apply"]
  }
}

Quando più di uno di questi file imposta lo stesso array, Claude Code concatena le voci. Per il formato della regola e come ogni array viene applicato, vedere Configurare la modalità automatica.

`autoMode.classifyAllShell`

Invia ogni comando Bash e PowerShell attraverso il classificatore della modalità automatica mentre la modalità automatica è attiva. Per impostazione predefinita, la modalità automatica sospende solo le regole di autorizzazione che potrebbero eseguire codice arbitrario: regole a livello di strumento e wildcard come Bash(*) e prefissi di interprete o shell-wrapper come Bash(python *). Un comando che corrisponde a qualsiasi altra regola di autorizzazione, come Bash(npm test), salta il classificatore e un argomento distruttivo che il prefisso della regola non ha anticipato può passare inosservato. L'impostazione di questa chiave sospende ogni regola di autorizzazione shell per la sessione in modo che il classificatore veda ogni comando. Richiede Claude Code v2.1.193 o successivo.

  • Ambito: User or managed. Leggi ovunque autoMode viene letto.
  • Tipo: Booleano
    • true: mentre la modalità automatica è attiva, Claude Code invia ogni comando Bash e PowerShell attraverso il classificatore e sospende le tue regole di autorizzazione shell; al di fuori della modalità automatica le regole si applicano ancora
    • false: la modalità automatica sospende solo le regole di autorizzazione che potrebbero eseguire codice arbitrario, come Bash(*) e Bash(python *); un comando che corrisponde a qualsiasi altra regola di autorizzazione salta il classificatore e ogni altro comando shell passa attraverso di esso
  • Predefinito: false
{
  "autoMode": {
    "classifyAllShell": true
  }
}

Vedere Instrada tutti i comandi shell attraverso il classificatore. Richiede Claude Code v2.1.193 o successivo.

`disableAutoMode`

Rimuovi la modalità automatica dal ciclo Shift+Tab. Qualsiasi sessione che altrimenti inizierebbe in modalità automatica, sia da --permission-mode auto, da un file di impostazioni o dal predefinito integrato, inizia invece in default. Gli amministratori lo impostano nelle impostazioni gestite per impedire agli sviluppatori della loro organizzazione di utilizzare la modalità automatica.

  • Ambito: Any file. Più utile nelle impostazioni gestite, dove gli utenti non possono sovrascriverlo. Accettato anche sotto permissions come permissions.disableAutoMode.
  • Tipo: la stringa "disable"
  • Predefinito: non impostato
{
  "disableAutoMode": "disable"
}

`permissions`

Controlla quali strumenti Claude può utilizzare senza chiedere, quali richiedono sempre un prompt e quali sono bloccati, e imposta la modalità di autorizzazione in cui una sessione inizia. Ogni chiave permissions.* di seguito si annida sotto questo oggetto.

  • Ambito: Any file
  • Tipo: oggetto con allow, ask, deny, additionalDirectories, blockReadsOutsideWorkingDirectories, defaultMode, disableBypassPermissionsMode e disableAutoMode
  • Predefinito: non impostato

Questo esempio approva i comandi npm run senza chiedere, richiede una conferma prima di git push, blocca le letture di .env e avvia le sessioni in acceptEdits:

{
  "permissions": {
    "allow": ["Bash(npm run *)"],
    "ask": ["Bash(git push *)"],
    "deny": ["Read(./.env)"],
    "defaultMode": "acceptEdits"
  }
}

I tre array di regole condividono una sintassi; vedere Sintassi della regola di autorizzazione sotto permissions.allow. Per come le regole di autorizzazione da file diversi si combinano, vedere come le regole di autorizzazione si uniscono tra gli ambiti; per come le chiavi di impostazioni in generale si combinano, vedere Precedenza delle impostazioni nella guida alle impostazioni.

`useAutoModeDuringPlan`

Scegli se Claude Code utilizza il classificatore della modalità automatica per esaminare i comandi shell in modalità piano. Con il valore predefinito true, il classificatore esamina ogni comando durante la pianificazione quando la modalità automatica è disponibile e non vedi alcun prompt. Imposta false per ottenere un prompt di autorizzazione per ogni comando al di fuori dell'insieme integrato di sola lettura. Appare in /config come Usa modalità automatica durante il piano.

  • Ambito: User, local, or managed. Un repository non può disattivarlo per te.
  • Tipo: Booleano
    • true: lo stesso di non impostato; quando la modalità automatica è disponibile, il classificatore esamina ogni comando shell durante la pianificazione invece di chiederti. Un false in uno qualsiasi di questi file lo disattiva comunque
    • false: ricevi un prompt di autorizzazione per ogni comando al di fuori dell'insieme integrato di sola lettura
  • Predefinito: true
{
  "useAutoModeDuringPlan": false
}

`permissions.allow`

Elenca gli usi degli strumenti che Claude Code approva senza chiederti. In una regola MCP, * può apparire solo nel nome dello strumento dopo il prefisso mcp__<server>__, come mcp__github__get_*; non può apparire nel nome del server.

  • Ambito: Any file
  • Tipo: array di stringhe di regole di autorizzazione
  • Predefinito: non impostato
  • Override per sessione: --allowedTools aggiunge regole di autorizzazione per una sessione e una regola di negazione da qualsiasi file di impostazioni blocca comunque uno strumento che nomina

Questo esempio approva git diff e consente a Claude Code di leggere il tuo .zshrc senza chiedere:

{
  "permissions": {
    "allow": ["Bash(git diff *)", "Read(~/.zshrc)"]
  }
}

Claude Code applica le regole allow dal .claude/settings.json di un progetto solo dopo che accetti la finestra di dialogo di fiducia dell'area di lavoro per quella cartella.

Sintassi della regola di autorizzazione

Le regole di autorizzazione seguono il formato Tool o Tool(specifier). Claude Code valuta prima le regole deny, poi ask, poi allow, e la prima corrispondenza decide indipendentemente da quanto specifica sia ogni regola; vedere l'ordine di valutazione della regola di autorizzazione.

Ogni riga mostra una forma di regola e cosa corrisponde.

Regola Cosa corrisponde
Bash Ogni comando Bash
Bash(npm run *) Comandi che iniziano con npm run
Read(./.env) Letture del file .env
WebFetch(domain:example.com) Richieste di recupero a example.com

Per la sintassi completa della regola, incluso il comportamento dei wildcard, i modelli specifici dello strumento per Read, Edit, WebFetch, MCP e regole Agent e i limiti di sicurezza dei modelli Bash, vedere Sintassi della regola di autorizzazione.

`permissions.ask`

Elenca gli usi degli strumenti che ti richiedono una conferma anche in una modalità di autorizzazione che altrimenti li approverebbe, come acceptEdits o bypassPermissions. In modalità dontAsk Claude Code nega un uso dello strumento corrispondente invece di richiedere.

  • Ambito: Any file
  • Tipo: array di stringhe di regole di autorizzazione
  • Predefinito: non impostato
{
  "permissions": {
    "ask": ["Bash(git push *)"]
  }
}

`permissions.deny`

Elenca gli usi degli strumenti che Claude Code blocca. Usalo per file che contengono chiavi API, segreti o valori di ambiente: Claude Code esclude i file corrispondenti dalla scoperta dei file e dai risultati della ricerca, nega le letture di essi e blocca gli strumenti Edit e Write sui percorsi corrispondenti. Le regole di negazione Read e Edit si applicano agli strumenti di file integrati di Claude, ai comandi di file che Claude Code riconosce in Bash, come cat, head, tail e sed, e ai target dei reindirizzamenti Bash come > file e < file; non si applicano a un comando che legge file senza nominarli, come grep -r pattern ., o a sottoprocessi arbitrari, quindi per l'applicazione a livello di sistema operativo abilita la sandbox.

  • Ambito: Any file
  • Tipo: array di stringhe di regole di autorizzazione
  • Predefinito: non impostato
  • Override per sessione: --disallowedTools aggiunge regole di negazione per una sessione insieme a questa chiave

Questo esempio nega le letture dei file .env, della directory secrets e di un file di credenziali e blocca i comandi curl:

{
  "permissions": {
    "deny": [
      "Read(./.env)",
      "Read(./.env.*)",
      "Read(./secrets/**)",
      "Read(./config/credentials.json)",
      "Bash(curl *)"
    ]
  }
}

I nomi degli strumenti accettano modelli glob, quindi "*" nega ogni strumento e "mcp__*" nega ogni strumento MCP. Claude Code ignora una regola di negazione per lo strumento EndConversation finché qualsiasi altro strumento è ancora disponibile per Claude. Una regola di negazione Bash corrisponde al comando come Claude lo scrive, quindi Bash(curl *) non ferma /usr/bin/curl o sh -c 'curl …'; vedere cosa una regola Bash non corrisponde. Questa chiave sostituisce la configurazione deprecata ignorePatterns.

`permissions.additionalDirectories`

Dai a Claude l'accesso ai file alle directory al di fuori di quella in cui hai iniziato, come directory di lavoro aggiuntive. La maggior parte della configurazione .claude/ non viene scoperta da queste directory.

  • Ambito: Any file
  • Tipo: array di percorsi di directory
  • Predefinito: non impostato
  • Override per sessione: --add-dir e /add-dir aggiungono directory per una sessione insieme a questa chiave
{
  "permissions": {
    "additionalDirectories": ["../docs/"]
  }
}

Come le regole allow, le voci nel .claude/settings.json di un progetto hanno effetto solo dopo che accetti la finestra di dialogo di fiducia dell'area di lavoro per quella cartella.

`permissions.blockReadsOutsideWorkingDirectories`

Impedisci a Claude di leggere percorsi al di fuori delle directory di lavoro della sessione con gli strumenti Read, Grep, Glob e LSP, in ogni modalità di autorizzazione inclusa bypassPermissions. Un comando Bash che legge un percorso corrispondente attraverso un comando di file che Claude Code riconosce, come cat, ti richiede anche in modalità automatica e modalità bypassPermissions. Richiede Claude Code v2.1.257 o successivo.

Claude Code scrive anche true qui quando scegli di bloccare tali letture sul prompt della modalità automatica prima della prima lettura al di fuori delle directory di lavoro.

  • Ambito: Any file. Se qualsiasi fonte di impostazioni imposta true, il blocco si applica, quindi il file archiviato di un repository può attivare il blocco per un progetto ma non può sollevare un blocco che hai impostato.
  • Tipo: Booleano
    • true: le letture di file al di fuori delle directory di lavoro sono bloccate
    • false: lo stesso di non impostato; un true in qualsiasi altro file di impostazioni blocca comunque
  • Predefinito: non impostato, quindi le letture al di fuori delle directory di lavoro seguono la tua modalità di autorizzazione e le regole
{
  "permissions": {
    "blockReadsOutsideWorkingDirectories": true
  }
}

Se solo il file di impostazioni archiviato di un repository aggiunge una directory, il blocco si applica comunque alle letture lì. I file che Claude Code stesso ha bisogno rimangono leggibili, come le tue skill, plugin, regole, agent, comandi e il file di memoria CLAUDE.md sotto ~/.claude/.

Quando la sandbox è attiva, il blocco nega anche ai comandi in sandbox l'accesso in lettura alle directory home e alle radici dei volumi montati al di fuori delle directory di lavoro. Un nuovo tentativo che ha bisogno di approvazione per eseguire al di fuori della sandbox ti richiede anche in modalità bypassPermissions. I file che uno strumento legge dalla tua directory home, come ~/.gitconfig, vengono negati con il resto; riapri un percorso specifico con sandbox.filesystem.allowRead quando uno strumento ha bisogno di esso.

Quando la directory di lavoro della sessione è un git worktree collegato, incluso uno che Claude Code ha inserito a metà sessione, la directory .git comune del repository rimane leggibile e scrivibile ai comandi in sandbox, in modo che git continui a funzionare lì.

`permissions.defaultMode`

Imposta la modalità di autorizzazione in cui le nuove sessioni iniziano. Quando la lasci non impostata, le sessioni iniziano nel predefinito integrato per il tuo piano e superficie.

  • Ambito: Any file. auto e bypassPermissions non hanno effetto dalle impostazioni di progetto o locale, quindi impostali in ~/.claude/settings.json invece. Prima della v2.1.257, bypassPermissions aveva effetto da qualsiasi file. Per le conversazioni che l'estensione VS Code avvia, Claude Code legge solo i valori utente, gestiti e --settings.
  • Tipo: stringa, uno di:
    • "default": Claude Code esegue solo letture senza chiedere
    • "acceptEdits": Claude Code esegue anche modifiche di file e comandi comuni del file system come mkdir e mv senza chiedere
    • "plan": Claude Code legge e pianifica ma blocca le modifiche finché non approvi un piano
    • "auto": Claude Code esegue tutto, con controlli di sicurezza in background
    • "dontAsk": Claude Code nega automaticamente ogni chiamata che altrimenti richiederebbe; le letture, altre azioni che non richiedono approvazione e gli strumenti pre-approvati si eseguono comunque
    • "bypassPermissions": Claude Code esegue tutto senza chiedere
    • "manual": un alias per "default", in Claude Code v2.1.200 o successivo
  • Predefinito: non impostato
  • Override per sessione: --permission-mode e il suo equivalente --dangerously-skip-permissions per bypassPermissions hanno la precedenza su questa chiave per una sessione
{
  "permissions": {
    "defaultMode": "acceptEdits"
  }
}

Le regole di autorizzazione si sovrappongono a ogni modalità: le regole deny bloccano in ogni modalità, inclusa bypassPermissions. Vedere Modalità di autorizzazione. manual nomina la modalità di autorizzazione etichettata Manual nella CLI e nell'estensione VS Code; l'alias richiede Claude Code v2.1.200 o successivo. In Claude Code sul web, Claude Code onora solo acceptEdits, plan, default e auto da questa chiave. Per le conversazioni che l'estensione VS Code avvia, vedere quale impostazione l'estensione legge per la modalità di autorizzazione iniziale.

`permissions.disableBypassPermissionsMode`

Impedisci a chiunque di entrare in modalità bypassPermissions. Claude Code rifiuta quindi il flag --dangerously-skip-permissions e ignora la definizione di un agent permissionMode: bypassPermissions, quindi il subagent viene eseguito con la modalità di autorizzazione della sessione padre.

  • Ambito: Any file. Tipicamente impostato nelle impostazioni gestite per applicare la politica organizzativa.
  • Tipo: la stringa "disable"
  • Predefinito: non impostato
  • Override per sessione: questa chiave ha la precedenza su --dangerously-skip-permissions, che Claude Code rifiuta mentre la chiave è impostata
{
  "permissions": {
    "disableBypassPermissionsMode": "disable"
  }
}

Prima della v2.1.223, Claude Code applicava la modalità di autorizzazione del frontmatter anche con il bypass disabilitato.

`skipAutoPermissionPrompt`

Salta l'avviso una tantum che descrive la modalità automatica che Claude Code mostra quando entri per la prima volta in modalità automatica tu stesso, ad esempio attraverso le tue impostazioni o il selettore di modalità, piuttosto che quando il predefinito integrato avvia una sessione in essa. Claude Code mostra quell'avviso una volta e poi registra che è stato mostrato, quindi questa chiave ha importanza solo dove l'avviso non è ancora apparso.

  • Ambito: User or managed. Un repository non può impostarlo per te.
  • Tipo: Booleano
    • true: Claude Code salta l'avviso
    • false: lo stesso di non impostato; l'avviso appare una volta a meno che un altro di questi file non imposti true
  • Predefinito: non impostato, quindi l'avviso appare una volta
{
  "skipAutoPermissionPrompt": true
}

`skipDangerousModePermissionPrompt`

Salta la finestra di dialogo di conferma che Claude Code mostra prima che una sessione entri in modalità bypassPermissions, sia da --dangerously-skip-permissions che da defaultMode: "bypassPermissions". Claude Code scrive true qui nelle tue impostazioni utente quando accetti quella finestra di dialogo una volta.

  • Ambito: User, local, or managed. Un repository non affidabile non può saltare la finestra di dialogo per te.
  • Tipo: Booleano
    • true: Claude Code salta la finestra di dialogo di conferma prima che una sessione entri in modalità bypassPermissions
    • false: lo stesso di non impostato; la finestra di dialogo appare a meno che un altro di questi file non imposti true
  • Predefinito: non impostato, quindi la finestra di dialogo appare
{
  "skipDangerousModePermissionPrompt": true
}

Impostazioni sandbox

Isola i comandi che Claude esegue dal tuo filesystem, dalla tua rete e dalle tue credenziali. Per informazioni su come funziona il sandboxing e sui requisiti della piattaforma, vedi Sandboxing.

`sandbox`

Isola i comandi Bash che Claude esegue dal tuo filesystem e dalla rete con il sandboxing. Attiva la sandbox con enabled, quindi restringi o amplia ciò che i comandi in sandbox possono toccare con i sotto-oggetti filesystem, network e credentials. La sandbox funziona su macOS, Linux e WSL2.

  • Scope: Any file
  • Type: object con enabled, failIfUnavailable, autoAllowBashIfSandboxed, excludedCommands, allowUnsandboxedCommands, enableWeakerNestedSandbox, enableWeakerNetworkIsolation, allowAppleEvents, bwrapPath, socatPath, ignoreViolations e ripgrep, più gli oggetti filesystem, network e credentials
  • Default: non impostato, quindi Claude Code esegue i comandi senza sandbox

Questo attiva la sandbox, salta i prompt di autorizzazione per i comandi in sandbox, esegue docker al di fuori della sandbox, apre due percorsi di scrittura aggiuntivi, nasconde il tuo file di credenziali AWS e pre-consente GitHub e npm:

{
  "sandbox": {
    "enabled": true,
    "autoAllowBashIfSandboxed": true,
    "excludedCommands": ["docker *"],
    "filesystem": {
      "allowWrite": ["/tmp/build", "~/.kube"],
      "denyRead": ["~/.aws/credentials"]
    },
    "network": {
      "allowedDomains": ["github.com", "*.npmjs.org"]
    }
  }
}

Claude Code prende il valore di una chiave booleana dall'ambito di impostazioni con la precedenza più alta che la imposta, quindi un enabled o failIfUnavailable gestito sovrascrive qualsiasi cosa uno sviluppatore imposti. Unisce le chiavi array in ogni ambito di impostazioni che la sessione carica, quindi uno sviluppatore può aggiungere voci; vedi Keep developers from widening the policy per i blocchi solo gestiti. Per richiedere la sandbox per un'organizzazione, vedi Enforce sandboxing with managed settings.

`sandbox.enabled`

Attiva il sandboxing per i comandi Bash. Quando scegli una modalità nel pannello /sandbox, Claude Code scrive questa chiave in .claude/settings.local.json per il progetto corrente; impostala in ~/.claude/settings.json per mettere in sandbox ogni progetto.

  • Scope: Any file
  • Type: Boolean
    • true: Claude Code mette in sandbox i comandi Bash
    • false: i comandi Bash vengono eseguiti senza sandbox
  • Default: false
{
  "sandbox": {
    "enabled": true
  }
}

Su Linux e WSL2 la sandbox ha bisogno di bubblewrap e socat; vedi Set up Linux and WSL2. Quando la sandbox non può avviarsi, Claude Code mostra un avviso ed esegue i comandi senza sandbox a meno che tu non imposti anche failIfUnavailable.

`sandbox.failIfUnavailable`

Fai uscire Claude Code con un errore all'avvio quando sandbox.enabled è true ma la sandbox non può avviarsi, perché una dipendenza è mancante o la piattaforma non è supportata. Senza di essa, Claude Code mostra un avviso ed esegue i comandi senza sandbox. Usala nelle impostazioni gestite quando la tua organizzazione richiede il sandboxing come un gate rigido.

  • Scope: Any file
  • Type: Boolean
    • true: Claude Code esce con un errore all'avvio quando sandbox.enabled è true ma la sandbox non può avviarsi
    • false: Claude Code mostra un avviso ed esegue i comandi senza sandbox
  • Default: false

Questo fa sì che ogni macchina gestita metta in sandbox i comandi o rifiuti di avviarsi:

{
  "sandbox": {
    "enabled": true,
    "failIfUnavailable": true
  }
}

Vedi Enforce sandboxing with managed settings.

`sandbox.autoAllowBashIfSandboxed`

Consenti a Claude Code di eseguire comandi Bash in sandbox senza un prompt di autorizzazione. I comandi che non possono essere eseguiti nella sandbox seguono comunque il flusso di autorizzazione regolare, e le regole deny e le regole ask con ambito di contenuto come Bash(git push *) si applicano comunque; una regola ask Bash semplice viene saltata per i comandi in sandbox. Impostala su false per inviare i comandi in sandbox anche attraverso il flusso di autorizzazione regolare, che la scheda Mode di /sandbox chiama modalità di autorizzazioni regolari.

  • Scope: Any file
  • Type: Boolean
    • true: Claude Code esegue i comandi Bash in sandbox senza un prompt di autorizzazione, soggetto alle regole deny e alle regole ask con ambito di contenuto; CLAUDE_CODE_SUBPROCESS_ENV_SCRUB disattiva l'auto-consentimento
    • false: i comandi in sandbox seguono il flusso di autorizzazione regolare, quindi le tue regole di consentimento e la modalità di autorizzazione decidono. La scheda Mode di /sandbox chiama questa modalità di autorizzazioni regolari
  • Default: true

Questo mantiene la sandbox attiva e invia i comandi in sandbox attraverso il flusso di autorizzazione regolare:

{
  "sandbox": {
    "enabled": true,
    "autoAllowBashIfSandboxed": false
  }
}

Vedi Sandbox modes per ciò che la modalità auto-consentimento ancora richiede e come si comporta in plan mode.

`sandbox.excludedCommands`

Nomina i comandi che Claude Code esegue sempre al di fuori della sandbox, come gli strumenti che non funzionano sotto di essa. Ogni voce utilizza la stessa sintassi del contenuto di una regola di autorizzazione Bash(...): un comando esatto, un prefisso come docker * o un pattern con wildcard. Quando qualsiasi parte di un comando composto corrisponde a una voce, Claude Code esegue l'intero comando senza sandbox.

  • Scope: Any file
  • Type: array di pattern di comando
  • Default: non impostato, quindi nessun comando è escluso
{
  "sandbox": {
    "excludedCommands": ["docker *"]
  }
}

I comandi esclusi seguono comunque il flusso di autorizzazione regolare. L'esclusione è una comodità, non un confine di sicurezza: preferisci filesystem.allowWrite quando uno strumento ha solo bisogno di scrivere da qualche parte di specifico. Claude Code unisce le voci in ogni ambito di impostazioni che la sessione carica, e non c'è un blocco solo gestito per questo elenco, quindi mantieni un elenco gestito ristretto.

`sandbox.allowUnsandboxedCommands`

Consenti a Claude di ritentare un comando al di fuori della sandbox con il parametro dangerouslyDisableSandbox dopo che la sandbox lo blocca. Impostalo su false in modo che Claude Code ignori completamente quel parametro e ogni comando che Claude esegue deve essere in sandbox o apparire in excludedCommands. La scheda Overrides di /sandbox mostra quello stato come Strict sandbox mode. Usa false nelle impostazioni gestite per le politiche che richiedono il sandboxing rigoroso.

  • Scope: Any file
  • Type: Boolean
    • true: Claude può ritentare un comando al di fuori della sandbox con il parametro dangerouslyDisableSandbox dopo che la sandbox lo blocca
    • false: Claude Code ignora quel parametro, quindi ogni comando che Claude esegue è in sandbox o appare in excludedCommands
  • Default: true

Questo applica la modalità sandbox rigorosa per tutti coloro che le impostazioni gestite coprono:

{
  "sandbox": {
    "enabled": true,
    "allowUnsandboxedCommands": false
  }
}

Un ritentativo senza sandbox passa attraverso il flusso di autorizzazione regolare, con un prompt in modalità Manual. Vedi The unsandboxed retry escape hatch.

Per vedere quando i comandi che digiti tu stesso al prompt di modalità shell ! vengono eseguiti in sandbox, vedi strict sandbox mode.

`sandbox.filesystem`

Controlla quali percorsi i comandi in sandbox possono leggere e scrivere. Per impostazione predefinita possono scrivere nella directory di lavoro, nella directory temporanea della sessione e nelle directory che aggiungi con --add-dir, /add-dir o permissions.additionalDirectories, e possono leggere il resto del filesystem, inclusi i file di credenziali. Amplia o restringi con i quattro elenchi di percorsi, o disattiva il livello del filesystem con disabled. Vedi Filesystem isolation per i confini predefiniti.

  • Scope: Any file
  • Type: object con array allowWrite, denyWrite, denyRead e allowRead, più i booleani allowManagedReadPathsOnly e disabled
  • Default: non impostato, quindi si applicano i confini di lettura e scrittura predefiniti

Questo consente ai comandi in sandbox di scrivere in una directory di build e nel tuo kubeconfig, e nasconde il tuo file di credenziali AWS:

{
  "sandbox": {
    "filesystem": {
      "allowWrite": ["/tmp/build", "~/.kube"],
      "denyRead": ["~/.aws/credentials"]
    }
  }
}

Claude Code applica questi elenchi al confine della sandbox del sistema operativo, quindi si applicano a ogni sottoprocesso che un comando in sandbox avvia, come kubectl, terraform o npm, non solo agli strumenti di file di Claude. Claude Code aggiunge le tue regole di autorizzazione agli stessi elenchi: le regole Edit allow e deny a allowWrite e denyWrite, le regole Read deny a denyRead e le regole WebFetch(domain:...) allow e deny agli elenchi di domini network.

A meno che non sia impostato un blocco solo gestito, Claude Code unisce ogni elenco nei file di impostazioni che la sessione carica. allowManagedReadPathsOnly limita allowRead alle voci dalle impostazioni gestite, e allowManagedDomainsOnly fa lo stesso per i domini consentiti.

Configure sandboxing copre le fonti che escludi con --setting-sources. Quando modifichi un elenco durante una sessione, Claude Code applica la modifica alla sessione in esecuzione.

Prefissi di percorso sandbox

I percorsi in allowWrite, denyWrite, denyRead, allowRead e credentials.files si risolvono in base al loro prefisso:

Prefisso Significato Esempio
/ Percorso assoluto dalla radice del filesystem /tmp/build rimane /tmp/build
~/ Relativo alla directory home ~/.kube diventa $HOME/.kube
./ o nessun prefisso Relativo alla radice del progetto per le impostazioni del progetto, o a ~/.claude per le impostazioni dell'utente ./output in .claude/settings.json si risolve in <project-root>/output

Il prefisso //path per i percorsi assoluti funziona anche. Se usi un singolo slash /path aspettandoti una risoluzione relativa al progetto, passa a ./path. Questa sintassi differisce dalle regole di autorizzazione Read e Edit, che usano //path per assoluto e /path per relativo al progetto: i percorsi del filesystem sandbox usano convenzioni standard, quindi /tmp/build è un percorso assoluto.

Claude Code rimuove uno slash finale da un percorso di directory, quindi ~/.aws e ~/.aws/ corrispondono alla stessa directory. Prima della v2.1.224, Claude Code passava lo slash finale alla sandbox, e Claude poteva comunque leggere o scrivere percorsi sotto una voce denyRead o denyWrite scritta con uno.

Claude Code rimuove anche un /** finale, quindi ~/build/** e ~/build coprono la stessa directory. Se un wildcard come * funziona dipende da quale elenco è la voce e dalla piattaforma:

  • allowWrite e denyWrite: su macOS, i wildcard funzionano. Su Linux e WSL2, la sandbox monta percorsi concreti, quindi Claude Code salta una voce che contiene *, ? o [ una volta rimosso il /** finale, e quella voce non ha effetto. Claude Code aggiunge i percorsi dalle tue regole di autorizzazione Edit a questi elenchi, quindi lo stesso limite si applica a loro, e la scheda Config di /sandbox avverte le regole di autorizzazione Edit e Read che contengono wildcard.
  • denyRead e allowRead: i wildcard funzionano su ogni piattaforma. Su Linux e WSL2, Claude Code espande una voce di lettura ai percorsi concreti che corrisponde, cosa che non fa per gli elenchi di scrittura.

`sandbox.filesystem.allowWrite`

Aggiungi percorsi dove i comandi in sandbox possono scrivere, oltre alla directory di lavoro, alla directory temporanea della sessione e alle directory che hai aggiunto con --add-dir, /add-dir o permissions.additionalDirectories. Usalo quando un sottoprocesso come kubectl o uno strumento di build ha bisogno di scrivere al di fuori del progetto.

Questo consente a una build di scrivere sotto /tmp/build e consente a kubectl di aggiornare il tuo kubeconfig:

{
  "sandbox": {
    "filesystem": {
      "allowWrite": ["/tmp/build", "~/.kube"]
    }
  }
}

Claude Code unisce le voci in ogni ambito di impostazioni che la sessione carica: i percorsi utente, progetto, locale e gestito si combinano piuttosto che sostituirsi a vicenda, e Claude Code aggiunge i percorsi dalle tue regole di autorizzazione Edit(...) allow. Una voce allowWrite non può sollevare un percorso protetto.

`sandbox.filesystem.denyWrite`

Blocca i comandi in sandbox dallo scrivere su percorsi specifici, inclusi i percorsi all'interno di una directory che è altrimenti scrivibile.

Questo impedisce ai comandi in sandbox di modificare la configurazione del sistema o installare binari:

{
  "sandbox": {
    "filesystem": {
      "denyWrite": ["/etc", "/usr/local/bin"]
    }
  }
}

Claude Code unisce le voci in ogni ambito di impostazioni che la sessione carica, e aggiunge i percorsi dalle tue regole di autorizzazione Edit(...) deny.

`sandbox.filesystem.denyRead`

Blocca i comandi in sandbox dal leggere percorsi specifici, come i file di credenziali che la politica di lettura predefinita esporrebbe altrimenti. Per proteggere un file di credenziali e mantenerlo utilizzabile attraverso il proxy della sandbox, vedi sandbox.credentials invece.

{
  "sandbox": {
    "filesystem": {
      "denyRead": ["~/.aws/credentials"]
    }
  }
}

Claude Code unisce le voci in ogni ambito di impostazioni che la sessione carica, e aggiunge i percorsi dalle tue regole di autorizzazione Read(...) deny. Quando filesystem.disabled è true, Claude Code non applica queste voci.

`sandbox.filesystem.allowRead`

Riapri la lettura per percorsi specifici all'interno di una regione che denyRead blocca, per costruire un accesso in lettura solo per l'area di lavoro. Una voce denyRead esatta o con wildcard rimane bloccata all'interno di un allowRead più ampio, come mostra la tabella di sovrapposizione. Quando una voce denyRead con wildcard come ~/**/.env corrisponde a una directory, Claude Code blocca le letture dei suoi contenuti anche. Prima della v2.1.236 su macOS, Claude Code riaprì i percorsi che una voce denyRead con wildcard corrispondeva ovunque una voce allowRead più ampia li copriva, e lasciò i contenuti di una directory corrispondente leggibili.

Questo blocca le letture della tua directory home tranne il progetto stesso:

{
  "sandbox": {
    "filesystem": {
      "denyRead": ["~/"],
      "allowRead": ["."]
    }
  }
}

Claude Code risolve una voce . alla radice del progetto nelle impostazioni del progetto e a ~/.claude nelle impostazioni dell'utente. Claude Code unisce le voci in ogni file di impostazioni che la sessione carica a meno che allowManagedReadPathsOnly non sia impostato.

`sandbox.filesystem.allowManagedReadPathsOnly`

Onora solo le voci allowRead che provengono dalle impostazioni gestite, in modo che gli sviluppatori non possano riaprire l'accesso in lettura ai percorsi che la tua organizzazione ha bloccato. Claude Code unisce comunque le voci denyRead da ogni ambito di impostazioni che la sessione carica.

  • Scope: Managed
  • Type: Boolean
    • true: Claude Code onora solo le voci allowRead dalle impostazioni gestite
    • false: le voci allowRead si uniscono da ogni ambito di impostazioni che la sessione carica
  • Default: false

Questo blocca le letture della directory home, riapre ~/work e impedisce agli sviluppatori di riaprire qualsiasi altra cosa:

{
  "sandbox": {
    "filesystem": {
      "denyRead": ["~/"],
      "allowRead": ["~/work"],
      "allowManagedReadPathsOnly": true
    }
  }
}

Vedi Keep developers from widening the policy.

`sandbox.filesystem.disabled`

Salta l'isolamento del filesystem mantenendo l'isolamento della rete. I comandi in sandbox ottengono accesso in lettura e scrittura senza restrizioni al filesystem host, e il loro egresso di rete rimane confinato a network.allowedDomains. Usalo quando metti in sandbox per controllare dove i comandi si connettono piuttosto che cosa scrivono. Richiede Claude Code v2.1.216 o successivo.

  • Scope: User or managed. Quando le impostazioni gestite configurano sandbox.filesystem affatto, o elencano una voce sandbox.credentials.files con "mode": "deny", solo le impostazioni gestite possono impostarla.
  • Type: Boolean
    • true: Claude Code salta l'isolamento del filesystem e mantiene l'isolamento della rete
    • false: l'isolamento del filesystem rimane attivo
  • Default: false, quindi l'isolamento del filesystem rimane attivo

Questo lascia il filesystem aperto e confina l'egresso di rete a GitHub e npm:

{
  "sandbox": {
    "enabled": true,
    "filesystem": {
      "disabled": true
    },
    "network": {
      "allowedDomains": ["github.com", "*.npmjs.org"]
    }
  }
}

Con il livello disattivato, Claude Code non applica le voci denyRead o credentials.files deny, mentre le voci credentials.envVars e le voci mask applicate continuano a funzionare. autoAllowBashIfSandboxed continua a impostazione predefinita su true, quindi impostalo su false per continuare a richiedere. Vedi Disable filesystem isolation per l'elenco completo delle fonti che possono impostarla e cosa cambia quando l'isolamento è disattivato. Richiede Claude Code v2.1.216 o successivo.

`sandbox.ignoreViolations`

Silenzia i rapporti di violazione della sandbox per i percorsi che ti aspetti che un comando sonda e sia rifiutato, come uno strumento che controlla /etc/hosts all'avvio, in modo che quei rifiuti non vengano visualizzati come violazioni o in ciò che Claude vede. La sandbox blocca comunque l'accesso; solo il rapporto è soppresso. Le chiavi sono sottostringhe da abbinare al comando, con * che corrisponde a ogni comando, e i valori sono sottostringhe della violazione da ignorare per quel comando, come un percorso del filesystem.

  • Scope: Any file
  • Type: object che mappa una sottostringa di comando a un array di sottostringhe di violazione, solitamente percorsi
  • Default: non impostato, quindi ogni violazione è segnalata
{
  "sandbox": {
    "ignoreViolations": {
      "*": ["/etc/hosts"]
    }
  }
}

`sandbox.enableWeakerNestedSandbox`

Esegui la sandbox Linux all'interno di un contenitore Docker senza privilegi, dove bubblewrap non può montare un /proc fresco. Invece la sandbox interna bind-monta il /proc esistente del contenitore, che espone informazioni di processo che un mount fresco nasconderebbe. Questo riduce la sicurezza; usalo solo quando il contenitore esterno fornisce già l'isolamento di cui hai bisogno.

  • Scope: Any file
  • Type: Boolean
    • true: la sandbox interna bind-monta il /proc esistente del contenitore invece di montarne uno fresco
    • false: la sandbox monta un /proc fresco, che non funziona in un contenitore Docker senza privilegi
  • Default: false
{
  "sandbox": {
    "enabled": true,
    "enableWeakerNestedSandbox": true
  }
}

Solo Linux e WSL2. Vedi Bubblewrap fails to start inside a container.

`sandbox.enableWeakerNetworkIsolation`

Consenti ai comandi in sandbox su macOS di raggiungere il servizio di fiducia TLS del sistema, com.apple.trustd.agent. Gli strumenti basati su Go come gh, gcloud e terraform ne hanno bisogno per verificare i certificati TLS quando usi network.httpProxyPort con un proxy MITM e una CA personalizzata. Questo riduce la sicurezza aprendo un potenziale percorso di esfiltrazione dei dati attraverso il servizio di fiducia.

  • Scope: Any file
  • Type: Boolean
    • true: i comandi in sandbox su macOS possono raggiungere com.apple.trustd.agent
    • false: i comandi in sandbox su macOS non possono raggiungere il servizio di fiducia TLS del sistema
  • Default: false
{
  "sandbox": {
    "enabled": true,
    "enableWeakerNetworkIsolation": true
  }
}

Se non usi un proxy MITM, elenca gli strumenti che falliscono in excludedCommands invece; vedi Go-based CLIs fail TLS verification on macOS.

`sandbox.allowAppleEvents`

Consenti ai comandi in sandbox su macOS di inviare Apple Events, che open, osascript e gli strumenti che aprono URL in un browser hanno bisogno; senza di esso falliscono con errore -600. Questo rimuove l'isolamento dell'esecuzione del codice: i comandi in sandbox possono lanciare altre applicazioni senza sandbox senza un prompt dell'utente, e possono inviare comandi AppleScript alle applicazioni in esecuzione come Terminal, soggetto al prompt di consenso per l'automazione per app macOS (TCC).

  • Scope: User or managed
  • Type: Boolean
    • true: i comandi in sandbox su macOS possono inviare Apple Events
    • false: i comandi in sandbox su macOS non possono inviare Apple Events, quindi open e osascript falliscono con errore -600
  • Default: false
{
  "sandbox": {
    "enabled": true,
    "allowAppleEvents": true
  }
}

Per mantenere l'isolamento e comunque eseguire uno di questi strumenti, aggiungilo a excludedCommands invece. Vedi Apple Events on macOS.

`sandbox.ripgrep`

Punta la sandbox a un binario ripgrep tuo invece di quello che Claude Code usa, ad esempio quando la tua piattaforma ha bisogno di un rg costruito diversamente.

  • Scope: User or managed
  • Type: object con command, il percorso al binario ripgrep, e opzionale args, un array di argomenti da anteporre
  • Default: non impostato, quindi la sandbox usa lo stesso binario ripgrep di Claude Code. Questo è il binario in bundle a meno che tu non imposti USE_BUILTIN_RIPGREP su 0
{
  "sandbox": {
    "ripgrep": {
      "command": "/usr/local/bin/rg"
    }
  }
}

`sandbox.bwrapPath`

Punta la sandbox a un binario bubblewrap installato al di fuori di PATH, come una copia venduta su un host air-gapped. Claude Code usa il percorso sia per il controllo della dipendenza di avvio che quando avvolge ogni comando in sandbox.

  • Scope: Managed. Claude Code lo legge solo dalle impostazioni gestite in modo che un file utente, progetto o locale non possa puntare la sandbox a un binario diverso.
  • Type: string, un percorso assoluto; Claude Code scarta un percorso relativo e ricade sulla ricerca PATH
  • Default: non impostato, quindi Claude Code trova bwrap su PATH
{
  "sandbox": {
    "enabled": true,
    "bwrapPath": "/opt/admin/bwrap"
  }
}

Solo Linux e WSL2.

`sandbox.socatPath`

Punta il proxy di rete della sandbox a un binario socat installato al di fuori di PATH.

  • Scope: Managed
  • Type: string, un percorso assoluto; Claude Code scarta un percorso relativo e ricade sulla ricerca PATH
  • Default: non impostato, quindi Claude Code trova socat su PATH
{
  "sandbox": {
    "enabled": true,
    "socatPath": "/opt/admin/socat"
  }
}

Solo Linux e WSL2.

`sandbox.credentials`

Dichiara i file di credenziali e le variabili di ambiente da proteggere dai comandi in sandbox. Ogni voce nomina un file path o una variabile name e una mode: deny nasconde la credenziale all'interno della sandbox, e mask mostra ai comandi in sandbox un segnaposto mentre il proxy della sandbox sostituisce il valore reale sulle richieste in uscita. Claude Code protegge solo le voci che elenchi; non c'è un elenco di negazione di credenziali incorporato. Richiede Claude Code v2.1.187 o successivo.

  • Scope: Any file. Claude Code onora le voci mask, allowPlaintextInject, awsPairs e sigv4 solo dalle impostazioni utente, dalle impostazioni gestite e dal flag --settings.
  • Type: object con files, envVars, allowPlaintextInject, awsPairs e sigv4
  • Default: non impostato, quindi nessuna credenziale è protetta

Questo nasconde il tuo file di credenziali AWS e rimuove GITHUB_TOKEN dai comandi in sandbox:

{
  "sandbox": {
    "credentials": {
      "files": [{ "path": "~/.aws/credentials", "mode": "deny" }],
      "envVars": [{ "name": "GITHUB_TOKEN", "mode": "deny" }]
    }
  }
}

La protezione del file deny fa parte del livello del filesystem, quindi non si applica quando disabiliti l'isolamento del filesystem; la protezione della variabile di ambiente continua comunque. Richiede Claude Code v2.1.187 o successivo.

Voci di credenziali non valide nelle impostazioni gestite

Quando una voce sandbox.credentials gestita non supera la convalida, Claude Code continua a proteggere la credenziale dove può:

  • Una voce in files o envVars che ha ancora un path o name valido e una mode di mask o deny, come una il cui pattern extract non ha un gruppo di cattura, è degradata a mode: "deny" con un avviso, quindi la credenziale rimane bloccata, non mascherata, finché non fissi la voce. Una voce files degradata fissa filesystem.disabled come una voce deny esplicita, e l'avviso nota che il suo blocco di lettura non è applicato se le impostazioni gestite disattivano l'isolamento del filesystem.
  • Una voce con una mode sconosciuta o un path o name non valido è rimossa.
  • Ogni caso avvisa; che una voce sia degradata o rimossa, le voci valide rimanenti sono ancora applicate, e un valore credentials interamente non valido viene scartato mentre il resto di sandbox si applica comunque.

Si applica nella v2.1.191 e successivo; prima della v2.1.221, ogni voce non valida era rimossa. Per le altre chiavi gestite con gestione per campo, vedi Invalid entries in managed settings.

`sandbox.credentials.files`

Proteggi i file o le directory di credenziali dai comandi in sandbox. Con "mode": "deny", Claude Code blocca le letture del percorso all'interno della sandbox, lo stesso blocco di lettura di sandbox.filesystem.denyRead. Con "mode": "mask", i comandi in sandbox su Linux e WSL2 leggono una copia sentinella del file, e il proxy della sandbox sostituisce il valore reale sulle richieste in uscita a injectHosts di quella voce; su macOS il file è illeggibile all'interno della sandbox invece. Richiede Claude Code v2.1.187 o successivo, e "mode": "mask" richiede v2.1.221 o successivo.

  • Scope: Any file. Claude Code scarta le voci mask da .claude/settings.json del progetto e da .claude/settings.local.json locale.
  • Type: array di object, ognuno con path e una mode di "deny" o "mask", più i campi mask opzionali per i file
  • Default: non impostato, quindi nessun file di credenziali è protetto

Questo nasconde il tuo file di credenziali AWS e maschera il file host gh, sostituendo il valore reale solo sulle richieste a api.github.com:

{
  "sandbox": {
    "credentials": {
      "files": [
        { "path": "~/.aws/credentials", "mode": "deny" },
        { "path": "~/.config/gh/hosts.yml", "mode": "mask", "injectHosts": ["api.github.com"] }
      ]
    }
  }
}

I percorsi usano gli stessi prefissi delle impostazioni sandbox.filesystem.*, e Claude Code unisce gli array da ogni ambito di impostazioni che la sessione carica. Protect credentials copre cosa si applica ancora dalle fonti che escludi con --setting-sources. Richiede Claude Code v2.1.187 o successivo; le voci mask richiedono v2.1.221 o successivo.

La sostituzione mask viene eseguita solo attraverso il proxy della sandbox, quindi imposta sandbox.network.tlsTerminate, o allowPlaintextInject per le reti di test HTTP semplice. mask si applica a un singolo file, quindi elenca ogni file di credenziali individualmente. Claude Code accetta ma ignora i campi mask su una voce deny. Mask credential files copre quali fonti di impostazioni sono onorate e quando una voce ricade a deny.

Campi mask per i file

Una voce mask accetta questi campi opzionali. Senza extract o decode, Claude Code sostituisce l'intero contenuto del file con un sentinella. Su macOS con isolamento del filesystem attivo, Claude Code applica una voce mask come deny prima che extract o decode venga eseguito; vedi Mask credential files.

Campo Tipo Cosa fa
extract string, un'espressione regolare con almeno un gruppo di cattura Maschera solo il testo catturato dal gruppo 1 di ogni corrispondenza, quindi il resto del file rimane analizzabile. Con decode anche impostato, Claude Code controlla ogni cattura come un possibile JWT invece di sostituirlo direttamente. Richiede v2.1.221 o successivo
onExtractNoMatch "warn", "deny" o "error"; predefinito "warn" Cosa succede quando extract o decode non trova nulla da mascherare. warn lascia il file leggibile così com'è all'interno della sandbox, deny lo rende illeggibile, e error ferma la configurazione della sandbox finché non fissi la configurazione. Claude Code tratta deny come error quando il blocco di lettura non sarebbe applicato, perché disabiliti l'isolamento del filesystem o una voce sandbox.filesystem.allowRead riapre il percorso. Richiede v2.1.221 o successivo; il caso decode richiede v2.1.224 o successivo
decode la string "jwt" Trova JSON Web Token (JWT) nel file, con un pattern incorporato o con extract quando impostato, verifica ogni candidato, e sostituiscilo con un token falso strutturalmente valido, quindi il codice all'interno della sandbox che decodifica il token continua a funzionare. Quando nessun candidato verifica, onExtractNoMatch governa il risultato. Richiede v2.1.224 o successivo
maskClaims array di stringhe, almeno un nome di claim; richiede decode Maschera solo i claim di payload di primo livello denominati all'interno di ogni JWT verificato e ricostruisci il token attorno al payload modificato, quindi gli altri claim rimangono leggibili. Quando nessun claim denominato corrisponde, onExtractNoMatch governa il risultato. Richiede v2.1.224 o successivo
maskDuplicates Boolean, predefinito false Sostituisci anche copie verbatim di ogni valore mascherato altrove nel file, come un segreto incollato in un commento. Claude Code corrisponde a sottostringhe grezze, quindi riservalo per segreti lunghi e ad alta entropia. Consultato solo quando extract o decode è impostato. Richiede v2.1.221 o successivo
injectHosts array di stringhe, ognuno un host che sandbox.network.allowedDomains ammette anche Restringi gli host dove il proxy della sandbox sostituisce il valore reale. Quando non impostato, il proxy lo sostituisce sulle richieste a ogni host in sandbox.network.allowedDomains. Richiede v2.1.221 o successivo

Questo maschera solo il valore oauth_token nel file host gh, sostituisce ogni altra copia di esso nel file, rende il file illeggibile se il pattern non corrisponde a nulla, e sostituisce il token reale solo sulle richieste a api.github.com:

{
  "sandbox": {
    "credentials": {
      "files": [
        {
          "path": "~/.config/gh/hosts.yml",
          "mode": "mask",
          "extract": "oauth_token:\\s*(\\S+)",
          "maskDuplicates": true,
          "onExtractNoMatch": "deny",
          "injectHosts": ["api.github.com"]
        }
      ]
    }
  }
}

`sandbox.credentials.envVars`

Proteggi le variabili di ambiente dai comandi in sandbox. Con "mode": "deny", Claude Code rimuove la variabile dall'ambiente dei comandi in sandbox. Con "mode": "mask", i comandi in sandbox vedono un valore sentinella per sessione, e il proxy della sandbox sostituisce il valore reale sulle richieste in uscita a injectHosts di quella voce, quindi gli strumenti come gh e npm continuano ad autenticarsi senza mai tenere la credenziale reale. Richiede Claude Code v2.1.187 o successivo, e "mode": "mask" richiede v2.1.199 o successivo.

  • Scope: Any file. Claude Code scarta le voci mask da .claude/settings.json del progetto e da .claude/settings.local.json locale.
  • Type: array di object, ognuno con name e una mode di "deny" o "mask", più i campi mask opzionali per le variabili di ambiente
  • Default: non impostato, quindi nessuna variabile di ambiente è protetta

Questo rimuove NPM_TOKEN dai comandi in sandbox e maschera GITHUB_TOKEN, sostituendo il valore reale solo sulle richieste a api.github.com:

{
  "sandbox": {
    "credentials": {
      "envVars": [
        { "name": "NPM_TOKEN", "mode": "deny" },
        { "name": "GITHUB_TOKEN", "mode": "mask", "injectHosts": ["api.github.com"] }
      ]
    }
  }
}

Il name deve iniziare con una lettera o un underscore e contenere solo lettere, cifre e underscore. Claude Code unisce gli array da ogni ambito di impostazioni che la sessione carica, e applica deny quando la stessa variabile appare con entrambe le modalità. Protect credentials copre cosa si applica ancora dalle fonti che escludi con --setting-sources. Richiede Claude Code v2.1.187 o successivo; le voci mask richiedono v2.1.199 o successivo.

La sostituzione mask viene eseguita solo attraverso il proxy della sandbox, quindi imposta sandbox.network.tlsTerminate, o allowPlaintextInject per le reti di test HTTP semplice; vedi Mask environment variables. Claude Code accetta ma ignora i campi mask su una voce deny.

Campi mask per le variabili di ambiente

Una voce mask accetta questi campi opzionali. Senza extract o decode, Claude Code sostituisce l'intero valore con un sentinella. extract e decode non possono essere combinati sulla stessa voce.

Campo Tipo Cosa fa
extract string, un'espressione regolare con almeno un gruppo di cattura Maschera solo il testo catturato dal gruppo 1 di ogni corrispondenza, come la password all'interno di una stringa di connessione DATABASE_URL, quindi il resto del valore rimane analizzabile. Richiede v2.1.224 o successivo
onExtractNoMatch "warn", "deny" o "error"; predefinito "warn". Su una voce con decode, solo "warn" è accettato Cosa succede quando extract non corrisponde a nulla. warn passa la variabile attraverso senza mascherare, deny la annulla all'interno della sandbox, e error ferma la configurazione della sandbox finché non fissi la configurazione. Richiede v2.1.224 o successivo
decode la string "jwt" Verifica che l'intero valore sia un JWT e sostituiscilo con un token falso strutturalmente valido, quindi il codice all'interno della sandbox che decodifica il token continua a funzionare; il proxy sostituisce l'intero token reale all'uscita. Un valore che non verifica passa attraverso senza mascherare con un avviso. Richiede v2.1.224 o successivo
maskClaims array di stringhe, almeno un nome di claim; richiede decode Maschera solo i claim di payload di primo livello denominati all'interno del JWT decodificato e ricostruisci il token attorno al payload modificato, quindi gli altri claim rimangono leggibili. Quando nessun claim denominato corrisponde, la variabile passa attraverso senza mascherare con un avviso. Richiede v2.1.224 o successivo
injectHosts array di stringhe, ognuno un host che sandbox.network.allowedDomains ammette anche Restringi gli host dove il proxy della sandbox sostituisce il valore reale. Quando non impostato, il proxy lo sostituisce sulle richieste a ogni host in sandbox.network.allowedDomains. Scrivi una destinazione IPv6 come l'indirizzo compresso nudo, come "::1", non la forma tra parentesi; vedi IPv6 destinations in injectHosts. Richiede v2.1.199 o successivo

Questo maschera solo la password all'interno di DATABASE_URL, annulla la variabile se il pattern non corrisponde a nulla, e maschera un JWT in SERVICE_JWT mentre lascia ogni claim tranne api_key leggibile:

{
  "sandbox": {
    "credentials": {
      "envVars": [
        {
          "name": "DATABASE_URL",
          "mode": "mask",
          "extract": "://[^:]+:([^@]+)@",
          "onExtractNoMatch": "deny"
        },
        {
          "name": "SERVICE_JWT",
          "mode": "mask",
          "decode": "jwt",
          "maskClaims": ["api_key"]
        }
      ]
    }
  }
}

`sandbox.credentials.allowPlaintextInject`

Consenti la sostituzione mask anche sulle richieste HTTP semplice oltre a HTTPS con terminazione TLS. Su HTTP semplice l'identità upstream non è verificata e la credenziale viaggia in testo in chiaro, quindi lascia questo disattivato al di fuori delle reti di test affidabili. Richiede Claude Code v2.1.199 o successivo.

  • Scope: User or managed
  • Type: Boolean
    • true: Claude Code consente la sostituzione mask anche sulle richieste HTTP semplice oltre a HTTPS con terminazione TLS
    • false: Claude Code consente la sostituzione mask solo su HTTPS con terminazione TLS
  • Default: false
{
  "sandbox": {
    "credentials": {
      "allowPlaintextInject": true
    }
  }
}

Richiede Claude Code v2.1.199 o successivo.

`sandbox.credentials.awsPairs`

Raggruppa le variabili di ambiente mascherate che formano una credenziale AWS per la ri-firma SigV4 quando la tua credenziale vive in variabili con nomi non standard. Claude Code collega automaticamente il trio convenzionale AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY e AWS_SESSION_TOKEN quando mascheri i loro interi valori, quindi hai bisogno di questa chiave solo per altri nomi. Richiede Claude Code v2.1.224 o successivo.

  • Scope: User or managed
  • Type: array di object, ognuno con accessKeyIdVar, secretAccessKeyVar e opzionalmente sessionTokenVar, nominando le voci sandbox.credentials.envVars
  • Default: non impostato, quindi solo il trio convenzionale è accoppiato

Questo collega tre variabili con nomi personalizzati in una credenziale AWS per la ri-firma:

{
  "sandbox": {
    "credentials": {
      "awsPairs": [
        {
          "accessKeyIdVar": "MY_KEY_ID",
          "secretAccessKeyVar": "MY_SECRET_KEY",
          "sessionTokenVar": "MY_SESSION_TOKEN"
        }
      ]
    }
  }
}

Ogni variabile denominata deve essere una voce mask di valore intero in sandbox.credentials.envVars, senza extract o decode, e può riempire solo uno slot in tutte le coppie.

`sandbox.credentials.sigv4`

Scegli cosa fa il proxy della sandbox con i moduli di richiesta AWS che non può ri-firmare: streaming per i caricamenti di streaming aws-chunked, presigned per gli URL pre-firmati, e sigv4a per le firme asimmetriche SigV4A. Questo si applica solo alle richieste firmate con l'ID della chiave di accesso segnaposto di una coppia mascherata. Richiede Claude Code v2.1.224 o successivo.

  • Scope: User or managed
  • Type: object con streaming, presigned e sigv4a, ognuno uno di:
    • "deny": il proxy fallisce la richiesta
    • "passthrough": il proxy invia la richiesta firmata con il segnaposto mascherato, quindi lo strumento riceve il rifiuto di AWS
  • Default: non impostato, quindi ogni modulo è "deny"

Questo invia i caricamenti di streaming invece di farli fallire al proxy:

{
  "sandbox": {
    "credentials": {
      "sigv4": {
        "streaming": "passthrough"
      }
    }
  }
}

Con deny, il proxy fallisce la richiesta. Con passthrough, il proxy invia la richiesta con la sua firma calcolata dal segnaposto mascherato, quindi AWS la rifiuta e lo strumento che chiama riceve la risposta di AWS stessa invece di un errore del proxy.

`sandbox.network`

Controlla quali host, porte e socket i comandi in sandbox possono raggiungere. La sandbox instrada il traffico in uscita attraverso un proxy che applica questi elenchi; vedi Network isolation per come il proxy decide e quando richiede.

  • Scope: Any file. strictAllowlist, allowManagedDomainsOnly e tlsTerminate vengono letti da meno fonti, come dicono le loro voci.
  • Type: object con le sotto-chiavi di seguito
  • Default: non impostato, quindi nessun dominio è pre-consentito e la sandbox richiede per ogni nuovo host

Questo pre-consente GitHub e npm, blocca uploads.github.com e consente ai comandi di associarsi a localhost:

{
  "sandbox": {
    "network": {
      "allowedDomains": ["github.com", "*.npmjs.org"],
      "deniedDomains": ["uploads.github.com"],
      "allowLocalBinding": true
    }
  }
}

Claude Code unisce le sotto-chiavi array in ambiti di impostazioni e le deduplica, quindi un progetto può aggiungere domini al tuo elenco utente. Le regole di autorizzazione WebFetch(domain:...) allow e deny permission rules alimentano gli stessi elenchi allow e deny.

`sandbox.network.allowUnixSockets`

Elenca i percorsi dei socket Unix che i comandi in sandbox possono connettere su macOS. Claude Code ignora questo elenco su Linux e WSL2, dove il filtro seccomp non può ispezionare i percorsi dei socket; usa allowAllUnixSockets invece.

  • Scope: Any file
  • Type: array di stringhe, ognuno un percorso di socket
  • Default: non impostato, quindi la sandbox macOS blocca ogni socket Unix
{
  "sandbox": {
    "network": {
      "allowUnixSockets": ["~/.ssh/agent-socket"]
    }
  }
}

Un percorso di socket può concedere un accesso ampio: consentire /var/run/docker.sock, ad esempio, consente a un comando in sandbox di controllare il daemon Docker. Vedi Security limitations.

`sandbox.network.allowAllUnixSockets`

Consenti ai comandi in sandbox di connettersi a ogni socket Unix. Su Linux e WSL2, il filtro seccomp della sandbox blocca le chiamate socket(AF_UNIX, ...), quindi questo è l'unico modo per consentire i socket Unix lì. Quando il filtro è mancante, che /sandbox segnala sulla sua scheda Dependencies, la sandbox non blocca le chiamate ai socket Unix. Vedi Set up Linux and WSL2 per dove viene il filtro.

  • Scope: Any file
  • Type: Boolean
    • true: i comandi in sandbox possono connettersi a ogni socket Unix
    • false: la sandbox blocca le connessioni ai socket Unix: su macOS tranne i percorsi in allowUnixSockets, e su Linux e WSL2 attraverso il filtro seccomp quando è presente
  • Default: false
{
  "sandbox": {
    "network": {
      "allowAllUnixSockets": true
    }
  }
}

Su WSL2, true riapre anche il socket interop che lancia binari Windows come cmd.exe e powershell.exe.

`sandbox.network.allowLocalBinding`

Consenti ai comandi in sandbox di associarsi alle porte localhost su macOS, ad esempio per avviare un server di sviluppo.

  • Scope: Any file
  • Type: Boolean
    • true: i comandi in sandbox possono associarsi alle porte localhost su macOS
    • false: i comandi in sandbox su macOS non possono associarsi alle porte localhost
  • Default: false
{
  "sandbox": {
    "network": {
      "allowLocalBinding": true
    }
  }
}

`sandbox.network.allowMachLookup`

Elenca i nomi di servizio XPC e Mach aggiuntivi che la sandbox macOS può cercare. Gli strumenti che comunicano su XPC, come il Simulatore iOS o Playwright, hanno bisogno che i loro servizi siano elencati qui.

  • Scope: Any file
  • Type: array di stringhe, ognuno un nome di servizio; un singolo * finale corrisponde a un prefisso, e "*" da solo corrisponde a ogni servizio
  • Default: non impostato

Questo consente ogni servizio sotto il prefisso com.apple.coresimulator.:

{
  "sandbox": {
    "network": {
      "allowMachLookup": ["com.apple.coresimulator.*"]
    }
  }
}

`sandbox.network.allowedDomains`

Pre-consenti i domini per il traffico in uscita dai comandi in sandbox, quindi la sandbox non li richiede. I wildcard come *.example.com corrispondono ai sottodomini, e un suffisso opzionale :port limita una voce a una porta; una voce senza una porta corrisponde a ogni porta.

  • Scope: Any file. Solo impostazioni gestite quando allowManagedDomainsOnly è impostato.
  • Type: array di stringhe, ognuno un dominio, pattern con wildcard o letterale IP, con un suffisso opzionale :port
  • Default: non impostato, quindi la sandbox richiede la prima volta che un comando raggiunge un nuovo host

Questo pre-consente GitHub su ogni porta, ogni sottodominio npm e un host API su porta 443 solo:

{
  "sandbox": {
    "network": {
      "allowedDomains": ["github.com", "*.npmjs.org", "api.example.com:443"]
    }
  }
}

Scrivi i letterali IPv6 tra parentesi, con una porta opzionale: "[::1]" consente ogni porta e "[::1]:443" una porta. La forma tra parentesi richiede Claude Code v2.1.229 o successivo. Vedi IPv6 addresses in domain lists.

`sandbox.network.deniedDomains`

Blocca i domini per il traffico in uscita dai comandi in sandbox, usando la stessa sintassi di wildcard, porta e IPv6 di allowedDomains. Un dominio negato rimane bloccato anche quando una voce allowedDomains lo corrisponde anche.

  • Scope: Any file
  • Type: array di stringhe, ognuno un dominio, pattern con wildcard o letterale IP, con un suffisso opzionale :port
  • Default: non impostato
{
  "sandbox": {
    "network": {
      "deniedDomains": ["sensitive.cloud.example.com"]
    }
  }
}

Claude Code unisce questo elenco da ogni fonte di impostazioni che la sessione carica anche quando allowManagedDomainsOnly è impostato, quindi uno sviluppatore può sempre stringere l'elenco di negazione. Per i letterali IPv6, vedi IPv6 addresses in domain lists.

Una voce scritta con il punto finale che marca un nome di dominio completamente qualificato, come example.com., blocca le stesse connessioni di example.com.

`sandbox.network.strictAllowlist`

Nega ai comandi in sandbox l'accesso agli host al di fuori dell'elenco consentito invece di richiedere l'approvazione. L'elenco consentito è allowedDomains più i domini dalle regole allow WebFetch(domain:...), o solo le voci delle impostazioni gestite quando allowManagedDomainsOnly è impostato. Richiede Claude Code v2.1.219 o successivo.

  • Scope: User or managed. Un repository non può attivarlo o disattivarlo.
  • Type: Boolean
    • true: Claude Code nega ai comandi in sandbox l'accesso agli host al di fuori dell'elenco consentito
    • false: a meno che un altro file di impostazioni affidabile non imposti true, Claude Code decide un host al di fuori dell'elenco consentito in base alla modalità di autorizzazione invece di negarlo direttamente: esegue il classificatore in modalità auto, nega in modalità dontAsk, consente in modalità bypassPermissions e in plan mode quando il bypass è disponibile, e altrimenti ti chiede
  • Default: false
{
  "sandbox": {
    "network": {
      "strictAllowlist": true
    }
  }
}

Claude Code applica questo solo per i comandi in sandbox; gli strumenti in-process come WebFetch seguono comunque le loro regole di autorizzazione. Quando una qualsiasi delle fonti onorate lo imposta su true, rimane attivo. Vedi Network isolation. Richiede Claude Code v2.1.219 o successivo.

`sandbox.network.allowManagedDomainsOnly`

Blocca l'elenco consentito di rete a ciò che le impostazioni gestite definiscono. Claude Code quindi onora solo allowedDomains e le regole allow WebFetch(domain:...) dalle impostazioni gestite, ignora i domini dalle impostazioni utente, progetto, locale e --settings, e blocca automaticamente un dominio non consentito invece di richiedere.

  • Scope: Managed
  • Type: Boolean
    • true: Claude Code onora solo allowedDomains e le regole allow WebFetch(domain:...) dalle impostazioni gestite e blocca automaticamente un dominio non consentito invece di richiedere
    • false: i domini dalle impostazioni utente, progetto, locale e --settings si uniscono all'elenco consentito
  • Default: false

Questo blocca l'elenco consentito a GitHub e npm e ignora qualsiasi dominio che gli sviluppatori aggiungono:

{
  "sandbox": {
    "network": {
      "allowManagedDomainsOnly": true,
      "allowedDomains": ["github.com", "*.npmjs.org"]
    }
  }
}

I domini negati si uniscono comunque da ogni fonte che la sessione carica. Vedi Keep developers from widening the policy.

`sandbox.network.httpProxyPort`

Punta la sandbox al tuo proxy HTTP invece di quello che Claude Code esegue. Le organizzazioni lo fanno per ispezionare il traffico HTTPS, applicare le loro regole di filtro o registrare ogni richiesta. Quando non impostato, Claude Code avvia il suo proxy per il traffico HTTP.

  • Scope: Any file
  • Type: number, una porta TCP locale
  • Default: non impostato, quindi Claude Code esegue il suo proxy
{
  "sandbox": {
    "network": {
      "httpProxyPort": 8080
    }
  }
}

Imposta anche socksProxyPort se il tuo proxy dovrebbe portare il traffico SOCKS anche; con solo uno dei due impostato, Claude Code continua a eseguire il suo proxy per l'altro protocollo. Vedi Custom proxy configuration.

`sandbox.network.socksProxyPort`

Punta la sandbox al tuo proxy SOCKS5 invece di quello che Claude Code esegue. Quando non impostato, Claude Code avvia il suo proxy per il traffico SOCKS.

  • Scope: Any file
  • Type: number, una porta TCP locale
  • Default: non impostato, quindi Claude Code esegue il suo proxy
{
  "sandbox": {
    "network": {
      "socksProxyPort": 8081
    }
  }
}

Vedi Custom proxy configuration.

`sandbox.network.tlsTerminate`

Fai terminare il proxy della sandbox TLS in modo che possa leggere i contenuti delle richieste HTTPS. Questo è sperimentale, e la sostituzione di credenziali mask lo richiede. Imposta {} per generare un'autorità di certificazione effimera per la sessione, o imposta caCertPath e caKeyPath per usare la tua.

  • Scope: User or managed. Un repository non può attivarlo o fornire un'autorità di certificazione.
  • Type: object con stringhe opzionali caCertPath e caKeyPath, ognuno un percorso di file
  • Default: non impostato, quindi il proxy non termina o ispeziona TLS
{
  "sandbox": {
    "network": {
      "tlsTerminate": {}
    }
  }
}

Quando più di una fonte onorata lo imposta, Claude Code usa il valore dalla fonte con la precedenza più alta: impostazioni gestite, quindi il flag --settings, quindi impostazioni utente. Richiede Claude Code v2.1.199 o successivo.

Memoria e contesto

Controlla cosa Claude Code carica nel contesto, come lo compatta e dove mantiene la memoria e i piani. Vedi Gestisci contesto e Memoria.

`autoCompactEnabled`

Fai in modo che Claude Code compatti la conversazione automaticamente quando il contesto si avvicina al limite. Appare in /config come Auto-compact, e attivarlo/disattivarlo lì scrive questa chiave nelle tue impostazioni utente.

  • Scope: Any file
  • Type: Boolean
    • true: Claude Code compatta la conversazione automaticamente quando il contesto si avvicina al limite
    • false: Claude Code non compatta automaticamente
  • Default: true
  • Per-session overrides: DISABLE_AUTO_COMPACT disattiva l'auto-compact per una sessione; quale dei due lo disattiva, l'altro non può riattivarlo
{
  "autoCompactEnabled": false
}

Il comando manuale /compact continua a funzionare mentre l'auto-compact è disattivato.

`autoCompactWindow`

Imposta quanto pieno diventa il contesto prima che Claude Code compatti automaticamente.

  • Scope: Any file
  • Type: numero di token, da 100000 a 1000000. Claude Code limita il valore alla finestra di contesto del tuo modello; la panoramica dei modelli elenca la finestra di ogni modello
  • Default: non impostato, quindi Claude Code sceglie una finestra ottimizzata per il tuo modello
  • Per-session overrides: --autocompact ha la precedenza su questa chiave per una sessione, e CLAUDE_CODE_AUTO_COMPACT_WINDOW ha la precedenza su entrambi
{
  "autoCompactWindow": 500000
}

Impostalo con il comando /autocompact, che scrive questa chiave nelle tue impostazioni utente. Imposta la finestra di auto-compact spiega come il comando, il flag, la variabile e l'impostazione interagiscono.

`autoMemoryDirectory`

Archivia la memoria automatica in una directory di tua scelta invece del valore predefinito per progetto.

  • Scope: Any file
  • Type: stringa, un percorso di directory assoluto o con prefisso ~/
  • Default: non impostato, quindi Claude Code utilizza ~/.claude/projects/<project>/memory/
{
  "autoMemoryDirectory": "~/my-memory-dir"
}

Dalle impostazioni di progetto o locali, Claude Code rispetta questa chiave secondo la stessa regola di fiducia dell'area di lavoro degli hook, poiché un repository clonato può fornire questi file.

`autoMemoryEnabled`

Attiva o disattiva la memoria automatica. Quando false, Claude non legge da o scrive nella directory di memoria automatica. Puoi anche attivarlo/disattivarlo con /memory durante una sessione, che scrive questa chiave nelle tue impostazioni utente.

  • Scope: Any file
  • Type: Boolean
    • true: lo stesso di non impostato; la memoria automatica rimane attiva a meno che qualcosa che ha la precedenza su questa chiave non la disattivi per la sessione, come --bare, modalità sicura, o CLAUDE_CODE_DISABLE_AUTO_MEMORY
    • false: Claude non legge da o scrive nella directory di memoria automatica
  • Default: true
  • Per-session overrides: CLAUDE_CODE_DISABLE_AUTO_MEMORY ha la precedenza su questa chiave per una sessione, in entrambe le direzioni
{
  "autoMemoryEnabled": false
}

`bashOutputMaxChars`

Imposta quanti caratteri dell'output di un comando Bash o PowerShell riuscito Claude riceve inline. Quando l'output supera il limite, Claude Code lo salva in un file e Claude riceve un'anteprima breve più il percorso del file. Aumenta il limite quando l'output del comando, come una build dettagliata o un log completo della suite di test, regolarmente supera il valore predefinito e vuoi che Claude lo legga senza aprire il file. Richiede Claude Code v2.1.261 o successivo.

  • Scope: Any file
  • Type: numero di caratteri, un intero positivo. Claude Code limita il valore nell'intervallo 4000 a 128000
  • Default: non impostato, quindi Claude riceve fino a 30.000 caratteri inline
{
  "bashOutputMaxChars": 100000
}

Quando imposti questa chiave, Claude Code ignora la variabile di ambiente BASH_MAX_OUTPUT_LENGTH.

`claudeMd`

Inietta istruzioni in stile CLAUDE.md come memoria gestita dall'organizzazione senza distribuire un file separato. Claude Code carica il testo come voce di memoria gestita prima dei file CLAUDE.md utente e di progetto.

  • Scope: Managed
  • Type: stringa, il testo di un file CLAUDE.md; scrivilo come faresti con il file, Markdown incluso, con interruzioni di riga come \n
  • Default: non impostato

Questo esempio distribuisce due regole come un breve elenco Markdown:

{
  "claudeMd": "# Engineering rules\n\n- Always run make lint before committing.\n- Never push directly to main."
}

Vedi Distribuisci CLAUDE.md a livello di organizzazione.

`claudeMdExcludes`

Salta file CLAUDE.md specifici quando Claude Code carica la memoria. In un grande monorepo, usalo per saltare file CLAUDE.md da altri team che non sono rilevanti per il tuo lavoro; Escludi file CLAUDE.md irrilevanti nella guida dei grandi codebase spiega quel caso. I pattern corrispondono ai percorsi di file assoluti.

  • Scope: Any file
  • Type: array di stringhe, ciascuna un pattern glob o un percorso assoluto
  • Default: non impostato, quindi Claude Code carica ogni CLAUDE.md che trova
{
  "claudeMdExcludes": ["**/vendor/**/CLAUDE.md"]
}

Le esclusioni si applicano solo ai file di memoria utente, progetto e locale; i file CLAUDE.md della politica gestita non possono essere esclusi.

`env`

Imposta variabili di ambiente per ogni sessione e per i sottoprocessi che Claude Code avvia da essa. Qualsiasi variabile nel riferimento delle variabili di ambiente può andare qui, che è come applichi una a ogni sessione o la distribuisci al tuo team.

  • Scope: Any file
  • Type: oggetto che mappa i nomi delle variabili ai valori stringa
  • Default: non impostato

Questo esempio disattiva la compattazione automatica e instrada le richieste API attraverso un proxy:

{
  "env": {
    "DISABLE_AUTO_COMPACT": "1",
    "ANTHROPIC_BASE_URL": "https://proxy.example.com"
  }
}

Come i valori di `env` interagiscono con la tua shell

  • Un valore qui sovrascrive la stessa variabile esportata nella tua shell, e quando più di un file di impostazioni imposta una variabile, si applica quello con la precedenza più alta.
  • Per annullare un'esportazione della shell, imposta la variabile su "". Claude Code tratta un valore vuoto come non impostato per la selezione del provider, e i sottoprocessi ereditano 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.
  • I valori qui sono testo semplice nel file di impostazioni e raggiungono ogni sottoprocesso che Claude Code avvia. Per un token bearer OTLP che ruota, usa otelHeadersHelper; per le credenziali API, usa apiKeyHelper.

Quando Claude Code applica i valori di `env`

  • Dalle impostazioni utente, --settings e impostazioni gestite: all'avvio, e di nuovo nella sessione in esecuzione quando una modifica salvata altera l'env unito.
  • Dalle impostazioni di progetto e locali: dopo che hai fiducia dell'area di lavoro, o all'avvio in modalità -p, che non mostra mai la finestra di dialogo di fiducia, e di nuovo quando una modifica salvata altera l'env unito.
  • Variabili che Claude Code classifica come sicure, come la selezione del modello, timeout e limiti, interruttori di funzionalità e impostazioni di telemetria: all'avvio da ogni file di impostazioni, a parte le variabili che le impostazioni di progetto e locali non possono impostare.
  • Dopo che sposti la sessione con /cd su v2.1.246 o successivo: i valori di env della nuova directory di progetto e locali, in aggiunta a quelli della directory precedente.

Variabili che Claude Code ignora in `env`

  • Le impostazioni di progetto e locali non possono impostare variabili che un repository estratto non dovrebbe controllare; impostale nella tua shell, impostazioni utente o impostazioni gestite invece. Claude Code elimina ciascuna e registra un avviso che puoi vedere con claude --debug. Includono:

    • Variabili che scelgono dove Claude Code archivia o scrive i suoi file: CLAUDE_CONFIG_DIR, CLAUDE_CODE_TMPDIR e le variabili di directory del sistema operativo come HOME, TMPDIR, TMP, TEMP e la famiglia XDG_*.
    • Variabili che esportano il contenuto della sessione: OTEL_LOG_RAW_API_BODIES e la coppia di tracciamento beta dettagliata ENABLE_BETA_TRACING_DETAILED e BETA_TRACING_ENDPOINT.
    • Variabili che cambiano come Claude Code si avvia o si sincronizza, come CLAUDE_CODE_PROCESS_WRAPPER, CLAUDE_CODE_SYNC_SKILLS, CLAUDE_CODE_SYNC_PLUGINS, CLAUDE_CODE_PLUGIN_CACHE_DIR e CLAUDE_CODE_PLUGIN_SEED_DIR.

    Prima di v2.1.251, le impostazioni di progetto e locali potevano impostare ogni variabile che questo elenco nomina tranne HOME, XDG_CONFIG_HOME e le variabili che cambiano come Claude Code si avvia o si sincronizza.

  • Variabili di identità che gli ambienti di hosting di Claude Code possiedono, come CLAUDE_CODE_REMOTE e CLAUDE_CODE_ACCOUNT_UUID, sono ignorate da ogni file.

  • CLAUDE_CODE_MESSAGING_SOCKET e CLAUDE_CODE_MESSAGING_TOKEN, che Claude Code esporta stesso, sono ignorate da ogni file. Ignorare la variabile socket richiede Claude Code v2.1.224 o successivo, e ignorare il token richiede v2.1.228 o successivo.

  • CLAUDE_CODE_PROJECT_DIR_NAME, che Claude Code legge solo dall'ambiente di avvio, è ignorata da ogni file; richiede v2.1.234 o successivo.

  • CLAUDE_CODE_RESTRICTED, che Claude Code legge solo dall'ambiente di avvio, è ignorata da ogni file.

`fileCheckpointingEnabled`

Fai in modo che Claude Code crei snapshot dei file prima di ogni modifica in modo che /rewind possa ripristinarli. Appare in /config come Rewind code (checkpoints), e attivarlo/disattivarlo lì scrive questa chiave nelle tue impostazioni utente.

  • Scope: Any file
  • Type: Boolean
    • true: Claude Code crea snapshot dei file prima di ogni modifica in modo che /rewind possa ripristinarli
    • false: Claude Code non crea snapshot dei file, quindi /rewind non può ripristinarli
  • Default: true
  • Per-session overrides: CLAUDE_CODE_DISABLE_FILE_CHECKPOINTING disattiva il checkpointing per una sessione; quale dei due lo disattiva, l'altro non può riattivarlo
{
  "fileCheckpointingEnabled": false
}

In un'esecuzione -p o una sessione Agent SDK, Claude Code ignora questa chiave. L'SDK attiva il checkpointing con la sua opzione enableFileCheckpointing, e un'esecuzione -p nuda ha bisogno di CLAUDE_CODE_ENABLE_SDK_FILE_CHECKPOINTING=true. Vedi File checkpointing in Agent SDK.

`plansDirectory`

Scegli dove Claude Code archivia i file di piano che scrive in plan mode. Claude Code risolve il percorso relativo alla radice del progetto e mantiene il valore predefinito quando il percorso si risolve al di fuori di esso.

  • Scope: Any file
  • Type: stringa, un percorso relativo alla radice del progetto
  • Default: non impostato, quindi Claude Code utilizza ~/.claude/plans
{
  "plansDirectory": "./plans"
}

`skillListingBudgetFraction`

Ogni turno, Claude vede un elenco delle tue skill con le loro descrizioni, e Claude Code limita quell'elenco a una quota della finestra di contesto. Quando l'elenco supera il limite, Claude Code mantiene il nome di ogni skill ma elimina le descrizioni delle skill meno utilizzate, in modo che Claude possa ancora invocare quelle skill ma è meno probabile che ne scelga una da solo. Aumenta questa chiave per mantenere più descrizioni visibili al costo di più contesto per turno.

  • Scope: Any file
  • Type: numero, una frazione maggiore di 0 e al massimo 1
  • Default: 0.01, che riserva l'1% della finestra di contesto
{
  "skillListingBudgetFraction": 0.02
}

Per vedere quanto contesto utilizza l'elenco e quali skill contribuiscono di più, esegui /doctor.

`skillListingMaxDescChars`

Ogni turno, Claude vede un elenco delle tue skill che mostra il testo description e when_to_use di ogni skill. Questa chiave limita quanti caratteri di quel testo Claude Code mostra per skill; il testo più lungo viene tagliato al limite.

  • Scope: Any file
  • Type: numero di caratteri, un intero positivo
  • Default: 1536
{
  "skillListingMaxDescChars": 2048
}

Aumentalo per mantenere le descrizioni lunghe intatte al costo di più contesto per turno; abbassalo per adattare più skill sotto skillListingBudgetFraction.

`taskOutputMaxChars`

Imposta quanti caratteri dell'output di un compito in background Claude riceve inline quando Claude legge il compito con lo strumento TaskOutput. Quando l'output di un compito terminato è più lungo, Claude riceve i caratteri più recenti. Aumenta il limite quando i tuoi compiti in background producono regolarmente più output del valore predefinito. Richiede Claude Code v2.1.261 o successivo.

  • Scope: Any file
  • Type: numero di caratteri, un intero positivo. Claude Code limita il valore nell'intervallo 4000 a 128000
  • Default: non impostato, quindi Claude riceve fino a 32.000 caratteri inline
{
  "taskOutputMaxChars": 100000
}

Quando imposti questa chiave, Claude Code ignora la variabile di ambiente TASK_MAX_OUTPUT_LENGTH.

Interfaccia e terminale

Cambia come Claude Code appare e si comporta nel tuo terminale: tema, modalità editor, riga di stato, spinner, notifiche all'interno della sessione e accessibilità. Vedi Configurazione del terminale.

`askUserQuestionTimeout`

Consenti a una finestra di dialogo AskUserQuestion senza risposta di continuare automaticamente dopo un periodo di inattività, inviando qualsiasi opzione tu avessi già selezionato. Impostalo quando ti allontani e vuoi che Claude continui senza di te. Con l'impostazione predefinita, le domande attendono fino a quando non le rispondi. Richiede Claude Code v2.1.200 o successivo.

  • Scope: User or managed
  • Type: string, uno di "60s", "5m", "10m", o "never"
  • Default: "never"
  • Per-session overrides: CLAUDE_AFK_TIMEOUT_MS ha la precedenza su questa chiave per una sessione
{
  "askUserQuestionTimeout": "5m"
}

Appare in /config come Question auto-continue timeout, che scrive questa chiave nelle impostazioni utente; Claude Code nasconde la riga mentre le impostazioni gestite o il flag --settings impostano la chiave. Richiede Claude Code v2.1.200 o successivo.

`autoContinueAtUsageLimit`

Dopo che un limite di utilizzo di claude.ai interrompe la tua sessione, attendi nella sessione aperta e continua l'attività automaticamente dopo il ripristino. Vedi Disattiva continuazione automatica. Richiede Claude Code v2.1.234 o successivo.

  • Scope: User or managed. Leggi dalle impostazioni utente, --settings e impostazioni gestite solo. Quando nessuno di questi imposta la chiave, un file di impostazioni di progetto o locale che la imposta disattiva la funzione piuttosto che essere ignorato.
  • Type: Boolean
    • true: dopo che un limite di utilizzo di claude.ai interrompe la tua sessione, Claude Code attende nella sessione aperta e continua l'attività automaticamente dopo il ripristino
    • false: Claude Code non avvia l'attesa da solo. Puoi comunque avviare un'attesa tu stesso dal menu delle opzioni del limite di utilizzo
  • Default: true
{
  "autoContinueAtUsageLimit": false
}

Appare in /config come Continue automatically at usage limit, che scrive questa chiave nelle impostazioni utente; Claude Code nasconde la riga mentre le impostazioni gestite o il flag --settings impostano la chiave.

`autoScrollEnabled`

Segui il nuovo output fino in fondo alla conversazione nel rendering a schermo intero. Disattivalo per rimanere dove hai fatto scorrere mentre Claude continua a lavorare; i prompt di autorizzazione scorrono comunque in vista.

  • Scope: Any file
  • Type: Boolean
    • true: la conversazione segue il nuovo output fino in fondo
    • false: rimani dove hai fatto scorrere mentre Claude continua a lavorare; i prompt di autorizzazione appaiono comunque sotto la trascrizione
  • Default: true
{
  "autoScrollEnabled": false
}

Appare in /config come Auto-scroll quando il rendering a schermo intero è attivo, che scrive questa chiave nelle impostazioni utente.

`axScreenReader`

Renderizza output compatibile con i lettori di schermo: testo piatto senza bordi decorativi o animazioni. La modalità lettore di schermo utilizza il renderer classico, quindi l'impostazione tui non ha effetto mentre è attiva; le sessioni in background allegate eseguono comunque il rendering a schermo intero. Richiede Claude Code v2.1.181 o successivo.

  • Scope: Any file
  • Type: Boolean
    • true: Claude Code renderizza testo piatto senza bordi decorativi o animazioni, utilizzando il renderer classico
    • false: Claude Code renderizza normalmente
  • Default: unset, quindi la modalità lettore di schermo è disattivata
  • Per-session overrides: --ax-screen-reader ha la precedenza su CLAUDE_AX_SCREEN_READER, e entrambi hanno la precedenza su questa chiave per una sessione
{
  "axScreenReader": true
}

Richiede Claude Code v2.1.181 o successivo.

`companyAnnouncements`

Mostra gli annunci della tua organizzazione agli utenti all'avvio. Quando ne elenchi più di uno, Claude Code ne sceglie uno a caso per ogni sessione; al primo avvio di una persona mostra la prima voce.

  • Scope: Any file
  • Type: array di stringhe
  • Default: unset, quindi nessun annuncio viene visualizzato
{
  "companyAnnouncements": [
    "Welcome to Acme Corp! Review our code guidelines at docs.example.com"
  ]
}

`defaultShell`

Scegli se Bash o PowerShell esegue i comandi shell che digiti con il prefisso ! nella casella di input, quelli che Claude Code esegue direttamente e aggiunge alla sessione.

"powershell" funziona solo mentre lo strumento PowerShell è attivo. Lo strumento è attivo per impostazione predefinita su Windows senza Git Bash, e su Windows con Git Bash per account claude.ai e Console. Nelle sessioni Amazon Bedrock, Google Cloud's Agent Platform e Microsoft Foundry, e su macOS, Linux e WSL, imposta CLAUDE_CODE_USE_POWERSHELL_TOOL=1 per attivare lo strumento. Imposta quella variabile su 0 per disattivare lo strumento.

  • Scope: Any file
  • Type: string, uno di:
    • "bash": Claude Code esegue i tuoi comandi ! in Bash
    • "powershell": Claude Code esegue i tuoi comandi ! in PowerShell
  • Default: "bash", o "powershell" su Windows quando Bash non è disponibile
{
  "defaultShell": "powershell"
}

Se la shell che nomini non è disponibile, Claude Code utilizza l'altra: "powershell" ritorna a Bash quando lo strumento PowerShell è disattivato, e "bash" ritorna a PowerShell quando Bash non è installato.

`dialogExpiry`

Imposta la scadenza per le finestre di dialogo che Claude Code inoltra a un client remoto, come un host Remote Control o SDK, e per la finestra di dialogo di approvazione per un messaggio tra sessioni mantenuto. Su Claude Code v2.1.236 o successivo, la stessa scadenza limita il prompt di consenso per i crediti di utilizzo Fable a metà sessione in una sessione che potrebbe non avere nessuno al terminale. Quando nessuna risposta arriva prima della scadenza, Claude Code annulla la finestra di dialogo e continua con il suo default senza azione. Richiede Claude Code v2.1.224 o successivo.

{
  "dialogExpiry": "10m"
}

I prompt di autorizzazione e le domande AskUserQuestion utilizzano i loro flussi propri e non sono governati da questa scadenza. Appare in /config come Dialog expiry, che scrive questa chiave nelle impostazioni utente; la riga richiede Claude Code v2.1.232 o successivo, e Claude Code la nasconde mentre le impostazioni gestite o il flag --settings impostano la chiave.

`editorMode`

Scegli la modalità di associazione dei tasti per il prompt di input.

  • Scope: Any file
  • Type: string, uno di:
    • "normal": scorciatoie da tastiera standard nel prompt di input
    • "vim": editing in stile vim con modalità NORMAL, INSERT e VISUAL
  • Default: "normal"
{
  "editorMode": "vim"
}

Appare in /config come Editor mode, che scrive questa chiave nelle impostazioni utente.

`emojiCompletionEnabled`

Mostra suggerimenti emoji quando digiti : più un codice breve nel prompt di input, e sostituisci un codice breve completato come :heart: con la sua emoji. Impostalo su false per disattivare entrambi.

  • Scope: Any file
  • Type: Boolean
    • true: Claude Code mostra suggerimenti emoji dopo : e sostituisce un codice breve completato con la sua emoji
    • false: Claude Code non suggerisce emoji né sostituisce codici brevi
  • Default: true
{
  "emojiCompletionEnabled": false
}

Vedi Codici brevi emoji. Richiede Claude Code v2.1.217 o successivo.

`fileSuggestion`

Esegui il tuo comando per fornire il completamento automatico del percorso file @ invece del suggerimento file integrato. Il suggerimento integrato utilizza l'attraversamento del filesystem veloce; un grande monorepo potrebbe fare meglio con l'indicizzazione specifica del progetto come un indice file pre-costruito.

  • Scope: Any file. Secondo i gate di riga di stato e suggerimento file, Claude Code disattiva il comando o esegue solo un valore gestito, e salta il tuo senza avviso.
  • Type: object con type, sempre "command", e command, il comando shell da eseguire
  • Default: unset, quindi Claude Code utilizza il suggerimento file integrato
{
  "fileSuggestion": {
    "type": "command",
    "command": "~/.claude/file-suggestion.sh"
  }
}

Dopo aver salvato questo, digita @ seguito da parte di un percorso nel prompt: i suggerimenti provengono dall'output del tuo comando.

Input e output del comando

Claude Code esegue il comando con le stesse variabili di ambiente dei hooks, incluso CLAUDE_PROJECT_DIR, e smette di attendere dopo cinque secondi. Il comando riceve JSON su stdin con un campo query che contiene quello che hai digitato finora:

{"query": "src/comp"}

Stampa percorsi file separati da newline su stdout. Claude Code mostra al massimo 15:

src/components/Button.tsx
src/components/Modal.tsx
src/components/Form.tsx

Lo script seguente legge la query e la passa a un indice file del repository:

#!/bin/bash
query=$(cat | jq -r '.query')
# Replace your-repo-file-index with your own file search command
your-repo-file-index --query "$query" | head -20

`footerLinksRegexes`

Renderizza badge cliccabili extra nel footer sotto la casella di input quando una regex corrisponde all'output del turno: risultati degli strumenti, inclusi contenuti di file e pagine recuperate, e risposte di Claude. Usalo per trasformare gli ID stampati dai CLI del progetto, come strumenti di revisione e tracker di problemi, in link di sessione. Richiede Claude Code v2.1.176 o successivo.

  • Scope: User or managed
  • Type: array di oggetti, ognuno con type impostato su "regex", una regex pattern, un template url, e un label opzionale; i placeholder {name} in url e label vengono riempiti dai gruppi di cattura denominati in pattern
  • Default: unset, quindi nessun badge viene renderizzato

Questo esempio corrisponde a chiavi di problemi come PROJ-1234 e costruisce ogni link dalla chiave catturata:

{
  "footerLinksRegexes": [
    {
      "type": "regex",
      "pattern": "\\b(?<key>PROJ-\\d+)\\b",
      "url": "https://issues.example.com/browse/{key}",
      "label": "{key}"
    }
  ]
}

Con questo configurato, quando PROJ-1234 appare in un risultato dello strumento o nella risposta di Claude, un badge PROJ-1234 appare nel footer collegato a https://issues.example.com/browse/PROJ-1234. Richiede Claude Code v2.1.176 o successivo.

Vincoli dei badge

L'URL, l'etichetta e il conteggio dei badge di ogni voce sono limitati come segue:

Vincolo Comportamento
Origine URL I valori catturati sono codificati in URL e l'URL costruito deve condividere l'origine letterale del template. Una cattura può riempire un segmento di percorso o un valore di query ma non può cambiare dove punta il link
Lunghezza URL Gli URL costruiti più lunghi di 2048 caratteri vengono eliminati
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
Etichetta Predefinita al testo corrispondente e troncata a 28 colonne di visualizzazione
Conteggio badge Al massimo 5 badge vengono renderizzati. Il più vecchio viene sostituito da corrispondenze più recenti e /clear li rimuove

Quando un turno si completa, Claude Code corrisponde a ogni regex pattern della voce rispetto all'output del turno sul thread principale, quindi una regex lenta 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 *.

I badge del footer vengono renderizzati insieme a una riga di stato personalizzata quando una è configurata; nessuno sostituisce l'altro. Usa una riga di stato per una riga guidata da script che calcola il suo contenuto dai dati della sessione, e badge del footer per trasformare gli ID dalla conversazione in link senza uno script.

`keybindingFlavor`

Nella v2.1.238 fino a v2.1.260, impostarlo su "readline" faceva sì che Ctrl+W eliminasse fino allo spazio bianco precedente invece di solo la parola precedente.

  • Scope: Any file
  • Type: string, "classic" o "readline"
  • Default: unset

`prefersReducedMotion`

Riduci o disattiva le animazioni dell'interfaccia come lo spinner, lo shimmer e gli effetti flash. Appare in /config come Reduce motion.

  • Scope: Any file
  • Type: Boolean
    • true: Claude Code riduce o disattiva le animazioni dell'interfaccia come lo spinner, lo shimmer e gli effetti flash
    • false: lo stesso di unset; Claude Code mostra le sue animazioni
  • Default: false
{
  "prefersReducedMotion": true
}

`promptSuggestionEnabled`

Mostra o nascondi i suggerimenti del prompt, le previsioni grigie che appaiono nel tuo input del prompt. Impostalo su false, o disattiva Prompt suggestions in /config, per nasconderli.

  • Scope: Any file
  • Type: Boolean
    • true: vedi suggerimenti del prompt nel tuo input del prompt
    • false: Claude Code nasconde i suggerimenti del prompt
  • Default: true
  • Per-session overrides: CLAUDE_CODE_ENABLE_PROMPT_SUGGESTION ha la precedenza su questa chiave per una sessione
{
  "promptSuggestionEnabled": false
}

I suggerimenti del prompt necessitano di un account claude.ai o Console con telemetria attiva. Su Amazon Bedrock, Google Cloud's Agent Platform e Microsoft Foundry, o con telemetria disattivata, come da DISABLE_TELEMETRY, questa chiave non ha effetto e solo CLAUDE_CODE_ENABLE_PROMPT_SUGGESTION=1 li attiva.

`respectGitignore`

Controlla se il selettore file @ esclude i file che corrispondono ai pattern .gitignore. Appare in /config come Respect .gitignore in file picker.

  • Scope: Any file. Quando nessun file di impostazioni lo imposta, Claude Code ritorna a respectGitignore in ~/.claude.json, che l'interruttore /config scrive.
  • Type: Boolean
    • true: il selettore file @ esclude i file che corrispondono ai pattern .gitignore
    • false: il selettore file @ include i file che corrispondono ai pattern .gitignore
  • Default: true
{
  "respectGitignore": false
}

`respondToBashCommands`

Scegli se Claude risponde dopo che esegui un comando shell con il prefisso ! nella casella di input. Per impostazione predefinita, Claude Code aggiunge l'output del comando alla conversazione e Claude vi risponde. Imposta questa chiave su false per aggiungere l'output al contesto senza una risposta, così puoi eseguire diversi comandi e chiedere informazioni su di essi insieme. Richiede Claude Code v2.1.186 o successivo.

  • Scope: Any file
  • Type: Boolean
    • true: Claude Code aggiunge l'output del comando alla conversazione e Claude vi risponde
    • false: Claude Code aggiunge l'output al contesto senza una risposta
  • Default: true
{
  "respondToBashCommands": false
}

Vedi Modalità shell con prefisso !. Richiede Claude Code v2.1.186 o successivo.

`showClearContextOnPlanAccept`

Quando Claude termina un piano in modalità piano, mostra un menu di approvazione. La pianificazione può utilizzare molto contesto, quindi questa chiave aggiunge una prima opzione a quel menu, Yes, clear context and …, che approva il piano, cancella il contesto della conversazione e inizia l'implementazione dal piano solo. Il resto dell'etichetta nomina la modalità di autorizzazione in cui la sessione continua, e mostra quanto contesto la pianificazione ha utilizzato.

  • Scope: Any file
  • Type: Boolean
    • true: il menu di approvazione del piano ottiene una prima opzione, Yes, clear context and …, che approva il piano e cancella il contesto della conversazione
    • false: il menu di approvazione del piano non mostra alcuna opzione di cancellazione del contesto
  • Default: false
{
  "showClearContextOnPlanAccept": true
}

`showTurnDuration`

Mostra o nascondi il messaggio di durata del turno dopo ogni risposta, come "Cooked for 1m 6s · done 6:05 PM". L'orologio dopo "done" mostra quando il turno è terminato; timeFormat e timeZone controllano il suo formato e la sua zona. Appare in /config come Show turn duration.

  • Scope: Any file. Un valore in ~/.claude.json da una versione precedente si applica quando nessun file di impostazioni lo imposta.
  • Type: Boolean
    • true: vedi il messaggio di durata del turno dopo ogni risposta
    • false: Claude Code nasconde il messaggio di durata del turno
  • Default: true
{
  "showTurnDuration": false
}

`spellcheck`

Sottolinea le parole scritte male nel prompt di input mentre digiti, utilizzando un correttore ortografico che installi. Claude Code controlla solo il testo nella casella di input. Controlla l'ortografia mentre digiti copre l'installazione di aspell, hunspell o ispell e cosa il correttore copre. Richiede Claude Code v2.1.235 o successivo.

  • Scope: User or managed. Il blocco dal livello più alto che lo imposta si applica nel suo insieme.
  • Type: object con enabled (Boolean), checker ("aspell", "hunspell", "ispell", o "auto"), language (string, passato al correttore come nome del suo dizionario), e color (string, un nome di colore del terminale, #rrggbb, rgb(r,g,b), ansi256(n), o ansi:<name>)
  • Default: unset, quindi il controllo ortografico è disattivato; checker predefinito su "auto", il primo dei tre trovato su PATH; language predefinito sul dizionario del correttore stesso; color predefinito sul colore di errore del tema
{
  "spellcheck": { "enabled": true, "language": "en_GB" }
}

`spinnerTipsEnabled`

Mentre Claude lavora, la riga dello spinner ruota attraverso brevi suggerimenti sulle funzioni di Claude Code, come "Use Plan Mode to prepare for a complex request before making changes. Press Shift+Tab twice to enable." Imposta questa chiave su false per nasconderli. Appare in /config come Show tips.

  • Scope: Any file
  • Type: Boolean
    • true: vedi suggerimenti nello spinner mentre Claude sta lavorando
    • false: Claude Code nasconde i suggerimenti dello spinner
  • Default: true
{
  "spinnerTipsEnabled": false
}

`spinnerTipsOverride`

Aggiungi i tuoi suggerimenti ai suggerimenti dello spinner che Claude Code mostra mentre Claude lavora, o sostituisci i suggerimenti integrati con i tuoi. Claude Code mette i tuoi suggerimenti nella stessa rotazione di quelli integrati: sceglie il suggerimento che non è stato mostrato più a lungo, salta i suggerimenti ancora nel loro cooldown, e rompe i pareggi per priorità.

Se imposti spinnerTipsEnabled su false, Claude Code nasconde tutti i suggerimenti, inclusi i tuoi.

  • Scope: Any file. Claude Code onora gli oggetti suggerimento, tipsFile, label, e excludeDefault dalle impostazioni utente, il flag --settings e impostazioni gestite; dai file di impostazioni di progetto e locale legge solo suggerimenti di stringa semplice.
  • Type: object con campi tips, tipsFile, label, e excludeDefault, ognuno opzionale
  • Default: unset, quindi Claude Code mostra solo i suggerimenti integrati

Gli oggetti suggerimento, tipsFile, label, e la regola della riga Scope che i file di impostazioni di progetto e locale contribuiscono solo stringhe semplici richiedono Claude Code v2.1.247 o successivo. Nelle versioni precedenti, excludeDefault di un file di progetto o locale si applica anche.

Ogni voce tips è una stringa semplice o un oggetto con questi campi:

Campo Obbligatorio Descrizione
id Sì Fino a 64 lettere, cifre, ., _, o -. Claude Code chiave la storia della visualizzazione del suggerimento su di esso, quindi il cooldown del suggerimento sopravvive al riordinamento dell'elenco. Di due voci con lo stesso id, Claude Code utilizza la prima
text Sì Il suggerimento, una riga di fino a 500 caratteri. Claude Code rimuove le sequenze ANSI e i caratteri di controllo e comprime lo spazio bianco
cooldownSessions No Sessioni che Claude Code attende prima di mostrare di nuovo il suggerimento, da 0 a 1000, predefinito 0
priority No Ordine tra i suggerimenti che non sono stati mostrati ugualmente a lungo, più alto prima, da -10 a 10, predefinito 0

Claude Code legge una stringa semplice come un suggerimento con quei valori predefiniti e un id basato sulla posizione, quindi la sua storia di visualizzazione si ripristina quando riordini l'elenco. Dai a un suggerimento un id per mantenere la sua storia attraverso le modifiche.

Claude Code legge al massimo 200 suggerimenti tra tips e tipsFile, e elimina una voce non valida con un avviso di debug invece di rifiutare il file di impostazioni.

Usa i campi rimanenti per nominare un file di suggerimenti, impostare il prefisso e nascondere i suggerimenti integrati:

  • tipsFile: un percorso assoluto o ~/ a un file JSON locale che contiene un array delle stesse voci, o un oggetto con un array tips, fino a 256 KB. Claude Code legge il file una volta per processo, quindi carica le tue modifiche al prossimo avvio. Non puoi impostarlo attraverso impostazioni gestite dal server; distribuisci suggerimenti tips inline lì, o distribuisci il percorso in un managed-settings.json su disco.
  • label: il prefisso che Claude Code mostra prima dei suggerimenti dalle impostazioni utente, --settings e gestite, fino a 40 caratteri. L'impostazione predefinita è Tip, lo stesso prefisso dei suggerimenti integrati, e i suggerimenti dai file di impostazioni di progetto e locale lo usano sempre.
  • excludeDefault: impostalo su true per nascondere i suggerimenti integrati e mostrare solo i tuoi. Quando Claude Code non riesce a caricare nessuno dei tuoi suggerimenti, ad esempio perché tipsFile non esiste o ogni voce non è valida, mantiene la rotazione integrata invece di uno spinner vuoto.

Quando più di un file di impostazioni imposta la chiave, Claude Code mostra suggerimenti da tutti loro e prende tipsFile, label, e excludeDefault da qualunque delle impostazioni gestite, il flag --settings e impostazioni utente sia il più alto precedente che imposta ognuno.

Questo esempio, nelle tue impostazioni utente, aggiunge un suggerimento di stringa semplice e un suggerimento di oggetto alla rotazione sotto il prefisso Acme tip:

{
  "spinnerTipsOverride": {
    "label": "Acme tip",
    "tips": [
      "Run /review before opening a PR",
      {
        "id": "gateway-errors",
        "text": "Seeing 5xx errors? Check the gateway status page first",
        "cooldownSessions": 5,
        "priority": 2
      }
    ]
  }
}

Ogni campo nell'esempio cambia una cosa su come Claude Code mostra i suggerimenti:

  • label: Claude Code mostra entrambi i suggerimenti come Acme tip: ... invece di Tip: ....
  • La stringa semplice: Claude Code le dà i valori predefiniti, quindi può venire di nuovo nella sessione successiva.
  • id: Claude Code chiave la storia della visualizzazione del secondo suggerimento su gateway-errors, quindi il suo cooldown si applica ancora dopo che aggiungi o riordini i suggerimenti.
  • cooldownSessions: dopo che Claude Code mostra il suggerimento gateway-errors, non mostra quel suggerimento di nuovo fino a cinque sessioni dopo.
  • priority: quando il suggerimento gateway-errors e un altro suggerimento non sono stati mostrati per lo stesso numero di sessioni, ad esempio quando nessuno è stato ancora mostrato, Claude Code mostra gateway-errors per primo. La stringa semplice ha la priorità predefinita, 0.

Mentre Claude lavora, Claude Code mostra i tuoi suggerimenti nello spinner con il tuo prefisso, come Acme tip: Run /review before opening a PR.

`spinnerVerbs`

Mentre un turno è in corso, lo spinner mostra un verbo rotante come "Accomplishing", "Architecting", o "Baking". Usa questa chiave per aggiungere i tuoi verbi a quella rotazione o sostituire l'elenco integrato con il tuo.

  • Scope: Any file
  • Type: object con un array verbs di stringhe e mode, uno di:
    • "append": Claude Code aggiunge i tuoi verbi al set integrato
    • "replace": Claude Code mostra solo i tuoi verbi
  • Default: unset, quindi Claude Code utilizza i verbi integrati

Questo esempio aggiunge due verbi al set integrato:

{
  "spinnerVerbs": {
    "mode": "append",
    "verbs": ["Pondering", "Crafting"]
  }
}

In modalità "replace" con un array verbs vuoto, Claude Code mantiene i verbi integrati.

`statusLine`

Esegui il tuo comando per renderizzare una riga di stato sotto il prompt con contesto come il modello, il costo o il ramo git. I campi opzionali regolano la spaziatura, aggiungono re-esecuzioni periodiche e nascondono l'indicatore di modalità vim integrato quando il tuo script renderizza vim.mode stesso.

  • Scope: Any file. Quando allowManagedHooksOnly è attivo, o disableAllHooks è impostato al di fuori delle impostazioni gestite, solo il valore delle impostazioni gestite viene eseguito.
  • Type: object con type impostato su "command" e una stringa command, più padding opzionale come numero di caratteri, refreshInterval come numero di secondi, minimo 1, e hideVimModeIndicator come Boolean
  • Default: unset, quindi nessuna riga di stato

Questo esempio stampa il nome del modello e l'utilizzo del contesto, e aggiunge due caratteri di spaziatura orizzontale:

{
  "statusLine": {
    "type": "command",
    "command": "jq -r '\"[\\(.model.display_name)] \\(.context_window.used_percentage // 0)% context\"'",
    "padding": 2
  }
}

L'esempio ha bisogno di jq installato e viene eseguito in una shell. Per equivalenti PowerShell e Git Bash, vedi Configurazione di Windows; per la configurazione completa, vedi Configura manualmente una riga di stato.

`subagentStatusLine`

Quando Claude esegue subagenti, Claude Code li elenca in una visualizzazione di attività sotto il prompt, una riga per subagente che mostra name · description · token count. Questa chiave ti consente di eseguire il tuo comando per riscrivere quelle righe, ad esempio per mostrare l'utilizzo del contesto di ogni subagente come percentuale. Su ogni aggiornamento, Claude Code invia le righe visibili come un oggetto JSON su stdin, con un array tasks che contiene id, name, status, model, tokenCount di ogni subagente e altro, e sostituisce la riga per ogni id che scrivi di nuovo come una riga {"id", "content"}. Le righe che non scrivi di nuovo mantengono il rendering predefinito.

  • Scope: Any file. Quando allowManagedHooksOnly è attivo, o disableAllHooks è impostato al di fuori delle impostazioni gestite, solo il valore delle impostazioni gestite viene eseguito.
  • Type: object con type impostato su "command" e una stringa command
  • Default: unset, quindi Claude Code renderizza le righe predefinite
{
  "subagentStatusLine": {
    "type": "command",
    "command": "jq -c '.tasks[] | {id, content: \"\\(.name): \\(.tokenCount) tokens\"}'"
  }
}

Vedi Righe di stato dei subagenti.

`syntaxHighlightingDisabled`

Claude Code colora il codice per linguaggio nei diff, blocchi di codice e anteprime di file che mostra nel terminale, con il suo evidenziatore integrato; nessun plugin o language server è coinvolto. Imposta questa chiave su true per mostrarli come testo semplice invece, ad esempio se i colori si scontrano con il tuo tema del terminale o rallentano un lettore di schermo.

  • Scope: Any file
  • Type: Boolean
    • true: Claude Code disattiva l'evidenziazione della sintassi nei diff, blocchi di codice e anteprime di file
    • false: Claude Code evidenzia la sintassi
  • Default: false
{
  "syntaxHighlightingDisabled": true
}

`terminalProgressBarEnabled`

Alcuni terminali possono mostrare un indicatore di progresso sulla scheda o nella barra delle applicazioni per il programma in esecuzione in essi. Mentre Claude sta lavorando, Claude Code segnala uno stato in corso al terminale, così puoi vedere da un'altra scheda o finestra se la sessione è ancora occupata. L'indicatore rimane visibile dopo che il turno termina mentre i subagenti in background o i flussi di lavoro dinamici sono ancora in esecuzione, e si cancella una volta che la sessione è inattiva.

Claude Code lo segnala solo nei terminali che supportano l'indicatore: ConEmu, Ghostty 1.2.0 o successivo, e iTerm2 3.6.6 o successivo. Imposta questa chiave su false per impedire a Claude Code di segnalarlo. Appare in /config come Terminal progress bar.

  • Scope: Any file. Un valore in ~/.claude.json da una versione precedente si applica quando nessun file di impostazioni lo imposta.
  • Type: Boolean
    • true: vedi la barra di progresso del terminale nei terminali che la supportano
    • false: Claude Code nasconde la barra di progresso del terminale
  • Default: true
{
  "terminalProgressBarEnabled": false
}

`terminalTitleFromRename`

Claude Code imposta il titolo della scheda del tuo terminale. Per impostazione predefinita utilizza un titolo che genera dalla conversazione, e una volta che dai alla sessione un nome con /rename o --name, la scheda mostra quel nome invece. Imposta questa chiave su false per mantenere il titolo generato sulla scheda anche dopo che nomini la sessione. Il nome stesso si applica comunque, quindi /resume <name> e il selettore di sessione lo trovano.

  • Scope: Any file
  • Type: Boolean
    • true: il titolo della scheda del terminale mostra il nome della sessione che hai impostato
    • false: la scheda mantiene il titolo che Claude Code genera dalla tua conversazione
  • Default: true
{
  "terminalTitleFromRename": false
}

Per impedire a Claude Code di aggiornare il titolo del terminale del tutto, imposta CLAUDE_CODE_DISABLE_TERMINAL_TITLE su 1 invece.

`theme`

Scegli il tema di colore per l'interfaccia. Appare in /config come Theme.

  • Scope: Any file. Un valore in ~/.claude.json da una versione precedente si applica quando nessun file di impostazioni lo imposta.
  • Type: string, uno di:
    • "auto": corrisponde allo sfondo chiaro o scuro del tuo terminale
    • "dark": il tema scuro
    • "light": il tema chiaro
    • "dark-daltonized": il tema scuro con colori adatti ai daltonici
    • "light-daltonized": il tema chiaro con colori adatti ai daltonici
    • "dark-ansi": il tema scuro utilizzando solo la tavolozza di colori ANSI del tuo terminale
    • "light-ansi": il tema chiaro utilizzando solo la tavolozza di colori ANSI del tuo terminale
    • "custom:<slug>" o "custom:<plugin-name>:<slug>": un tema personalizzato da ~/.claude/themes/ o un plugin
  • Default: "dark"
{
  "theme": "light-daltonized"
}

Vedi Crea un tema personalizzato.

`timeFormat`

Scegli come Claude Code scrive i tempi che mostra nell'interfaccia, come il done 6:05 PM alla fine di ogni messaggio di durata del turno e i timestamp nel visualizzatore di trascrizione. Per scegliere un preset, esegui /config e imposta Time format. Richiede Claude Code v2.1.257 o successivo.

  • Scope: Any file
  • Type: string, uno di:
    • "auto": lo stesso di unset; ogni tempo mantiene il suo formato integrato, che segue il tuo locale nel messaggio di durata del turno
    • "12-hour": un orologio a 12 ore
    • "24-hour": un orologio a 24 ore
    • "24-hour-utc": un orologio a 24 ore in UTC con Z dopo i minuti, come 18:05Z; Claude Code ignora timeZone per questo preset
    • Un pattern strftime come "%H:%M": Claude Code scrive ogni tempo con il pattern. Qualsiasi valore che contiene un % è un pattern, e qualsiasi altro valore al di fuori dei preset conta come "auto"
  • Default: "auto"
{
  "timeFormat": "24-hour"
}

/config offre solo i preset, quindi per usare un pattern strftime, aggiungi la chiave a un file di impostazioni. Questo esempio mostra ogni tempo come un orologio a 24 ore a due cifre:

{
  "timeFormat": "%H:%M"
}

Il messaggio di durata del turno e il visualizzatore di trascrizione mostrano quindi tempi come 18:05. Nel visualizzatore di trascrizione, il pattern è l'intero timestamp, quindi aggiungi direttive di data quando vuoi la data lì. Questo esempio mette la data davanti all'orologio:

{
  "timeFormat": "%Y-%m-%d %H:%M"
}

Le stesse superfici mostrano quindi tempi come 2026-09-01 18:05.

`timeZone`

Mostra i tempi nell'interfaccia in un fuso orario diverso dal tuo sistema. Impostalo su un nome di fuso orario IANA, come "UTC" o "Europe/Dublin". I tempi che timeFormat controlla mostrano quindi in questa zona. Se timeFormat è "24-hour-utc", i tempi rimangono in UTC e Claude Code ignora questa chiave. /config non ha una riga per questa chiave, quindi impostala in un file di impostazioni. Richiede Claude Code v2.1.257 o successivo.

  • Scope: Any file
  • Type: string, un nome di fuso orario IANA. Quando Claude Code non riconosce il nome, utilizza il tuo fuso orario di sistema
  • Default: unset, quindi i tempi mostrano nel tuo fuso orario di sistema
{
  "timeZone": "Europe/Dublin"
}

`tui`

Scegli il renderer dell'interfaccia utente del terminale. Usa "fullscreen" per il renderer alt-screen senza sfarfallio con scrollback virtualizzato, o "default" per il renderer classico dello schermo principale. Eseguire /tui fullscreen o /tui default scrive questa chiave per te.

  • Scope: Any file
  • Type: string, uno di:
    • "default": il renderer classico dello schermo principale
    • "fullscreen": il renderer alt-screen senza sfarfallio con scrollback virtualizzato
  • Default: unset, quindi Claude Code sceglie il renderer per te
  • Per-session overrides: CLAUDE_CODE_NO_FLICKER e CLAUDE_CODE_DISABLE_ALTERNATE_SCREEN hanno la precedenza su questa chiave per una sessione: CLAUDE_CODE_NO_FLICKER=1 attiva fullscreen, e CLAUDE_CODE_NO_FLICKER=0 o CLAUDE_CODE_DISABLE_ALTERNATE_SCREEN=1 lo disattiva; quando entrambi sono impostati, Claude Code lo disattiva
{
  "tui": "fullscreen"
}

Sotto tmux -CC o su SSH a Windows, Claude Code mantiene il renderer classico a meno che tu non imposti CLAUDE_CODE_NO_FLICKER=1. Le sessioni in background aperte da agent view utilizzano sempre il renderer fullscreen indipendentemente da questa impostazione.

`verbose`

Per impostazione predefinita, la trascrizione comprime ogni chiamata di strumento a un breve riepilogo, come il comando che Claude ha eseguito e un conteggio delle righe del suo output, e premi Ctrl+O per passare l'intera trascrizione alla visualizzazione espansa quando vuoi i dettagli. Imposta questa chiave su true per mostrare l'input e l'output completi di ogni chiamata di strumento inline mentre accade, il che è utile quando stai eseguendo il debug di un hook, di un server MCP o di un lungo comando shell. Appare in /config come Verbose output.

  • Scope: Any file. Un valore in ~/.claude.json da una versione precedente si applica quando nessun file di impostazioni lo imposta.
  • Type: Boolean
    • true: vedi l'output completo dello strumento
    • false: vedi riepiloghi troncati dell'output dello strumento
  • Default: false
  • Per-session overrides: --verbose ha la precedenza su questa chiave per una sessione
{
  "verbose": true
}

Un valore viewMode o una selezione sticky /focus sostituisce questa chiave ogni sessione.

`viewMode`

Imposta la visualizzazione della trascrizione in cui Claude Code inizia: "default", "verbose", o "focus". Quando impostato, sostituisce sia la selezione sticky /focus che l'impostazione verbose.

  • Scope: Any file
  • Type: string, uno di:
    • "default": la trascrizione normale con output dello strumento troncato
    • "verbose": la trascrizione con output dello strumento completo
    • "focus": solo il tuo ultimo prompt, un riepilogo di una riga delle chiamate di strumento con diffstat di modifica, e la risposta finale. La visualizzazione focus necessita del renderer fullscreen
  • Default: unset, quindi l'impostazione verbose e la tua ultima scelta /focus si applicano
  • Per-session overrides: --verbose ha la precedenza su questa chiave per una sessione
{
  "viewMode": "focus"
}

`vimInsertModeRemaps`

Mappa sequenze INSERT-mode a due tasti su Escape in modalità editor vim. Ogni chiave è esattamente due caratteri stampabili digitati in sequenza, e "<Esc>" è l'unico target supportato; Claude Code ignora altre voci. Richiede Claude Code v2.1.208 o successivo.

  • Scope: User or managed. Un repository non può rimappare le tue scorciatoie da tastiera.
  • Type: object che mappa una sequenza di due caratteri su "<Esc>"
  • Default: unset
{
  "vimInsertModeRemaps": {
    "jj": "<Esc>"
  }
}

Non ha effetto a meno che editorMode non sia "vim". Vedi Rimappa sequenze di tasti INSERT-mode. Richiede Claude Code v2.1.208 o successivo.

`voice`

Attiva la dettatura vocale e scegli come il tasto di dettatura si comporta. Claude Code scrive questo oggetto per te quando esegui /voice.

  • Scope: Any file
  • Type: object con enabled come Boolean, autoSubmit come Boolean che si applica solo in modalità hold, e mode, uno di:
    • "hold": tieni premuto il tasto di dettatura mentre parli e rilascialo per fermarti
    • "tap": tocca il tasto una volta per iniziare la registrazione e di nuovo per inviare
  • Default: unset, quindi la dettatura è disattivata; quando enabled è true e mode è unset, Claude Code utilizza "hold"

Questo esempio attiva la dettatura e fa sì che il tasto tocchi una volta per iniziare la registrazione e di nuovo per inviare:

{
  "voice": {
    "enabled": true,
    "mode": "tap"
  }
}

autoSubmit invia il prompt quando rilasci il tasto in modalità hold. La dettatura vocale richiede un account claude.ai.

`voiceEnabled`

Attiva la dettatura vocale con il modulo Boolean singolo che precede l'oggetto voice. Quando entrambi sono impostati, voice.enabled si applica.

  • Scope: Any file
  • Type: Boolean
    • true: la dettatura vocale è attiva quando sei connesso con un account claude.ai e la politica della tua organizzazione consente la voce, a meno che voice.enabled non sia impostato
    • false: la dettatura vocale è disattivata, a meno che voice.enabled non sia impostato
  • Default: unset
{
  "voiceEnabled": true
}

`wheelScrollAccelerationEnabled`

Accelera la velocità di scorrimento della rotella del mouse durante scorrimenti veloci nel rendering a schermo intero. Impostalo su false per una velocità di scorrimento costante per tacca della rotella. Richiede Claude Code v2.1.174 o successivo.

  • Scope: Any file
  • Type: Boolean
    • true: Claude Code accelera la velocità di scorrimento della rotella del mouse durante scorrimenti veloci
    • false: Claude Code scorre a una velocità costante per tacca della rotella
  • Default: true
{
  "wheelScrollAccelerationEnabled": false
}

Richiede Claude Code v2.1.174 o successivo.

Git e attribuzione

Controllate l'attribuzione che Claude Code aggiunge ai commit e alle pull request e come funziona con git.

`attribution`

Personalizzate l'attribuzione che Claude Code aggiunge ai commit git e alle pull request. I commit ricevono un git trailer come Co-Authored-By per impostazione predefinita; le descrizioni delle pull request ricevono testo semplice. Impostate ogni parte separatamente con le sotto-chiavi di seguito.

  • Ambito: Any file
  • Tipo: oggetto con stringhe commit e pr e un Boolean sessionUrl
  • Predefinito: non impostato, quindi Claude Code utilizza l'attribuzione standard mostrata sotto ogni sotto-chiave

Questo esempio sostituisce l'attribuzione del commit, rimuove l'attribuzione della pull request e elimina il collegamento della sessione:

{
  "attribution": {
    "commit": "Generated with AI\n\nCo-Authored-By: AI <ai@example.com>",
    "pr": "",
    "sessionUrl": false
  }
}

Per nascondere tutta l'attribuzione, impostate commit e pr su stringhe vuote e sessionUrl su false. Una volta impostato commit o pr, Claude Code ignora l'impostazione deprecata includeCoAuthoredBy e utilizza il testo predefinito per quello dei due che avete lasciato non impostato.

`includeCoAuthoredBy`

Utilizzate attribution invece, che sostituisce questa chiave e vi consente di modificare o nascondere il trailer del commit, il testo della pull request e il collegamento della sessione separatamente. Claude Code onora ancora includeCoAuthoredBy: false dai file di impostazioni precedenti a attribution, ma lo ignora una volta impostato attribution.commit o attribution.pr.

  • Ambito: Any file
  • Tipo: Boolean
    • true: lo stesso di non impostato; Claude Code aggiunge il trailer del commit e il testo di attribuzione della pull request
    • false: Claude Code omette sia il trailer del commit che il testo di attribuzione della pull request, a meno che attribution non imposti commit o pr, nel qual caso si applicano le regole attribution
  • Predefinito: true
{
  "includeCoAuthoredBy": false
}

Per nascondere tutta l'attribuzione oggi, impostate attribution.commit e attribution.pr su stringhe vuote e attribution.sessionUrl su false.

`includeGitInstructions`

All'inizio della sessione, Claude Code aggiunge due elementi correlati a git al prompt di Claude: le sue istruzioni integrate su come scrivere commit e pull request, nella descrizione dello strumento Bash, e uno snapshot dello stato git del vostro repository nel prompt di sistema, il che significa il ramo corrente, il ramo principale, l'output di git status e i commit recenti. Impostate questa chiave su false per escludere entrambi, ad esempio quando utilizzate le vostre skill di flusso di lavoro git personalizzate.

  • Ambito: Any file
  • Tipo: Boolean
    • true: Claude Code include le sue istruzioni integrate per il flusso di lavoro di commit e pull request e lo snapshot dello stato git. Le sessioni cloud non includono mai lo snapshot
    • false: Claude Code esclude entrambi
  • Predefinito: true
  • Override per sessione: CLAUDE_CODE_DISABLE_GIT_INSTRUCTIONS ha la precedenza su questa chiave per una sessione
{
  "includeGitInstructions": false
}

`prUrlTemplate`

Indirizzate i link PR che Claude Code renderizza, nel badge del footer e nei riepiloghi dei risultati degli strumenti, verso uno strumento di revisione del codice interno invece di github.com. Claude Code sostituisce {host}, {owner}, {repo}, {number} e {url} dall'URL della PR. I link delle richieste di merge GitLab su entrambe le superfici mantengono il loro URL GitLab.

  • Ambito: Any file
  • Tipo: stringa, un modello di URL utilizzando uno qualsiasi dei cinque segnaposti
  • Predefinito: non impostato
{
  "prUrlTemplate": "https://reviews.example.com/{owner}/{repo}/pull/{number}"
}

Claude Code applica il modello solo ai link che renderizza stesso; un numero PR che Claude scrive in un messaggio, come #123, rimane come Claude lo ha scritto. Un URL che non ha la forma /pull/<number> viene lasciato invariato.

`attribution.commit`

Impostate il testo di attribuzione che Claude Code aggiunge ai commit git, inclusi eventuali trailer. Impostatelo su una stringa vuota per nascondere l'attribuzione del commit.

  • Ambito: Any file
  • Tipo: stringa
  • Predefinito: non impostato, quindi Claude Code aggiunge Co-Authored-By: <name> <noreply@anthropic.com>. Il nome è il modello attivo della sessione, come Claude Sonnet 5.
    • Quando Claude Code riconosce il modello come un modello Claude ma non può confermarne la versione esatta, scrive Claude da solo.
    • Quando non può abbinare l'ID del modello a nessun modello Claude, come un modello di terze parti servito attraverso un ANTHROPIC_BASE_URL personalizzato, scrive Claude Code.

Questo esempio sostituisce il trailer predefinito con una riga personalizzata e un trailer Co-Authored-By personalizzato:

{
  "attribution": {
    "commit": "Generated with AI\n\nCo-Authored-By: AI <ai@example.com>"
  }
}

`attribution.pr`

Impostate il testo di attribuzione che Claude Code aggiunge alle descrizioni delle pull request. Impostatelo su una stringa vuota per nascondere l'attribuzione della pull request.

  • Ambito: Any file
  • Tipo: stringa
  • Predefinito: non impostato, quindi Claude Code aggiunge 🤖 Generated with [Claude Code](https://claude.com/claude-code)
{
  "attribution": {
    "pr": ""
  }
}

`attribution.sessionUrl`

Scegliete se Claude Code aggiunge il collegamento della sessione claude.ai quando esegue il commit o apre una pull request da una sessione cloud o Remote Control. Claude Code aggiunge il collegamento come trailer Claude-Session sui commit e come collegamento nelle descrizioni delle pull request. Impostatelo su false per omettere il collegamento.

  • Ambito: Any file
  • Tipo: Boolean
    • true: Claude Code aggiunge il collegamento della sessione claude.ai quando esegue il commit o apre una pull request da una sessione cloud o Remote Control
    • false: Claude Code omette il collegamento
  • Predefinito: true
{
  "attribution": {
    "sessionUrl": false
  }
}

Hooks e automazione

Registra gli hooks, limita quali hooks vengono eseguiti e controlla i flussi di lavoro. Per gli eventi e i payload degli hooks, consulta il riferimento degli hooks.

`allowedHttpHookUrls`

Limita gli URL che gli HTTP hooks possono raggiungere. Quando definisci questa chiave, Claude Code esegue un HTTP hook solo se il suo URL corrisponde a uno dei modelli e blocca il resto senza eseguirli; un array vuoto blocca ogni HTTP hook.

  • Scope: Any file. Gli array si uniscono tra i file di impostazioni.
  • Type: array di modelli URL, con * come carattere jolly
  • Default: non impostato, quindi qualsiasi URL è consentito

Questo esempio consente qualsiasi URL sotto https://hooks.example.com/ e qualsiasi URL http://localhost:

{
  "allowedHttpHookUrls": ["https://hooks.example.com/*", "http://localhost:*"]
}

La corrispondenza del nome host non distingue tra maiuscole e minuscole e tratta hooks.example.com., con il punto finale che contrassegna un nome di dominio completamente qualificato, allo stesso modo di hooks.example.com, come fa il DNS. L'elenco di autorizzazione si applica agli hooks da ogni fonte, incluse le impostazioni gestite.

`allowManagedHooksOnly`

Limita l'esecuzione degli hooks agli hooks che la tua organizzazione distribuisce.

  • Scope: Managed
  • Type: Boolean
    • true: solo gli hooks gestiti vengono eseguiti, più gli hooks dell'Agent SDK e gli hooks dai plugin che le tue impostazioni gestite forzano l'abilitazione. Vedi Cosa viene eseguito sotto allowManagedHooksOnly
    • false: gli hooks da ogni scope di impostazioni e plugin vengono eseguiti
  • Default: non impostato, quindi gli hooks da ogni scope di impostazioni e plugin vengono eseguiti
{
  "allowManagedHooksOnly": true
}

Cosa viene eseguito sotto `allowManagedHooksOnly`

Quando lo imposti su true, Claude Code cambia quali hooks e comandi simili agli hooks vengono caricati:

  • Gli hooks gestiti e SDK vengono eseguiti: gli hooks dalle impostazioni gestite e gli hooks che l'Agent SDK registra nel processo
  • Gli hooks dei plugin forzati vengono eseguiti: gli hooks dai plugin che le tue impostazioni gestite forzano l'abilitazione tramite enabledPlugins. Claude Code corrisponde all'ID completo plugin@marketplace, quindi un plugin con lo stesso nome da un marketplace diverso rimane bloccato. Questo ti consente di distribuire hooks verificati tramite un marketplace dell'organizzazione mentre blocchi tutto il resto
  • Tutto il resto è bloccato: gli hooks dell'utente, del progetto e locali, gli hooks da altri plugin e gli hooks dichiarati nel frontmatter dell'agente
  • I plugin con origine comando sono disabilitati: Claude Code disabilita anche i plugin con un'origine command, inclusi i plugin forzati abilitati in enabledPlugins gestito, a meno che tu non imposti disableCommandPluginSources su false esplicitamente
  • I comandi marketplace headersHelper sono bloccati: Claude Code blocca anche i comandi marketplace headersHelper a meno che disableCommandPluginSources non sia esplicitamente impostato su false, ad eccezione di un marketplace che le impostazioni gestite stesse dichiarano. Richiede Claude Code v2.1.238 o successivo
  • La riga di stato e il suggerimento di file si restringono alle impostazioni gestite: Claude Code legge statusLine, fileSuggestion e subagentStatusLine solo dalle impostazioni gestite, seguendo i gate della riga di stato e del suggerimento di file

Il comando /goal non può essere eseguito mentre questa chiave è impostata, perché dipende dagli hooks.

`disableAllHooks`

Disattiva gli hooks, qualsiasi riga di stato personalizzata e qualsiasi comando suggerimento di file personalizzato. Usalo per disattivare tutti questi temporaneamente senza eliminarli dalle tue impostazioni.

  • Scope: Any file. Solo le impostazioni gestite possono disabilitare gli hooks gestiti.
  • Type: Boolean
    • true: Claude Code disattiva gli hooks, qualsiasi riga di stato personalizzata e qualsiasi comando suggerimento di file personalizzato
    • false: gli hooks, la riga di stato e il comando suggerimento di file vengono eseguiti
  • Default: non impostato, quindi gli hooks vengono eseguiti
{
  "disableAllHooks": true
}

La portata dipende da quale file contiene la chiave:

  • Nelle impostazioni gestite: Claude Code disabilita ogni hook configurato, inclusi quelli gestiti, e continua a eseguire gli hooks che l'Agent SDK registra nel processo
  • In qualsiasi altro file di impostazioni: Claude Code disabilita gli hooks dell'utente, del progetto, locali e dei plugin; gli hooks gestiti, gli hooks dell'Agent SDK e gli hooks dai plugin forzati abilitati in enabledPlugins gestito continuano a essere eseguiti

Mantenere gli hooks dell'Agent SDK in esecuzione quando le impostazioni gestite impostano questa chiave richiede Claude Code v2.1.242 o successivo.

Il comando /goal non può essere eseguito mentre gli hooks sono disabilitati e il menu /hooks mostra un avviso invece dei tuoi hooks.

Gate della riga di stato e del suggerimento di file

Claude Code prende due decisioni per statusLine, fileSuggestion e subagentStatusLine, in questo ordine:

Sotto il restringimento, Claude Code esegue un valore gestito se uno è distribuito. Altrimenti salta il tuo valore senza avviso: la riga di stato è disabilitata e l'autocompletamento @ torna al suggerimento di file integrato.

`disableWorkflows`

Disattiva i flussi di lavoro dinamici e i comandi del flusso di lavoro in bundle per tutti coloro che le tue impostazioni raggiungono, come un'organizzazione tramite impostazioni gestite. Per attivare o disattivare i flussi di lavoro solo per te stesso, usa enableWorkflows invece, che l'interruttore Dynamic workflows in /config scrive nelle tue impostazioni utente.

  • Scope: Any file
  • Type: Boolean
    • true: Claude Code disattiva i flussi di lavoro dinamici e i comandi del flusso di lavoro in bundle per tutti coloro che le tue impostazioni raggiungono
    • false: lo stesso di non impostato; se i flussi di lavoro sono attivi dipende da enableWorkflows e dal default del tuo piano
  • Default: false
  • Per-session overrides: CLAUDE_CODE_DISABLE_WORKFLOWS disattiva i flussi di lavoro per una sessione; qualunque dei due li disattivi, l'altro non può riattivarli
{
  "disableWorkflows": true
}

`enableWorkflows`

Attiva o disattiva i flussi di lavoro dinamici per te stesso quando il default del tuo piano non è quello che desideri. Appare in /config come Dynamic workflows, che scrive questa chiave nelle tue impostazioni utente e la rimuove di nuovo quando torni al default del tuo piano. Per disattivare i flussi di lavoro per tutti dalle impostazioni gestite, usa disableWorkflows invece.

  • Scope: Any file
  • Type: Boolean
    • true: Claude Code attiva i flussi di lavoro dinamici per te
    • false: Claude Code disattiva i flussi di lavoro dinamici per te
  • Default: non impostato, quindi i flussi di lavoro sono attivi a meno che tu non sia su un piano Pro, dove sono disattivi
  • Per-session overrides: CLAUDE_CODE_DISABLE_WORKFLOWS disattiva i flussi di lavoro per una sessione, e true qui non può riattivarli mentre è impostato
{
  "enableWorkflows": true
}

disableWorkflows e la politica dei flussi di lavoro della tua organizzazione hanno anche la precedenza: enableWorkflows: true non può riattivare i flussi di lavoro mentre una fonte disattiva i flussi di lavoro. Claude Code nasconde la riga /config mentre una fonte diversa dalle tue impostazioni utente imposta enableWorkflows, o imposta disableWorkflows su true.

`hooks`

Esegui i tuoi comandi, prompt, agenti, richieste HTTP o strumenti MCP come hooks in punti del ciclo di vita di Claude Code, come prima di una chiamata a uno strumento o quando una sessione inizia; il riferimento degli hooks elenca ogni evento, il suo payload e i suoi codici di uscita. Ogni evento è mappato a un elenco di gruppi di matcher, e ogni gruppo elenca i gestori da eseguire quando il matcher si applica.

  • Scope: Any file. Gli hooks si uniscono tra i file piuttosto che sostituirsi a vicenda, e gli hooks dalle impostazioni gestite non possono essere rimossi da altri file.
  • Type: oggetto con chiave hook event; ogni valore è un array di gruppi { "matcher", "hooks" } le cui voci hooks hanno un type di "command", "prompt", "agent", "http" o "mcp_tool"
  • Default: non impostato, quindi nessun hook viene eseguito

Questo esempio esegue uno script prima di ogni chiamata allo strumento Bash:

{
  "hooks": {
    "PreToolUse": [
      {
        "matcher": "Bash",
        "hooks": [
          { "type": "command", "command": "~/.claude/hooks/check-bash.sh" }
        ]
      }
    ]
  }
}

Per ogni evento, modello di matcher e campo del gestore, consulta il riferimento degli hooks. Per disattivare gli hooks, vedi disableAllHooks; per limitare gli hooks a quelli che la tua organizzazione distribuisce, vedi allowManagedHooksOnly.

`httpHookAllowedEnvVars`

Un HTTP hook può inserire il valore di una variabile di ambiente in un'intestazione di richiesta, ad esempio un'intestazione Authorization: Bearer $HOOK_TOKEN, ma solo per le variabili che l'hook elenca nel suo allowedEnvVars. Questa chiave imposta un limite esterno su tale elenco per ogni HTTP hook: un hook può utilizzare una variabile solo se sia il suo allowedEnvVars che questa chiave la nominano. Usalo per impedire a un hook di leggere un segreto che non dovrebbe, anche quando la definizione dell'hook lo richiede.

  • Scope: Any file. Gli array si uniscono tra i file di impostazioni.
  • Type: array di nomi di variabili di ambiente
  • Default: non impostato, quindi l'elenco allowedEnvVars di ogni hook si applica

Questo esempio limita l'interpolazione dell'intestazione a MY_TOKEN e HOOK_SECRET:

{
  "httpHookAllowedEnvVars": ["MY_TOKEN", "HOOK_SECRET"]
}

L'elenco di autorizzazione si applica agli hooks da ogni fonte, incluse le impostazioni gestite.

`workflowKeywordTriggerEnabled`

Scegli se digitare la parola chiave ultracode in un prompt attiva un flusso di lavoro dinamico. Impostalo su false per digitare la parola senza attivarne uno.

  • Scope: Any file. Appare in /config come Ultracode keyword trigger.
  • Type: Boolean
    • true: digitare ultracode in un prompt attiva un flusso di lavoro dinamico
    • false: puoi digitare la parola senza attivarne uno
  • Default: true
{
  "workflowKeywordTriggerEnabled": false
}

L'impostazione dello sforzo ultracode, /workflows e i comandi del flusso di lavoro salvati non sono interessati.

`workflowSizeGuideline`

Imposta il numero di agenti a cui Claude mira nei flussi di lavoro dinamici che scrive. Claude Code invia il valore a Claude come consiglio, non come limite imposto: "small" chiede meno di 5 agenti, "medium" meno di 15 e "large" meno di 50. Scegli "small" quando vuoi limitare ciò che un flusso di lavoro spende. Richiede Claude Code v2.1.219 o successivo.

  • Scope: Any file. Un valore lì ha la precedenza sulla scelta Dynamic workflow size in /config, che Claude Code memorizza in ~/.claude.json, e Claude Code nasconde quella riga mentre un file di impostazioni imposta la chiave.
  • Type: stringa, uno di:
    • "unrestricted": nessuna linea guida, quindi Claude dimensiona il flusso di lavoro al compito
    • "small": Claude mira a meno di 5 agenti
    • "medium": Claude mira a meno di 15 agenti
    • "large": Claude mira a meno di 50 agenti
  • Default: "medium"
{
  "workflowSizeGuideline": "small"
}

Richiede Claude Code v2.1.219 o successivo; su v2.1.202 attraverso v2.1.218, imposta la linea guida in /config invece.

Plugin e skills

Abilita i plugin, registra i marketplace, limita le fonti di plugin che un'organizzazione consente e controlla quali skills si caricano. Per l'installazione e la creazione di plugin, vedi Plugin.

`disableBundledSkills`

Disattiva le skills e i flussi di lavoro inclusi con Claude Code. Claude Code rimuove completamente le skills e i flussi di lavoro in bundle, mentre i comandi incorporati come /init rimangono digitabili ma sono nascosti dal modello.

  • Scope: Any file
  • Type: Boolean
    • true: Claude Code rimuove le skills e i flussi di lavoro in bundle e nasconde i comandi incorporati come /init dal modello
    • false: le skills in bundle si caricano
  • Default: non impostato, quindi le skills in bundle si caricano
  • Per-session overrides: CLAUDE_CODE_DISABLE_BUNDLED_SKILLS impostato su 1 disattiva le skills in bundle per una sessione; qualunque dei due le disattivi, l'altro non può riattivarle
{
  "disableBundledSkills": true
}

Le skills dai plugin, da .claude/skills/ e da .claude/commands/ non sono interessate. /doctor rimane digitabile come i comandi incorporati; per nasconderlo, imposta DISABLE_DOCTOR_COMMAND invece.

`disableSkillShellExecution`

Disattiva l'esecuzione inline della shell per !`...` e ```! blocchi in skills e comandi personalizzati da fonti utente, progetto, plugin o directory aggiuntiva. Claude Code sostituisce ogni comando con [shell command execution disabled by policy] invece di eseguirlo.

  • Scope: Any file. Un true nelle impostazioni gestite non può essere sovrascritto da false altrove.
  • Type: Boolean
    • true: Claude Code sostituisce ogni comando shell inline con [shell command execution disabled by policy] invece di eseguirlo
    • false: la shell inline si esegue
  • Default: non impostato, quindi la shell inline si esegue
{
  "disableSkillShellExecution": true
}

Le skills in bundle e le skills distribuite tramite impostazioni gestite non sono interessate.

`skillOverrides`

Nascondi o comprimi una skill senza modificare il suo SKILL.md. Claude Code applica il valore sotto il nome di ogni skill all'elenco delle skills che Claude vede e al tuo completamento automatico /.

  • Scope: Any file. Il menu /skills scrive in .claude/settings.local.json.
  • Type: oggetto che mappa il nome della skill a uno di:
    • "on": Claude vede la skill e puoi digitare /name
    • "name-only": Claude vede la skill per nome senza la sua descrizione
    • "user-invocable-only": Claude non vede la skill, ma puoi comunque digitare /name
    • "off": Claude non vede la skill e /name è nascosto dal completamento automatico
  • Default: non impostato, quindi ogni skill è "on"

Questo esempio elenca legacy-context a Claude solo per nome e nasconde deploy da Claude e dal completamento automatico /:

{
  "skillOverrides": {
    "legacy-context": "name-only",
    "deploy": "off"
  }
}

Gli override non si applicano alle skills dei plugin, che gestisci tramite /plugin.

Nelle impostazioni gestite e nei file passati con --settings, una chiave su un alias di una skill in bundle, come checkup per /doctor, si applica anche alla skill; vedi come le chiavi alias si combinano con le chiavi sul nome della skill stessa.

`syncClaudeAiSkills`

Disattiva il download delle skills che abiliti su claude.ai. Claude Code le scarica in ~/.claude/skills/synced/ quando lo esegui in modalità non interattiva con il flag -p e CLAUDE_CODE_SYNC_SKILLS impostato. Imposta false per interrompere quel download e nascondere le skills che ha già sincronizzato. Claude Code onora solo false: true è lo stesso di non impostato e non attiva la sincronizzazione.

  • Scope: User, local, or managed. Un repository non può disattivarla per te.
  • Type: Boolean
    • false: Claude Code interrompe il download delle skills sincronizzate e nasconde quelle già in ~/.claude/skills/synced/. Nelle impostazioni utente o gestite, le sposta anche in ~/.claude/skills/.trash/
    • true: lo stesso di non impostato
  • Default: non impostato, quindi un'esecuzione non interattiva con CLAUDE_CODE_SYNC_SKILLS impostato scarica le skills

Questo esempio impedisce a una macchina di scaricare le skills dell'account, qualunque cosa una sessione imposti nel suo ambiente:

{
  "syncClaudeAiSkills": false
}

`allowedChannelPlugins`

Scegli quali plugin di channel possono inviare messaggi nelle sessioni della tua organizzazione. Quando lo imposti, Claude Code utilizza il tuo elenco al posto della lista di autorizzazione predefinita di Anthropic; ogni voce nomina un plugin e il marketplace da cui proviene.

  • Scope: Managed
  • Type: array di oggetti, ciascuno con stringhe marketplace e plugin. Una voce può invece essere una stringa "plugin@marketplace" come "telegram@claude-plugins-official", che Claude Code tratta come l'oggetto equivalente. La forma stringa richiede Claude Code v2.1.267 o successivo; le versioni precedenti rifiutano l'intero valore allowedChannelPlugins quando ne contiene una
  • Default: non impostato, quindi Claude Code utilizza la lista di autorizzazione predefinita di Anthropic

Questo esempio attiva i channel e consente solo il plugin Telegram dal marketplace ufficiale di Anthropic:

{
  "channelsEnabled": true,
  "allowedChannelPlugins": [
    { "marketplace": "claude-plugins-official", "plugin": "telegram" }
  ]
}

Un array vuoto blocca ogni plugin di channel.

Questa chiave ha effetto una volta che i channel superano il gate channelsEnabled per l'account: su piani Team e Enterprise, e su account Console con impostazioni gestite, significa channelsEnabled: true. Vedi Limita quali plugin di channel possono essere eseguiti.

`blockedMarketplaces`

Blocca le fonti di marketplace dei plugin per la tua organizzazione. Claude Code controlla la lista di blocco all'aggiunta del marketplace e all'installazione, aggiornamento, aggiornamento e auto-aggiornamento del plugin, quindi un marketplace che qualcuno ha aggiunto prima di impostare la policy non può essere utilizzato per recuperare plugin. Le fonti bloccate vengono controllate prima del download, quindi non toccano mai il filesystem.

  • Scope: Managed
  • Type: array di oggetti di fonte marketplace, nelle stesse forme di strictKnownMarketplaces
  • Default: non impostato, quindi nessun marketplace è bloccato

Questo esempio blocca un repository GitHub come fonte di marketplace:

{
  "blockedMarketplaces": [
    { "source": "github", "repo": "untrusted/plugins" }
  ]
}

Una voce github può utilizzare la forma owner-wildcard "owner/*" per bloccare ogni repository sotto quel proprietario GitHub, che richiede Claude Code v2.1.223 o successivo. Aggiungi { "source": "skills-dir" } per impedire a Claude Code di caricare i plugin @skills-dir da ~/.claude/skills/ senza limitare alcun marketplace. Vedi Restrizioni di marketplace gestite.

`channelsEnabled`

Consenti i channel per la tua organizzazione. Su piani Team e Enterprise di claude.ai, Claude Code blocca i channel finché non imposti questo su true. Per account Anthropic Console che si autenticano con una chiave API, i channel sono consentiti per impostazione predefinita. Se la tua organizzazione distribuisce impostazioni gestite, Claude Code blocca i channel anche su quegli account finché non imposti questa chiave su true.

  • Scope: Managed
  • Type: Boolean
    • true: Claude Code consente i channel per la tua organizzazione
    • false: lo stesso di non impostato; se i channel sono bloccati dipende dal tuo piano, come dice il Default
  • Default: non impostato; i channel sono bloccati su piani Team e Enterprise e su account Console con impostazioni gestite, e consentiti su piani Pro e Max e su account Console senza impostazioni gestite
{
  "channelsEnabled": true
}

Per limitare quali plugin possono registrarsi come channel una volta abilitati, imposta allowedChannelPlugins. Vedi Controlli Enterprise.

`disableCommandPluginSources`

Blocca la fonte plugin command, che installa un plugin eseguendo un comando dichiarato dal marketplace sulla macchina dell'utente. Quando lo imposti su true, Claude Code non esegue mai il comando, non installa o aggiorna plugin con origine comando e interrompe il caricamento di quelli già installati. Imposta su false per consentirli esplicitamente. Ogni volta che blocca le fonti comando, che tu lo imposti su true o lo lasci non impostato sotto allowManagedHooksOnly, blocca anche i comandi headersHelper del marketplace, tranne per un marketplace che le impostazioni gestite stesse dichiarano. Richiede Claude Code v2.1.229 o successivo, e il blocco headersHelper richiede v2.1.238 o successivo.

  • Scope: Managed
  • Type: Boolean
    • true: Claude Code non esegue mai il comando dichiarato dal marketplace, non installa o aggiorna plugin con origine comando e interrompe il caricamento di quelli già installati
    • false: Claude Code consente i plugin con origine comando esplicitamente
  • Default: non impostato, quindi Claude Code segue allowManagedHooksOnly: un'organizzazione che limita l'esecuzione degli hook alle impostazioni gestite ottiene anche le fonti comando disabilitate
{
  "disableCommandPluginSources": true
}

Richiede Claude Code v2.1.229 o successivo.

`pluginSuggestionMarketplaces`

Nomina i marketplace i cui plugin possono apparire come suggerimenti di installazione contestuali, nei suggerimenti spinner e fissati in cima alla scheda Discover di /plugin. Il suggerimento incorporato di prima parte per il design del frontend non è interessato. I suggerimenti provengono dalla dichiarazione relevance di ogni plugin nella sua voce di marketplace.

  • Scope: Managed
  • Type: array di nomi di marketplace
  • Default: non impostato, quindi nessun suggerimento dichiarato dal marketplace viene visualizzato
{
  "pluginSuggestionMarketplaces": ["acme-corp-plugins"]
}

Un nome ha effetto solo quando il marketplace è registrato sulla macchina e la sua fonte registrata è anche dichiarata nelle stesse impostazioni gestite, come voce extraKnownMarketplaces per quel nome o come voce di strictKnownMarketplaces. Claude Code ignora un marketplace registrato da una fonte diversa sotto un nome nella lista di autorizzazione. Il marketplace ufficiale è esente dal requisito di fonte: autorizzare solo il suo nome è sufficiente, poiché quel nome può registrarsi solo dalla fonte ufficiale di Anthropic. Vedi Suggerisci plugin per contesto.

`pluginTrustMessage`

Aggiungi il testo della tua organizzazione all'avviso di fiducia del plugin che Claude Code mostra prima dell'installazione, ad esempio per confermare che i plugin dal tuo marketplace interno sono controllati.

  • Scope: Managed
  • Type: string
  • Default: non impostato, quindi Claude Code mostra solo l'avviso standard
{
  "pluginTrustMessage": "All plugins from our marketplace are approved by IT"
}

`strictKnownMarketplaces`

Limita le fonti di marketplace dei plugin da cui le persone nella tua organizzazione possono aggiungere e installare plugin. Claude Code applica la lista di autorizzazione all'aggiunta del marketplace e all'installazione, aggiornamento, aggiornamento e auto-aggiornamento del plugin, prima di qualsiasi operazione di rete o filesystem, quindi un marketplace che qualcuno ha aggiunto prima di impostare la policy non può essere utilizzato per recuperare plugin una volta che la sua fonte non corrisponde più. Gli utenti bloccati vedono un errore che nomina la policy gestita.

  • Scope: Managed
  • Type: array di oggetti di fonte marketplace; vedi Tipi di fonte consentiti
  • Default: non impostato, quindi gli utenti possono aggiungere qualsiasi marketplace. Un array vuoto è un blocco completo che blocca ogni fonte di marketplace, incluso il marketplace ufficiale di Anthropic

Questo esempio consente due repository GitHub, uno fissato al ref v2.0 e uno URL di marketplace.json ospitato:

{
  "strictKnownMarketplaces": [
    { "source": "github", "repo": "acme-corp/approved-plugins" },
    { "source": "github", "repo": "acme-corp/security-tools", "ref": "v2.0" },
    { "source": "url", "url": "https://plugins.example.com/marketplace.json" }
  ]
}

Puoi anche scrivere questa chiave come allowedMarketplaces; Alias di chiave Marketplace descrive come Claude Code tratta l'alias e quale versione lo accetta. Questa chiave è un gate di policy: controlla cosa gli utenti possono aggiungere ma non registra nulla. Per limitare e pre-registrare in un file, vedi Combina con extraKnownMarketplaces. Per la vista rivolta all'utente, vedi Restrizioni di marketplace gestite.

Tipi di fonte consentiti

Ogni voce di seguito mostra una voce della lista di autorizzazione per tipo di fonte e i campi che accetta. La maggior parte dei tipi corrisponde esattamente; hostPattern e pathPattern corrispondono per regex, e le voci github possono utilizzare un wildcard del proprietario.

Source Example entry Fields
github { "source": "github", "repo": "acme-corp/plugins", "ref": "main", "path": "marketplace" } repo obbligatorio; ref è un ramo o un tag; path è una sottodirectory
git { "source": "git", "url": "https://gitlab.example.com/tools/plugins.git", "ref": "production" } url obbligatorio; ref e path come per github
url { "source": "url", "url": "https://plugins.example.com/marketplace.json", "headers": { "Authorization": "Bearer ${TOKEN}" } } url obbligatorio; headers aggiunge intestazioni HTTP per l'accesso autenticato
npm { "source": "npm", "package": "@acme-corp/claude-plugins" } package obbligatorio, il pacchetto npm che contiene marketplace.json
file { "source": "file", "path": "/opt/acme-corp/plugins/marketplace.json" } path obbligatorio, il percorso assoluto a un file marketplace.json
directory { "source": "directory", "path": "/opt/acme-corp/approved-marketplaces" } path obbligatorio, il percorso assoluto a una directory contenente .claude-plugin/marketplace.json
hostPattern { "source": "hostPattern", "hostPattern": "^github\\.example\\.com$" } hostPattern obbligatorio, una regex confrontata con l'host del marketplace
pathPattern { "source": "pathPattern", "pathPattern": "^/opt/approved/" } pathPattern obbligatorio, una regex confrontata con il path delle fonti file e directory
skills-dir { "source": "skills-dir" } Nessun campo. Riattiva la scansione del plugin ~/.claude/skills/

Tre tipi di fonte portano regole oltre la tabella:

  • url: un marketplace URL scarica solo il file marketplace.json e Claude Code non recupera i file plugin per percorso relativo da quel server, quindi i suoi plugin devono utilizzare una fonte plugin diversa da un percorso relativo, come un URL di archivio, che può essere sullo stesso host. Per i plugin con percorsi relativi, utilizza un marketplace basato su Git. Vedi I plugin con percorsi relativi falliscono nei marketplace basati su URL.

  • hostPattern: usalo per consentire ogni marketplace su un server GitHub Enterprise o GitLab interno senza elencare ogni repository. Claude Code confronta le fonti github con github.com, prende il nome host dalle fonti url e lo prende dalle fonti git a seconda della forma dell'URL git:

    • Un URL con uno schema, come https:// o ssh://: il nome host nell'URL.
    • Un indirizzo SSH senza schema, nella forma user@host:path di git, come git@git.example.com:tools/plugins.git: l'host tra @ e :, che è l'host a cui git si connette.
    • Qualsiasi altra forma senza schema: nessun host, quindi nessuna voce strictKnownMarketplaces hostPattern la corrisponde. Per una blockedMarketplaces hostPattern, Claude Code prende un host da un insieme più ampio di forme, quindi una voce della lista di blocco può comunque corrispondere a tale forma. Prima di v2.1.234, una strictKnownMarketplaces hostPattern corrispondeva anche ad alcune forme che git non tratta come indirizzi SSH.

    Le fonti file e directory non hanno host e non corrispondono mai a una voce hostPattern.

  • pathPattern: usalo per consentire marketplace del filesystem insieme alle voci hostPattern per le fonti di rete. ".*" consente ogni percorso locale; un pattern più stretto come "^/opt/approved/" limita a una directory.

Qualsiasi lista di autorizzazione, anche una vuota, interrompe anche il caricamento dei plugin @skills-dir da ~/.claude/skills/ da parte di Claude Code. Aggiungi la voce { "source": "skills-dir" } per continuare a caricarli; la voce non ha significato al di fuori di questa chiave e blockedMarketplaces.

Wildcard del proprietario

Una voce github il cui valore repo è "<owner>/*" corrisponde a ogni repository sotto quel proprietario GitHub. I wildcard del proprietario richiedono Claude Code v2.1.223 o successivo e funzionano solo in strictKnownMarketplaces e blockedMarketplaces. Ovunque altrove appaia una fonte github, come extraKnownMarketplaces o /plugin marketplace add, il valore repo deve nominare un singolo repository. Prima di v2.1.223, Claude Code confrontava la voce letteralmente, quindi una voce della lista di autorizzazione non corrispondeva a nessun repository e una voce della lista di blocco non bloccava nulla; le voci di singolo repository vengono applicate su ogni versione.

Questa voce consente qualsiasi repository di marketplace nell'organizzazione acme-corp:

{
  "strictKnownMarketplaces": [
    { "source": "github", "repo": "acme-corp/*" }
  ]
}

Solo l'intera posizione del nome del repository può essere un wildcard. Claude Code confronta voci come *, */plugins o acme-corp/tools-* letteralmente, quindi non corrispondono a nessun repository.

Le regole di corrispondenza differiscono tra le due impostazioni:

Rule strictKnownMarketplaces blockedMarketplaces
Matching source spellings Solo forma owner/repo. Un URL git che clona lo stesso repository non corrisponde Qualsiasi ortografia, inclusi gli URL git che si risolvono nello stesso repository github.com
Owner case Sensibile alle maiuscole, come la corrispondenza esatta della voce Insensibile alle maiuscole
ref Segue le regole di corrispondenza esatta: una voce con un ref corrisponde solo alle fonti con quel ref esatto, e una voce senza uno corrisponde solo alle fonti che non specificano un ref Una voce senza un ref blocca tutti i ref dei repository che corrisponde
path Più lasco delle regole di corrispondenza esatta: una voce con un path richiede quel valore esatto, mentre una voce senza uno corrisponde a qualsiasi percorso all'interno del repository Una voce senza un path blocca tutti i percorsi dei repository che corrisponde

Corrispondenza esatta

Per ogni tipo di fonte tranne le voci github con wildcard del proprietario e le voci hostPattern e pathPattern confrontate per regex, Claude Code consente l'aggiunta di un utente solo quando la fonte del marketplace corrisponde a una voce esattamente. Per le fonti basate su git github e git, la corrispondenza esatta include i campi facoltativi:

  • Il repo o url deve corrispondere esattamente
  • Il campo ref deve corrispondere esattamente, o entrambi devono essere non definiti
  • Il campo path deve corrispondere esattamente, o entrambi devono essere non definiti

Ad esempio, Claude Code tratta ogni coppia di seguito come due fonti diverse:

  • { "source": "github", "repo": "acme-corp/plugins" } e { "source": "github", "repo": "acme-corp/plugins", "ref": "main" }
  • { "source": "github", "repo": "acme-corp/plugins", "path": "marketplace" } e { "source": "github", "repo": "acme-corp/plugins" }

Consenti solo il marketplace ufficiale

Per consentire il marketplace ufficiale di Anthropic e nient'altro, elenca il suo repository:

{
  "strictKnownMarketplaces": [
    { "source": "github", "repo": "anthropics/claude-plugins-official" }
  ]
}

Con questa voce, Claude Code mantiene disponibile un marketplace ufficiale già registrato e, su una macchina nuova, registra il marketplace automaticamente la prima volta che avvii Claude Code in modo interattivo. La registrazione automatica più comunemente manca:

  • Ambienti non interattivi che vengono eseguiti prima del primo avvio interattivo della macchina.
  • Macchine dove Claude Code è già stato eseguito in modo interattivo sotto una policy che ha bloccato il marketplace, come il blocco dell'array vuoto. Claude Code registra il tentativo bloccato e non ritenta dopo il cambio della policy.

Su queste macchine, aggiungi il marketplace a extraKnownMarketplaces nello stesso managed-settings.json in modo che Claude Code lo registri automaticamente, o esegui claude plugin marketplace add anthropics/claude-plugins-official.

Combina con `extraKnownMarketplaces`

Le due chiavi svolgono lavori diversi. Questa tabella le confronta:

Aspect strictKnownMarketplaces extraKnownMarketplaces
Purpose Applicazione della policy organizzativa Comodità del team
Settings file Solo impostazioni gestite Qualsiasi file di impostazioni
Behavior Blocca le aggiunte non autorizzate Registra i marketplace mancanti
When enforced Prima delle operazioni di rete e filesystem Immediatamente dalle impostazioni utente o gestite; dopo la finestra di dialogo di fiducia dell'area di lavoro per i file di un repository
Can be overridden No, precedenza massima Sì, da impostazioni di precedenza superiore
Source format Oggetto di fonte diretto Marketplace denominato con un oggetto source annidato

Per limitare e pre-registrare un marketplace per tutti gli utenti, imposta entrambi in managed-settings.json:

{
  "strictKnownMarketplaces": [
    { "source": "github", "repo": "acme-corp/plugins" }
  ],
  "extraKnownMarketplaces": {
    "acme-tools": {
      "source": { "source": "github", "repo": "acme-corp/plugins" }
    }
  }
}

Con solo strictKnownMarketplaces impostato, gli utenti possono comunque aggiungere un marketplace autorizzato da soli con /plugin marketplace add. Il marketplace ufficiale di Anthropic è l'unico che Claude Code registra automaticamente, e solo quando la lista di autorizzazione lo consente. Consenti solo il marketplace ufficiale elenca le macchine che manca.

`strictPluginOnlyCustomization`

Blocca skills, agenti, hooks e server MCP da fonti utente e progetto, quindi possono provenire solo da plugin o impostazioni gestite. Combinalo con strictKnownMarketplaces per controllare l'intera catena di approvvigionamento della personalizzazione: la lista di autorizzazione del marketplace controlla quali plugin gli utenti possono installare.

  • Scope: Managed
  • Type: true per bloccare tutti e quattro i tipi di personalizzazione, o un array che nomina i tipi da bloccare, da "skills", "agents", "hooks" e "mcp"
  • Default: non impostato, quindi nulla è bloccato

Questo esempio blocca skills e hooks e lascia agenti e server MCP sbloccati:

{
  "strictPluginOnlyCustomization": ["skills", "hooks"]
}

Le quattro voci di sub-chiave di seguito elencano cosa blocca ogni superficie e cosa continua a caricarsi. Claude Code ignora i nomi di superficie che non riconosce piuttosto che fallire il file di impostazioni, quindi puoi aggiungere nuovi nomi di superficie prima che ogni client si sia aggiornato.

`strictPluginOnlyCustomization.skills`

Blocca la superficie skills. Claude Code interrompe il caricamento delle skills da ~/.claude/skills/ e .claude/skills/, comandi personalizzati da ~/.claude/commands/ e .claude/commands/, skills sotto directory --add-dir e skills sincronizzate dal tuo account claude.ai, e continua a caricare skills dei plugin, skills in bundle e skills nella directory della policy gestita.

{
  "strictPluginOnlyCustomization": ["skills"]
}

`strictPluginOnlyCustomization.agents`

Blocca la superficie agents. Claude Code interrompe il caricamento degli agenti da ~/.claude/agents/ e .claude/agents/, e continua a caricare agenti dei plugin, agenti incorporati e agenti nella directory della policy gestita.

{
  "strictPluginOnlyCustomization": ["agents"]
}

`strictPluginOnlyCustomization.hooks`

Blocca la superficie hooks. Claude Code interrompe l'esecuzione degli hooks da impostazioni utente, progetto e locale settings.json, e continua a eseguire hooks dei plugin e hooks nelle impostazioni gestite.

{
  "strictPluginOnlyCustomization": ["hooks"]
}

`strictPluginOnlyCustomization.mcp`

Blocca la superficie mcp. Claude Code interrompe il caricamento dei server MCP da ~/.claude.json e .mcp.json, e continua a caricare server MCP dei plugin, server managed-mcp.json e server da managedMcpServers.

{
  "strictPluginOnlyCustomization": ["mcp"]
}

`enabledPlugins`

Attiva o disattiva i singoli plugin, codificati per plugin-name@marketplace-name. Un plugin senza voce in alcuno scope ricade al suo valore defaultEnabled. Quando abiliti o disabiliti un plugin con /plugin o claude plugin enable, Claude Code scrive questa chiave per te.

  • Scope: Any file
  • Type: oggetto che mappa plugin-name@marketplace-name a un Boolean
  • Default: non impostato, quindi ogni plugin segue il suo valore defaultEnabled

Questo esempio abilita due plugin dal marketplace team-tools e disabilita uno da personal:

{
  "enabledPlugins": {
    "code-formatter@team-tools": true,
    "deployment-tools@team-tools": true,
    "experimental-features@personal": false
  }
}

Ogni scope serve a uno scopo diverso:

  • Impostazioni utente: le tue preferenze personali di plugin
  • Impostazioni progetto: plugin condivisi con tutti nel repository
  • Impostazioni locali: override per macchina, gitignored quando Claude Code salva un'impostazione lì
  • Impostazioni gestite: policy a livello di organizzazione. Un plugin impostato su false qui è bloccato dall'installazione in ogni scope e nascosto dal marketplace

Le impostazioni del progetto hanno precedenza sulle impostazioni utente, quindi impostare un plugin su false in ~/.claude/settings.json non disabilita un plugin che il .claude/settings.json del progetto abilita. Per rinunciare a un plugin abilitato dal progetto sulla tua macchina, impostalo su false in .claude/settings.local.json invece. I plugin forzatamente abilitati dalle impostazioni gestite non possono essere disabilitati in questo modo, poiché le impostazioni gestite sovrascrivono le impostazioni locali.

Abilitare un plugin da una fonte esterna come un repository GitHub o un pacchetto npm nel .claude/settings.json di un progetto non lo installa per altre persone. Su ogni percorso che carica i plugin, Claude Code segnala il plugin come non installato finché ogni utente non lo installa da solo.

`extraKnownMarketplaces`

Registra marketplace di plugin aggiuntivi per nome, in modo che le persone che aprono il repository, o tutti quelli che le impostazioni gestite raggiungono, ottengono il marketplace senza aggiungerlo da soli. Claude Code registra ogni marketplace che non conosce già. Se un plugin che enabledPlugins nomina da esso si installa dipende dalla fonte del plugin e da quale file lo abilita; quella voce ha le regole.

  • Scope: Any file. Claude Code onora le voci nel .claude/settings.json o .claude/settings.local.json di un repository solo dopo che accetti la finestra di dialogo di fiducia dell'area di lavoro per quella cartella; in una cartella che non hai fidato, inclusa un'esecuzione -p lì, le ignora senza un messaggio.
  • Type: oggetto che mappa un nome di marketplace a un oggetto con un oggetto source e un Boolean autoUpdate facoltativo
  • Default: non impostato

Questo esempio registra un marketplace GitHub e un marketplace da un URL git auto-ospitato:

{
  "extraKnownMarketplaces": {
    "acme-tools": {
      "source": {
        "source": "github",
        "repo": "acme-corp/claude-plugins"
      }
    },
    "security-plugins": {
      "source": {
        "source": "git",
        "url": "https://git.example.com/security/plugins.git"
      }
    }
  }
}

Cosa viene eseguito prima di fidare una cartella confronta il gate di fiducia con l'altro contenuto che un repository può fornire. Puoi anche scrivere questa chiave come additionalMarketplaces; vedi Alias di chiave Marketplace.

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. Quando omesso, claude-plugins-official e la maggior parte degli altri marketplace ufficiali di Anthropic predefiniti su true, e i marketplace di terze parti predefiniti su false. Vedi Configura gli auto-aggiornamenti.

Quando più di un file di impostazioni definisce una voce di marketplace con lo stesso nome, Claude Code utilizza la voce dal file di precedenza più alta nel complesso. Quella voce sostituisce la voce di precedenza inferiore e non eredita nessuno dei suoi campi, quindi una ridefinizione non può combinare le credenziali source.headers di un file con un URL che un altro file controlla. Prima di v2.1.228, Claude Code univa le voci con lo stesso nome campo per campo, quindi una voce in un file di precedenza superiore poteva ereditare campi che non impostava, incluso headers di un altro file.

Tipi di fonte di marketplace

L'oggetto source assume una di queste forme:

  • github: un repository GitHub, con repo
  • git: qualsiasi URL git, con url
  • url: un URL diretto a un file marketplace.json, con url e headers facoltativo e headersHelper per l'accesso autenticato. headersHelper nomina un comando che stampa intestazioni i cui valori sono troppo effimeri per elencare in headers, e richiede Claude Code v2.1.238 o successivo
  • file: un percorso locale a un file marketplace.json, con path
  • directory: un percorso del filesystem locale, con path, solo per lo sviluppo
  • settings: un marketplace inline dichiarato direttamente nel file di impostazioni senza un repository ospitato, con name e plugins

Il tipo di fonte git funziona con qualsiasi servizio di hosting git, incluso GitLab auto-ospitato e Bitbucket. Claude Code clona il repository con la stessa autenticazione che git clone userebbe su quella macchina: helper di credenziali configurati o chiavi SSH. Un token del provider come GITHUB_TOKEN ha effetto solo attraverso un helper di credenziali che lo legge. Vedi Repository privati per i dettagli di configurazione.

Per 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. Usalo quando il repository contiene grandi oggetti LFS non correlati al contenuto del plugin.

Per una fonte url, imposta headersHelper all'interno dell'oggetto source quando la credenziale in headers scade e un comando deve produrne una nuova. Richiede Claude Code v2.1.238 o successivo. Per cosa il comando deve stampare e dove Claude Code lo esegue, vedi Scrivi il comando headersHelper, e per i casi in cui Claude Code non lo esegue, vedi Quando Claude Code salta un comando headersHelper. Una volta che imposti headersHelper su un URL di marketplace https://, Claude Code esegue il comando in due punti, riutilizzando l'output di un'esecuzione per fino a 60 secondi:

  • Prima di ogni recupero del marketplace.json di quel marketplace, incluso un aggiornamento successivo. Claude Code invia le intestazioni stampate con quel recupero.
  • Prima di ogni download di archivio plugin sull'origine dell'URL del marketplace, significando lo stesso schema, host e porta. Claude Code invia l'output con quel download, e nessun altro download ottiene le intestazioni.

Claude Code ignora qualsiasi headersHelper impostato nel .claude/settings.json o .claude/settings.local.json di una directory che aggiungi con --add-dir, su una fonte url e su una voce di plugin inline allo stesso modo, e invia solo gli headers fissi impostati in quel file. Come gli utenti accettano un comando headersHelper copre gli altri file di impostazioni.

I plugin elencati in una fonte settings devono fare riferimento a fonti esterne come GitHub o npm, e il name deve corrispondere alla chiave del marketplace. Abiliti comunque ogni plugin separatamente in enabledPlugins. Questo esempio dichiara un plugin inline:

{
  "extraKnownMarketplaces": {
    "team-tools": {
      "source": {
        "source": "settings",
        "name": "team-tools",
        "plugins": [
          {
            "name": "code-formatter",
            "source": {
              "source": "github",
              "repo": "acme-corp/code-formatter"
            }
          }
        ]
      }
    }
  }
}

Una voce di plugin sotto source: 'settings' la cui propria source è un archive può impostare headers per il download dell'archivio. Se il valore che metteresti in headers è effimero, come un token che il tuo registro conia su richiesta, imposta un comando headersHelper invece. Una voce può impostare entrambi. Entrambi i campi richiedono Claude Code v2.1.238 o successivo.

Claude Code invia gli headers della voce e tutto ciò che il comando stampa, con il download dell'archivio di quel plugin e con nessun altro download. Claude Code esegue il comando solo quando un utente installa o aggiorna quel singolo plugin da solo. Tre ulteriori regole dipendono da quale file contiene la voce:

  • strict: a differenza di una voce nel marketplace.json di un marketplace, una voce nelle impostazioni non ha bisogno di "strict": false, perché un file di impostazioni non porta campi di manifesto da inline. Vedi Modalità strict.
  • Fiducia della cartella: per una voce nel .claude/settings.json o .claude/settings.local.json di un progetto, Claude Code esegue il comando solo dopo che l'utente ha anche fidato quella cartella.
  • Filtro intestazione: Claude Code elimina i nomi di intestazione di routing delle richieste e identità del client da una voce nel .claude/settings.json o .claude/settings.local.json di un progetto, perché un repository può fornire quei file. Claude Code applica lo stesso filtro a una voce di catalogo e a una voce in una directory --add-dir, e nessun filtro a una voce nelle tue impostazioni utente, un file --settings o impostazioni gestite.

Alias di chiave Marketplace

Su Claude Code v2.1.232 o successivo, puoi scrivere extraKnownMarketplaces come additionalMarketplaces e strictKnownMarketplaces come allowedMarketplaces. Claude Code tratta ogni alias come segue:

  • Le versioni precedenti ignorano l'alias, quindi mantieni l'ortografia canonica in un file che le versioni precedenti leggono anche, come un file di impostazioni gestite per una flotta con versioni Claude Code miste.
  • In qualsiasi file di impostazioni che accetta la chiave canonica, Claude Code legge l'alias esattamente come legge la chiave canonica.
  • Claude Code può riscrivere additionalMarketplaces a extraKnownMarketplaces quando aggiorna il file.
  • Se imposti entrambe le ortografie in un file, Claude Code utilizza il valore canonico e ignora l'alias.

`pluginConfigs`

Archivia le risposte non sensibili che dai al dialogo di configurazione userConfig di un plugin, codificato per ID plugin. Claude Code scrive questa chiave alle tue impostazioni utente quando riempi il dialogo, quindi non devi modificarla a mano. Claude Code archivia le opzioni sensibili nel Portachiavi di macOS invece, ricadendo a ~/.claude/.credentials.json quando il Portachiavi rifiuta la scrittura; su piattaforme senza un portachiavi supportato, le archivia in ~/.claude/.credentials.json.

  • Scope: User or managed
  • Type: oggetto che mappa un ID plugin a un oggetto con un campo options, mappando ogni nome di opzione a una stringa, numero, Boolean o array di stringhe, e un campo mcpServers facoltativo che contiene valori di configurazione utente per server nella stessa forma
  • Default: non impostato

Questo esempio archivia l'opzione api_endpoint per il plugin deployer da acme-tools:

{
  "pluginConfigs": {
    "deployer@acme-tools": {
      "options": {
        "api_endpoint": "https://api.example.com"
      }
    }
  }
}

Claude Code ignora le voci di progetto e locale perché sostituisce questi valori nelle configurazioni di hook, MCP e LSP del plugin, e un repository clonato non deve essere in grado di fornirli. Prima di v2.1.207, anche le impostazioni di progetto e locale venivano lette.

MCP

Controllare a quali server MCP Claude Code si connette e quali un'organizzazione consente. Vedere Connettere a strumenti esterni con MCP e Configurazione MCP gestita.

`allowAllClaudeAiMcps`

Caricare i connettori claude.ai che Claude Code recupera da solo insieme a un managed-mcp.json distribuito. Senza questa chiave, managed-mcp.json assume il controllo esclusivo dei server MCP e sopprime quei connettori.

  • Scope: Managed. Gli utenti non possono riabilitare i connettori che il controllo esclusivo ha soppresso.
  • Type: Boolean
    • true: Claude Code carica i connettori claude.ai insieme a un managed-mcp.json distribuito
    • false: un managed-mcp.json distribuito assume il controllo esclusivo dei server MCP e sopprime i connettori claude.ai che Claude Code recupera da solo
  • Default: false, quindi un managed-mcp.json distribuito sopprime i connettori claude.ai che Claude Code recupera da solo
{
  "allowAllClaudeAiMcps": true
}

allowedMcpServers e deniedMcpServers si applicano ancora ai connettori che questa chiave carica. I connettori consegnati a una sessione cloud il cui host contiene un managed-mcp.json, come un runner auto-ospitato, rimangono soppressi. Vedere Consentire i connettori claude.ai insieme al set gestito.

`allowedMcpServers`

Creare un elenco di autorizzazione dei server MCP che le persone possono aggiungere. Claude Code blocca qualsiasi server che non corrisponde a una voce ovunque sia definito, inclusi i server plugin, i server passati con --mcp-config e i server da claude.ai.

I server incorporati come Claude in Chrome, il server ide a cui Claude Code si connette in un VS Code o JetBrains IDE in esecuzione e i server che la CLI stessa configura sono esenti dall'elenco di autorizzazione e l'elenco di negazione si applica ancora a loro. I server type: "sdk" in-process sono esenti da entrambi gli elenchi; l'app che ha avviato la sessione li registra.

I server che l'organizzazione fornisce sono anche esenti dall'elenco di autorizzazione e l'elenco di negazione si applica ancora a loro. L'esenzione copre ogni voce managedMcpServers e qualsiasi voce managed-mcp.json i cui valori non utilizzano l'espansione ${VAR}. Vedere Come viene valutato un server per l'ordine di controllo completo. Prima della v2.1.259, i server da managed-mcp.json dovevano corrispondere anche loro.

  • Scope: Any file. Le voci di ogni file si uniscono in un elenco di autorizzazione a meno che allowManagedMcpServersOnly non sia impostato. Distribuirlo nelle impostazioni gestite per applicarlo.
  • Type: array di oggetti, ognuno con esattamente una chiave: serverName, una stringa limitata a lettere, numeri, trattini e sottolineature; serverCommand, un array del comando e dei suoi argomenti abbinati esattamente; o serverUrl, un modello di URL con caratteri jolly *
  • Default: non impostato, quindi ogni server è consentito; un array vuoto blocca ogni server che gli utenti aggiungono

Questo esempio consente solo il server stdio che il comando npx elencato avvia:

{
  "allowedMcpServers": [
    { "serverCommand": ["npx", "-y", "@modelcontextprotocol/server-filesystem"] }
  ]
}

Una voce deniedMcpServers ha la precedenza, quindi un server in entrambi gli elenchi è bloccato. Una volta che l'elenco contiene qualsiasi voce serverCommand, un server stdio deve corrispondere a una voce serverCommand, e una volta che contiene qualsiasi voce serverUrl, un server remoto deve corrispondere a una voce serverUrl: una corrispondenza serverName non ammette più quel tipo di server. Vedere Controllo basato su criteri con elenchi di autorizzazione e negazione.

`allowManagedMcpServersOnly`

Rendere l'elenco di autorizzazione gestito l'unico che si applica. Claude Code legge quindi allowedMcpServers solo dalle impostazioni gestite e ignora gli elenchi di autorizzazione nelle impostazioni utente, progetto e locale; deniedMcpServers si unisce ancora da ogni ambito di impostazioni, quindi gli utenti possono ancora bloccare i server per se stessi. Gli amministratori lo impostano in modo che le impostazioni proprie di un utente non possano ampliare ciò che l'elenco di autorizzazione gestito consente.

  • Scope: Managed
  • Type: Boolean
    • true: Claude Code legge allowedMcpServers solo dalle impostazioni gestite e ignora gli elenchi di autorizzazione nelle impostazioni utente, progetto e locale
    • false: gli elenchi di autorizzazione da ogni ambito di impostazioni si uniscono
  • Default: false, quindi gli elenchi di autorizzazione da ogni ambito di impostazioni si uniscono

Questo esempio blocca l'elenco di autorizzazione alle impostazioni gestite e consente solo il server denominato github:

{
  "allowManagedMcpServersOnly": true,
  "allowedMcpServers": [
    { "serverName": "github" }
  ]
}

Gli utenti possono comunque aggiungere server MCP propri; solo i server che corrispondono all'elenco di autorizzazione gestito vengono caricati. Vedere Limitare l'elenco di autorizzazione alle sole impostazioni gestite.

`deniedMcpServers`

Bloccare server MCP specifici. Claude Code rifiuta di caricare un server corrispondente ovunque sia definito, inclusi i server plugin, i server passati con --mcp-config, i server da managed-mcp.json, i server da managedMcpServers e i connettori claude.ai che recupera da solo. I server type: "sdk" in-process sono esenti; l'app che ha avviato la sessione li registra.

  • Scope: Any file. Le voci di ogni file si uniscono in un elenco di negazione e allowManagedMcpServersOnly non cambia questo. Distribuirlo nelle impostazioni gestite per applicarlo.
  • Type: array di oggetti, ognuno con esattamente una chiave: serverName, qualsiasi stringa non vuota, quindi il nome visualizzato di un connettore claude.ai come "claude.ai Slack" funziona; serverCommand, un array del comando e dei suoi argomenti abbinati esattamente; o serverUrl, un modello di URL con caratteri jolly *
  • Default: non impostato, quindi nessun server è bloccato; un array vuoto non blocca nulla
{
  "deniedMcpServers": [
    { "serverName": "filesystem" }
  ]
}

L'elenco di negazione ha la precedenza su allowedMcpServers, quindi un server in entrambi gli elenchi è bloccato. Vedere Controllo basato su criteri con elenchi di autorizzazione e negazione.

`disableClaudeAiConnectors`

Disattivare i connettori MCP claude.ai che Claude Code recupera da solo, in modo che non li recuperi né li connetta. Un true in qualsiasi file di impostazioni si applica: un .claude/settings.json di progetto archiviato può escludere un repository da quei connettori, ma un false a livello di progetto non può sovrascrivere un true a livello di utente o gestito. Richiede Claude Code v2.1.182 o successivo.

  • Scope: Any file
  • Type: Boolean
    • true: Claude Code non recupera né connette quei connettori
    • false: lo stesso di non impostato; Claude Code recupera i tuoi connettori a meno che un altro file di impostazioni o ENABLE_CLAUDEAI_MCP_SERVERS non li disattivi
  • Default: false, quindi Claude Code recupera i tuoi connettori
  • Per-session overrides: ENABLE_CLAUDEAI_MCP_SERVERS impostato su false disattiva i connettori per una sessione; qualunque dei due li disattivi, l'altro non può riattivarli
{
  "disableClaudeAiConnectors": true
}

I server che passi esplicitamente con --mcp-config non sono interessati. Per bloccare i singoli connettori invece di tutti, usa deniedMcpServers. Vedere Disattivare i connettori claude.ai. Richiede Claude Code v2.1.182 o successivo.

`disabledMcpjsonServers`

Rifiutare server specifici definiti nel file .mcp.json di un progetto in modo che Claude Code non li connetta mai o non ti chieda di approvarli. Un rifiuto in qualsiasi file di impostazioni si applica, incluso un .claude/settings.json di progetto archiviato nel repository.

  • Scope: Any file
  • Type: array di stringhe, i nomi dei server come appaiono in .mcp.json
  • Default: non impostato
{
  "disabledMcpjsonServers": ["filesystem"]
}

Claude Code scrive questa chiave in .claude/settings.local.json quando rifiuti un server nella finestra di dialogo di approvazione. claude mcp get <name> mostra un server rifiutato come ✘ Rejected (see disabledMcpjsonServers in settings). Il rifiuto ha la precedenza su enabledMcpjsonServers e enableAllProjectMcpServers.

`enableAllProjectMcpServers`

Approvare ogni server MCP definito nei file .mcp.json del progetto senza un prompt. Claude Code scrive questa chiave in .claude/settings.local.json quando scegli di approvare tutti i server nella finestra di dialogo di approvazione.

  • Scope: Any file. In una cartella la cui finestra di dialogo di fiducia non hai accettato, Claude Code la onora dalle impostazioni utente, impostazioni gestite e --settings e la ignora nel file di progetto condiviso, sia nella sessione che per claude mcp list e claude mcp get; Approvazioni dei server di progetto e fiducia dell'area di lavoro dice quando un .claude/settings.local.json non tracciato conta anche.
  • Type: Boolean
    • true: Claude Code approva ogni server MCP definito nei file .mcp.json del progetto senza un prompt
    • false: Claude Code ti chiede di approvare ogni server. In una cartella attendibile, un false in un file con precedenza più alta sovrascrive un true in uno inferiore; in una cartella che non hai attendibile, un true in qualsiasi file onorato è sufficiente
  • Default: non impostato, quindi Claude Code ti chiede di approvare ogni server
{
  "enableAllProjectMcpServers": true
}

Una voce disabledMcpjsonServers rifiuta comunque un server.

`enabledMcpjsonServers`

Approvare server specifici definiti nei file .mcp.json del progetto in modo che Claude Code li connetta senza chiedere. Claude Code scrive questa chiave in .claude/settings.local.json quando approvi un server nella finestra di dialogo di approvazione.

  • Scope: Any file. In una cartella la cui finestra di dialogo di fiducia non hai accettato, Claude Code la onora dalle impostazioni utente, impostazioni gestite e --settings e la ignora nel file di progetto condiviso, sia nella sessione che per claude mcp list e claude mcp get; Approvazioni dei server di progetto e fiducia dell'area di lavoro dice quando un .claude/settings.local.json non tracciato conta anche.
  • Type: array di stringhe, i nomi dei server come appaiono in .mcp.json
  • Default: non impostato

Questo esempio approva i server memory e github dal .mcp.json del progetto:

{
  "enabledMcpjsonServers": ["memory", "github"]
}

Una voce disabledMcpjsonServers rifiuta comunque un server.

`managedMcpServers`

Fornire server MCP remoti a ogni utente dalle impostazioni gestite. Gli utenti mantengono i server che aggiungono da soli e non possono modificare o rimuovere quelli che fornisci. Richiede Claude Code v2.1.259 o successivo.

  • Scope: Managed. Claude Code elimina la chiave con un avviso nelle impostazioni utente, progetto e locale e non la legge nella scheda Code dell'app Claude Desktop su una distribuzione di terze parti o nelle sessioni Cowork dell'app, dove Claude Desktop fornisce e blocca i server MCP di quelle sessioni stesso.
  • Type: oggetto con chiave per nome del server. Ogni voce ha la forma .mcp.json per un server http o sse: un url https:// obbligatorio e facoltativamente headers, oauth e le altre opzioni HTTP e SSE. Claude Code elimina le voci che non superano la convalida e Cosa può contenere una voce elenca le condizioni
  • Default: non impostato, quindi le impostazioni gestite non forniscono server

Questo esempio fornisce un server HTTP denominato search:

{
  "managedMcpServers": {
    "search": {
      "type": "http",
      "url": "https://search.example.com/mcp"
    }
  }
}

Per la precedenza, come i server forniti si combinano con managed-mcp.json e gli elenchi di autorizzazione e negazione, e cosa vedono gli utenti, vedere Fornire server tramite impostazioni gestite.

Agenti, sessioni e worktrees

Impostare l'agente predefinito, controllare i compagni di squadra e la messaggistica tra sessioni, e configurare i worktrees. Vedere Subagenti e Worktrees.

`agent`

Eseguire il thread principale come un subagente denominato, in modo che Claude Code applichi il prompt di sistema, le restrizioni degli strumenti e il modello di quel subagente alla sessione. La stessa chiave imposta l'agente predefinito per le sessioni che si inviano da claude agents.

  • Scope: Any file
  • Type: string, il nome di un agente integrato o personalizzato
  • Default: non impostato, quindi il thread principale viene eseguito come agente predefinito di Claude Code
  • Per-session overrides: --agent ha la precedenza su questa chiave per una sessione
{
  "agent": "code-reviewer"
}

Il settings.json di un plugin può anche fornire questa chiave; vedere Ship default settings with your plugin.

`crossSessionInbound`

Scegliere cosa fa questa sessione con i messaggi provenienti dalle altre sessioni di Claude Code. Quando nessun valore si applica, Claude Code decide per messaggio dalle classi della modalità di autorizzazione delle due sessioni. Richiede Claude Code v2.1.224 o successivo.

  • Scope: Any file. Un valore di progetto o locale si applica solo quando è più rigoroso del valore delle impostazioni gestite, del flag --settings o delle impostazioni utente.
  • Type: string, uno di:
    • "accept": Claude Code consegna il messaggio a Claude
    • "hold": Claude Code mostra un avviso per il messaggio senza consegnarlo
    • "refuse": Claude Code scarta il messaggio
  • Default: non impostato, quindi Claude Code decide per messaggio
{
  "crossSessionInbound": "hold"
}

Claude Code legge prima le impostazioni gestite, poi il flag --settings, poi le impostazioni utente, e applica il primo valore trovato. refuse è più rigoroso di hold, e hold è più rigoroso di accept. Quando nessuna delle fonti attendibili imposta un valore, un hold o refuse di progetto o locale si applica comunque, sostituendo il valore predefinito per messaggio. Nelle sessioni con messaggistica tra sessioni, questa chiave appare in /config come Messages from your other sessions, che la scrive nelle impostazioni utente; la riga richiede Claude Code v2.1.232 o successivo, e Claude Code la nasconde mentre il flag --settings o le impostazioni gestite impostano la chiave.

Claude Code avverte quando si imposta un valore che non riconosce. Mentre quel valore è presente in un file utente, progetto, locale o --settings, Claude Code trattiene i messaggi in entrata, anche quando una fonte che ha la precedenza imposta accept. Un refuse che un'altra fonte imposta si applica comunque. Correggere o rimuovere il valore per cancellare la sospensione.

Quando il valore non riconosciuto è nelle impostazioni gestite, Claude Code lo tratta invece come refuse finché un amministratore non lo corregge. Prima della v2.1.248, Claude Code ignorava un valore non riconosciuto senza avviso.

`disableAgentView`

Disattivare gli agenti di background e la visualizzazione agente: claude agents, --bg, /background e il supervisore su richiesta. Impostarlo nelle impostazioni gestite per applicarlo a un'organizzazione.

  • Scope: Any file
  • Type: Boolean
    • true: Claude Code disattiva claude agents, --bg, /background e il supervisore su richiesta
    • false: la visualizzazione agente è disponibile
  • Default: non impostato, quindi la visualizzazione agente è disponibile
  • Per-session overrides: CLAUDE_CODE_DISABLE_AGENT_VIEW disattiva la visualizzazione agente per una sessione; qualunque dei due la disattivi, l'altro non può riattivarla
{
  "disableAgentView": true
}

`isolatePeerMachines`

Richiedere l'approvazione esplicita prima che SendMessage di Claude raggiunga una delle sessioni oltre questa macchina; vedere Require approval for cross-machine messages. Il prompt di approvazione appare anche nella modalità bypassPermissions.

  • Scope: Any file. Un true da qualsiasi scope si applica, quindi un file di progetto archiviato può attivare il requisito ma non disattivarlo.
  • Type: Boolean
    • true: Claude Code chiede l'approvazione prima che SendMessage di Claude raggiunga una delle sessioni oltre questa macchina
    • false: i messaggi tra macchine non richiedono un prompt
  • Default: non impostato, quindi i messaggi tra macchine non richiedono un prompt
{
  "isolatePeerMachines": true
}

L'approvazione SendMessage tra macchine richiede Claude Code v2.1.224 o successivo.

`processWrapper`

Su macOS e Linux, posizionare un comando di avvio aziendale davanti ai processi di background che Claude Code avvia. Claude Code esegue l'avvio con la propria riga di comando aggiunta, quindi l'avvio deve eseguire in Claude Code; vedere Run Claude Code behind a corporate launcher per il contratto dell'avvio. Richiede Claude Code v2.1.210 o successivo.

  • Scope: User or managed
  • Type: string, il comando dell'avvio come prefisso argv, come un percorso assoluto con argomenti facoltativi
  • Default: non impostato, quindi i processi di background si avviano senza wrapper
  • Per-session overrides: CLAUDE_CODE_PROCESS_WRAPPER ha la precedenza su questa chiave per una sessione
{
  "processWrapper": "/opt/corp/launcher --profile claude"
}

Claude Code ignora l'avvio su Windows e avvia ogni processo senza wrapper. Richiede Claude Code v2.1.210 o successivo.

`teammateMode`

Scegliere dove Claude Code mostra i compagni di squadra del team agente: all'interno del riquadro terminale principale, o in riquadri divisi quando il terminale li supporta. Vedere Choose a display mode.

  • Scope: Any file. Claude Code legge anche un valore lasciato in ~/.claude.json da versioni precedenti.
  • Type: string, uno di:
    • "in-process": i compagni di squadra vengono eseguiti all'interno del riquadro terminale principale
    • "auto": riquadri divisi quando si esegue all'interno di tmux, o all'interno di iTerm2 con it2 sul PATH o tmux installato; in-process altrimenti
    • "tmux": riquadri divisi utilizzando tmux o iTerm2, rilevati dal terminale
    • "iterm2": riquadri divisi nativi di iTerm2 tramite la CLI it2, in Claude Code v2.1.186 o successivo
  • Default: "in-process"
  • Per-session overrides: --teammate-mode ha la precedenza su questa chiave per una sessione
{
  "teammateMode": "auto"
}

Prima della v2.1.179, il valore predefinito era auto. Il valore iterm2 richiede Claude Code v2.1.186 o successivo.

`worktree`

Configurare come Claude Code crea e gestisce i git worktrees per --worktree, lo strumento EnterWorktree e i subagenti isolati e le sessioni di background.

  • Scope: Any file
  • Type: object con baseRef, symlinkDirectories, sparsePaths e bgIsolation
  • Default: non impostato

Questo esempio crea rami di nuovi worktrees dal HEAD corrente e crea symlink di node_modules in ognuno:

{
  "worktree": {
    "baseRef": "head",
    "symlinkDirectories": ["node_modules"]
  }
}

Per copiare file ignorati da git come .env nei nuovi worktrees, aggiungere un file .worktreeinclude alla radice del progetto invece di un'impostazione.

`worktree.baseRef`

Scegliere da quale ref i nuovi worktrees si diramano. "fresh" si dirama da origin/<default-branch> per un albero pulito che corrisponde al remoto; "head" si dirama dal HEAD locale corrente, quindi i commit non inviati e lo stato del ramo di funzionalità sono presenti nel worktree.

  • Scope: Any file
  • Type: string, uno di:
    • "fresh": i nuovi worktrees si diramano da origin/<default-branch>
    • "head": i nuovi worktrees si diramano dal HEAD locale corrente, inclusi i commit non inviati
  • Default: "fresh"
{
  "worktree": {
    "baseRef": "head"
  }
}

All'interno di un worktree collegato, "head" si risolve nel HEAD di quel worktree, non nel checkout principale.

`worktree.symlinkDirectories`

Creare symlink di directory dal repository principale in ogni worktree in modo da non duplicare directory di grandi dimensioni su disco.

  • Scope: Any file
  • Type: array di strings, percorsi di directory relativi alla radice del repository
  • Default: non impostato, quindi Claude Code non crea symlink di directory

Questo esempio crea symlink di node_modules e .cache dal repository principale in ogni nuovo worktree:

{
  "worktree": {
    "symlinkDirectories": ["node_modules", ".cache"]
  }
}

`worktree.sparsePaths`

Estrarre solo le directory elencate in ogni worktree tramite git sparse-checkout. Claude Code scrive solo quelle directory più i file a livello di radice su disco, il che è più veloce nei monorepo di grandi dimensioni; vedere Check out only the directories you need.

  • Scope: Any file
  • Type: array di strings, percorsi di directory relativi alla radice del repository
  • Default: non impostato, quindi ogni worktree estrae l'intero albero

Questo esempio estrae solo packages/my-app e shared/utils, più i file a livello di radice, in ogni worktree:

{
  "worktree": {
    "sparsePaths": ["packages/my-app", "shared/utils"]
  }
}

Mentre esiste un worktree sparse, git abilita extensions.worktreeConfig nel .git/config condiviso del repository.

`worktree.bgIsolation`

Scegliere come le sessioni di background isolano le loro modifiche ai file. Con "worktree", Claude Code blocca Edit e Write nel checkout principale finché la sessione non chiama EnterWorktree; con "none", i lavori di background modificano direttamente la copia di lavoro. Impostare "none" per un repository dove i git worktrees non sono pratici.

  • Scope: Any file
  • Type: string, uno di:
    • "worktree": Claude Code blocca Edit e Write nel checkout principale finché la sessione non chiama EnterWorktree
    • "none": i lavori di background modificano direttamente la copia di lavoro
  • Default: "worktree"
{
  "worktree": {
    "bgIsolation": "none"
  }
}

Al di fuori di un repository git, un hook WorktreeCreate che fallisce rilascia il blocco in modo che la sessione possa modificare la directory di lavoro in posizione; quel rilascio richiede Claude Code v2.1.203 o successivo.

Controllo remoto, desktop e notifiche

Configura il Controllo remoto, gli ambienti cloud, l'app desktop e le notifiche che Claude Code invia quando ha bisogno di te. Vedi Controllo remoto.

`agentPushNotifEnabled`

Consenti a Claude di inviare una notifica push al tuo telefono quando decide che ne vale la pena, ad esempio quando un'attività lunga si conclude. Claude Code sincronizza questa scelta al tuo account e le notifiche push arrivano mentre il Controllo remoto è connesso. Appare in /config come Push quando Claude decide.

  • Scope: Any file. Claude Code legge anche un valore lasciato in ~/.claude.json da versioni precedenti.
  • Type: Boolean
    • true: Claude può inviare una notifica push al tuo telefono quando decide che ne vale la pena
    • false: Claude non invia quelle notifiche
  • Default: false
{
  "agentPushNotifEnabled": true
}

Vedi Notifiche push mobile.

`awaySummaryEnabled`

Mostra un riepilogo di una riga della sessione quando torni al terminale dopo alcuni minuti di assenza. Impostalo su false o disattiva Session recap in /config per interrompere il riepilogo.

  • Scope: Any file
  • Type: Boolean
    • true: vedi un riepilogo di una riga della sessione quando torni dopo alcuni minuti di assenza
    • false: Claude Code non mostra alcun riepilogo
  • Default: non impostato, quindi il riepilogo è attivo
  • Per-session overrides: CLAUDE_CODE_ENABLE_AWAY_SUMMARY ha la precedenza su questa chiave per una sessione, in entrambe le direzioni
{
  "awaySummaryEnabled": false
}

Claude Code non mostra mai il riepilogo in modalità non interattiva.

`disableArtifact`

Usa enableArtifact invece per disattivare lo strumento Artifact, che pubblica l'output della sessione come pagina web privata su claude.ai. Quando disattivi la riga Artifacts in /config, Claude Code scrive enableArtifact nelle tue impostazioni utente e cancella questa chiave.

  • Scope: Any file
  • Type: Boolean
    • true: Claude Code disattiva lo strumento Artifact per ogni sessione a cui il file si applica e nessun altro file lo riattiva. Prima della v2.1.242, un file con precedenza più alta potrebbe sovrascrivere un true di un file inferiore piuttosto che la chiave agire come un blocco
    • false: ignorato; per lasciare lo strumento attivo, rimuovi la chiave
  • Default: non impostato, quindi lo strumento segue la disponibilità del tuo account
  • Per-session overrides: CLAUDE_CODE_DISABLE_ARTIFACT impostato su 1 disattiva lo strumento per una sessione
{
  "disableArtifact": true
}

Disabilita artefatti elenca ogni modo per disattivare lo strumento.

`disableDeepLinkRegistration`

Impedisci a Claude Code di registrare il gestore del protocollo claude-cli:// con il sistema operativo, che altrimenti fa dopo che invii il primo prompt di una sessione interattiva. I Deep link consentono agli strumenti esterni di aprire una sessione Claude Code con un prompt precompilato. Impostalo in ambienti in cui la registrazione del gestore del protocollo è limitata o gestita separatamente.

  • Scope: Any file
  • Type: la stringa "disable"
  • Default: non impostato, quindi Claude Code registra il gestore
{
  "disableDeepLinkRegistration": "disable"
}

`disableDesktopLocalSessions`

Disattiva le sessioni Code che vengono eseguite sul dispositivo nell'app desktop, per distribuzioni in cui gli sviluppatori dovrebbero lavorare su macchine remote tramite SSH. Nella scheda Code, l'ambiente Local rimane nel menu a discesa dell'ambiente ma è disattivato e non può essere selezionato, con un tooltip che dice che la tua organizzazione lo ha disattivato; su Windows la voce WSL è disattivata allo stesso modo, anche se se le sessioni WSL vengono eseguite su un dispositivo gestito è governato separatamente. Le nuove sessioni predefinite alla prima connessione SSH se ne è configurata una, e l'app rifiuta di avviare o riprendere una sessione sul dispositivo, inclusa una connessione SSH allo stesso computer. Le sessioni SSH ad altri host e le sessioni cloud non sono interessate. L'app desktop legge questa chiave; il CLI del terminale la ignora. Richiede Claude Desktop v1.37937.0 o successivo.

  • Scope: Managed
  • Type: Boolean; solo il Boolean JSON true ha effetto
    • true: l'app desktop non offre sessioni Code on-device; le sessioni locali esistenti rimangono elencate ma non possono continuare
    • false: le sessioni locali rimangono disponibili
  • Default: non impostato, quindi le sessioni locali sono disponibili
{
  "disableDesktopLocalSessions": true
}

L'app desktop ignora qualsiasi altro valore e un valore che non è un Boolean, come la stringa "true" o 1, registra anche un avviso. Abbinalo a sshConfigs in modo che gli utenti si trovino su una connessione funzionante e con sshHostAllowlist per limitare quali host possono raggiungere. Vedi Sessioni locali su dispositivi gestiti.

Claude Desktop fornisce sessioni Code con policy derivata dalla tua configurazione desktop, ad esempio l'allowlist di uscita, la sandbox del filesystem e le restrizioni MCP nelle distribuzioni di terze parti. Claude Code ignora quelle impostazioni padre ogni volta che è presente un'origine amministratore: impostazioni gestite dal server, una policy MDM o a livello di sistema operativo, o un file di impostazioni gestite. Distribuire questa chiave attraverso uno di questi su un dispositivo che non ne aveva nessuno prima, come nelle distribuzioni di terze parti, quindi interrompe l'applicazione delle policy derivate dal desktop. Consenti a un host di incorporamento di aggiungere policy copre quando le impostazioni padre possono ancora unirsi; questo vale per qualsiasi chiave che distribuisci in quel modo, non solo questa.

`disableRemoteControl`

Disattiva il Controllo remoto: Claude Code rifiuta quindi claude remote-control, il flag --remote-control, l'avvio automatico e l'interruttore in-sessione e segnala che la policy della tua organizzazione lo ha disabilitato. Posizionalo nelle impostazioni gestite per l'applicazione MDM per dispositivo.

  • Scope: Any file
  • Type: Boolean
    • true: Claude Code rifiuta claude remote-control, il flag --remote-control, l'avvio automatico e l'interruttore in-sessione
    • false: il Controllo remoto rimane disponibile
  • Default: false
{
  "disableRemoteControl": true
}

`enableArtifact`

Disattiva lo strumento Artifact, che pubblica l'output della sessione come pagina web privata su claude.ai. Quando disattivi la riga Artifacts in /config, Claude Code scrive questa chiave nelle tue impostazioni utente, quindi di solito non la modifichi manualmente. Richiede Claude Code v2.1.196 o successivo.

  • Scope: Any file. Ogni file può disattivare lo strumento e nessuno può riattivarlo.
  • Type: Boolean
    • false: Claude Code disattiva lo strumento Artifact per ogni sessione a cui il file si applica
    • true: lo stesso di lasciare la chiave non impostata, perché non sovrascrive mai un false da un altro file, da CLAUDE_CODE_DISABLE_ARTIFACT o dall'impostazione amministratore della tua organizzazione
  • Default: non impostato, quindi lo strumento segue la disponibilità del tuo account
{
  "enableArtifact": false
}

Mentre un'origine diversa dalle tue impostazioni utente mantiene lo strumento disattivato, Claude Code nasconde la riga Artifacts in /config, perché attivarlo lì non cambierebbe nulla. Disabilita artefatti elenca ogni modo per disattivare lo strumento. Prima della v2.1.242, Claude Code ignorava questa chiave nelle impostazioni di progetto e locali e un file più alto nello stack di precedenza potrebbe riattivare lo strumento su un file inferiore spento.

`inputNeededNotifEnabled`

Ricevi una notifica push sul tuo telefono quando un prompt di autorizzazione o una domanda è in attesa del tuo input. Claude Code invia questi solo mentre il Controllo remoto è connesso. Appare in /config come Push quando azioni richieste.

  • Scope: Any file. Claude Code legge anche un valore lasciato in ~/.claude.json da versioni precedenti.
  • Type: Boolean
    • true: ricevi una notifica push sul tuo telefono quando un prompt di autorizzazione o una domanda è in attesa, mentre il Controllo remoto è connesso
    • false: Claude Code non invia tali notifiche
  • Default: false
{
  "inputNeededNotifEnabled": true
}

Vedi Notifiche push mobile.

`preferredNotifChannel`

Scegli come Claude Code ti notifica quando un'attività si completa o un prompt di autorizzazione è in attesa. Appare in /config come Local notifications.

  • Scope: Any file. Claude Code legge anche un valore lasciato in ~/.claude.json da versioni precedenti.
  • Type: stringa, una di:
    • "auto": Claude Code invia una notifica desktop in iTerm2, Ghostty e Kitty, suona il campanello in Terminal.app solo quando il suo campanello udibile è disattivato e non fa nulla altrove
    • "terminal_bell": Claude Code suona il carattere campanello in qualsiasi terminale
    • "iterm2": Claude Code invia una notifica desktop iTerm2
    • "iterm2_with_bell": Claude Code invia una notifica desktop iTerm2 e suona il campanello
    • "kitty": Claude Code invia una notifica desktop Kitty
    • "ghostty": Claude Code invia una notifica desktop Ghostty
    • "notifications_disabled": Claude Code non invia alcuna notifica
  • Default: "auto"
{
  "preferredNotifChannel": "terminal_bell"
}

Con "auto", Claude Code invia una notifica desktop in iTerm2, Ghostty e Kitty. In Terminal.app suona il carattere campanello solo quando hai disattivato il campanello udibile di Terminal e in altri terminali non fa nulla. Imposta "terminal_bell" per suonare il carattere campanello in qualsiasi terminale. Vedi Ottieni un campanello terminale o una notifica.

`remote.defaultEnvironmentId`

Scegli l'ambiente cloud predefinito per le sessioni cloud che crei dalla CLI, come con claude --cloud. Claude Code scrive questa chiave nelle tue impostazioni utente quando scegli un ambiente con /remote-env.

  • Scope: Any file. Per un ID ambiente self-hosted, impostazioni utente o gestite o il flag --settings solo.
  • Type: stringa, un ID ambiente come env_... o ccpool_...
  • Default: non impostato, quindi Claude Code utilizza l'ambiente ospitato da Anthropic quando il tuo elenco ne ha uno e altrimenti il primo ambiente nel tuo elenco che non è un'ambiente ponte Controllo remoto, o il primo ambiente quando tutti sono ambienti ponte
  • Per-session overrides: --environment ha la precedenza su questa chiave per la sessione cloud che crea
{
  "remote": {
    "defaultEnvironmentId": "env_0123abcd"
  }
}

Un ID ambiente ospitato da Anthropic, che inizia con env_, segue la precedenza delle impostazioni standard, quindi un valore nelle impostazioni di progetto di un repository sovrascrive la tua scelta a livello utente. Un ID ambiente self-hosted, che inizia con ccpool_, è onorato solo dalle impostazioni utente, impostazioni gestite e il flag --settings; Claude Code ignora uno nelle impostazioni di progetto o locali di un repository e /remote-env mostra quale valore ha ignorato, quindi un file archiviato non può indirizzare le sessioni su un ambiente self-hosted che non hai scelto.

`remoteControlAtStartup`

Connetti il Controllo remoto automaticamente quando ogni sessione interattiva inizia, invece di aspettare /remote-control. Impostalo su true per attivare la connessione automatica, false per disattivarla. Appare in /config come Abilita Controllo remoto per tutte le sessioni.

  • Scope: Any file. Claude Code legge anche un valore lasciato in ~/.claude.json da versioni precedenti.
  • Type: Boolean
    • true: Claude Code connette il Controllo remoto automaticamente quando ogni sessione interattiva inizia
    • false: Claude Code aspetta /remote-control
  • Default: non impostato, quindi la connessione automatica segue il default amministratore della tua organizzazione quando ne è impostato uno e altrimenti il default attuale di Claude Code
  • Per-session overrides: --remote-control attiva il Controllo remoto per una sessione anche quando questa chiave è false e nessun flag lo disattiva per una sessione
{
  "remoteControlAtStartup": true
}

Claude Code ignora un true dalle impostazioni di progetto o locali, quindi un repository può disattivare la connessione automatica per il suo checkout ma non può attivarla. Per il comportamento completo per scope, vedi Abilita Controllo remoto per tutte le sessioni e le chiavi di sicurezza in cui il valore più rigoroso si applica.

`sshConfigs`

Aggiungi connessioni SSH al menu a discesa dell'ambiente Desktop. Gli amministratori lo usano per distribuire connessioni condivise a un team. Le connessioni che definisci nelle impostazioni gestite vengono mostrate come gestite, quindi gli utenti possono selezionarle ma non possono modificarle o eliminarle nell'app.

  • Scope: User or managed. L'app desktop legge questa chiave.
  • Type: array di oggetti, ognuno con id, name e sshHost obbligatori e sshPort e sshIdentityFile opzionali
  • Default: non impostato

Questo esempio aggiunge una connessione denominata Dev VM che si connette a user@dev.example.com:

{
  "sshConfigs": [
    {
      "id": "dev-vm",
      "name": "Dev VM",
      "sshHost": "user@dev.example.com"
    }
  ]
}

`sshHostAllowlist`

Limita gli host a cui una sessione SSH Desktop può connettersi. Solo l'app Desktop legge questa chiave; il CLI non lo fa. I pattern sono case-insensitive: * corrisponde a qualsiasi host, *.example.com corrisponde a example.com e a ogni sottodominio e qualsiasi altra cosa è una corrispondenza esatta rispetto al nome host dopo la risoluzione di ~/.ssh/config. Un array vuoto disattiva le sessioni SSH.

  • Scope: Managed
  • Type: array di pattern di nome host
  • Default: non impostato, quindi qualsiasi host è consentito

Questo esempio consente devboxes.example.com e i suoi sottodomini, più l'host esatto bastion.example.com:

{
  "sshHostAllowlist": ["*.devboxes.example.com", "bastion.example.com"]
}

Autenticazione e provider

Fornisci credenziali tramite script helper e, per le organizzazioni, forza un metodo di accesso o un'organizzazione. Vedi Autenticazione.

`apiKeyHelper`

Esegui il tuo comando per produrre le credenziali che Claude Code invia con le richieste del modello. Claude Code esegue il comando attraverso la shell di sistema, /bin/sh su macOS e Linux e cmd su Windows, e invia il suo output come intestazioni sia X-Api-Key che Authorization: Bearer. Usalo per credenziali dinamiche o rotanti, come token di breve durata recuperati da un vault.

  • Scope: Any file
  • Type: string, una riga di comando shell
  • Default: non impostato, quindi Claude Code non esegue un helper
{
  "apiKeyHelper": "/bin/generate_temp_api_key.sh"
}

Claude Code memorizza nella cache il valore e riesegue il comando in questi casi:

  • Dopo la durata della cache, cinque minuti per impostazione predefinita o l'intervallo che imposti con CLAUDE_CODE_API_KEY_HELPER_TTL_MS.
  • Quando una richiesta all'API Anthropic, direttamente o tramite un gateway LLM, fallisce con 401 o 403.
  • Prima di inviare una richiesta all'API Anthropic, direttamente o tramite un gateway LLM, quando l'output memorizzato nella cache è un JWT scaduto dopo che l'helper lo ha prodotto. Richiede Claude Code v2.1.246 o successivo.

Gli ultimi due casi si applicano solo quando l'output dell'helper è la credenziale che Claude Code invia e ANTHROPIC_AUTH_TOKEN non è impostato.

Nelle sessioni interattive, quando il comando proviene dalle impostazioni del progetto o locali, Claude Code non lo esegue finché non accetti il prompt di fiducia dell'area di lavoro. Vedi Gestione delle credenziali.

`awsAuthRefresh`

Esegui il tuo comando, come aws sso login, per aggiornare le credenziali nella tua directory .aws quando quelle che Claude Code ha per Amazon Bedrock smettono di funzionare. Claude Code controlla prima le credenziali attuali rispetto a STS ed esegue il comando solo quando quel controllo fallisce, quindi legge la directory .aws aggiornata.

  • Scope: Any file
  • Type: string, una riga di comando shell
  • Default: non impostato, quindi Claude Code non aggiorna le credenziali AWS per te
{
  "awsAuthRefresh": "aws sso login --profile myprofile"
}

Usa questa chiave quando il tuo flusso di aggiornamento scrive in .aws; usa awsCredentialExport quando stampa credenziali invece. Vedi configurazione avanzata delle credenziali.

`awsCredentialExport`

Esegui il tuo comando che stampa le credenziali AWS come JSON, in modo che Claude Code possa chiamare Amazon Bedrock con credenziali che non vivono nella tua directory .aws. Claude Code accetta la forma di output aws sts e la forma piatta aws configure export-credentials, e limita le credenziali al suo client Bedrock, quindi i comandi shell che Claude esegue vedono ancora le tue credenziali ambientali.

  • Scope: Any file
  • Type: string, una riga di comando shell
  • Default: non impostato, quindi Claude Code utilizza la catena di credenziali AWS ambientale
{
  "awsCredentialExport": "/bin/generate_aws_grant.sh"
}

A differenza di awsAuthRefresh, Claude Code esegue sempre questo comando quando è impostato, senza controllare prima le credenziali ambientali. Vedi configurazione avanzata delle credenziali.

`forceLoginMethod`

Limita il tipo di account con cui le persone possono accedere. Imposta "claudeai" per consentire solo account claude.ai, "console" per consentire solo account Claude Console, o "gateway" per inviare le persone a un cloud gateway invece di un accesso di prima parte. Gli amministratori lo impostano nelle impostazioni gestite e lo associano a forceLoginOrgUUID per mantenere gli accessi claude.ai degli sviluppatori all'interno di un'organizzazione. Se lo imposti su "claudeai" o "console" in qualsiasi file di impostazioni, Claude Code smette anche di offrire l'accesso Console senza chiave nelle sessioni a cui si applica quel file.

  • Scope: Any file. Claude Code onora "gateway" solo da una fonte gestita sulla macchina: managed-settings.json, il plist macOS o il registro HKLM di Windows, o un helper di policy. Lo tratta come non impostato nelle impostazioni utente, progetto, locali, HKCU e gestite dal server, la stessa regola di forceLoginGatewayUrl.
  • Type: string, uno di:
    • "claudeai": solo gli account claude.ai possono accedere
    • "console": solo gli account Claude Console possono accedere
    • "gateway": Claude Code invia le persone a un cloud gateway invece di un accesso di prima parte
  • Default: non impostato, quindi le persone scelgono un metodo di accesso
{
  "forceLoginMethod": "claudeai"
}

Ogni percorso di accesso di prima parte applica la restrizione, inclusa l'estensione VS Code, l'Agent SDK, claude setup-token, e /install-github-app, ad eccezione della schermata di accesso interattiva del terminale, raggiunta da /login o dall'onboarding al primo avvio, che pre-seleziona il metodo senza applicarlo. Prima della v2.1.212, solo gli accessi al terminale lo applicavano. Vedi Limita l'accesso alla tua organizzazione per come ogni percorso di accesso, le credenziali ambientali e i provider di terze parti vengono gestiti.

Quando una fonte gestita sulla macchina imposta "gateway", Claude Code non utilizza un accesso residuo, una chiave API o una credenziale apiKeyHelper. Vedi La policy dell'amministratore richiede un accesso Cloud gateway per il messaggio che ognuno produce. Se selezioni un provider cloud tramite CLAUDE_CODE_USE_BEDROCK o una variabile di ambiente simile, la sessione non ha bisogno dell'accesso al gateway. Prima della v2.1.261, Claude Code utilizzava un accesso residuo su queste macchine.

`forceLoginGatewayUrl`

Imposta l'URL del gateway a cui si connette la schermata /login Cloud gateway, in modo che le persone raggiungano il tuo cloud gateway senza digitare il suo indirizzo. La schermata non ha un campo URL: con questa chiave impostata, mostra l'URL del tuo gateway e si connette quando la persona preme Invio; senza di essa, dice loro di contattare il loro amministratore IT.

O questa chiave o forceLoginMethod: "gateway" rende la macchina solo gateway, quindi /login si apre sulla schermata Cloud gateway senza un selettore di metodo di accesso. Vedi La policy dell'amministratore richiede un accesso Cloud gateway per cosa succede a un accesso di prima parte residuo o a una chiave API. Imposta entrambe le chiavi in modo che la schermata si connetta invece di mostrare un errore.

  • Scope: Managed. Leggi solo da una fonte sulla macchina: managed-settings.json, il plist macOS o il registro HKLM di Windows, o un helper di policy. Claude Code lo ignora nelle impostazioni HKCU e gestite dal server.
  • Type: string, un URL completo incluso lo schema
  • Default: non impostato, quindi la schermata Cloud gateway mostra un errore che dice alle persone di contattare il loro amministratore IT
{
  "forceLoginGatewayUrl": "https://claude-gateway.example.com"
}

Se il valore non è un URL valido, la schermata di accesso lo segnala e il resto del file di impostazioni gestite si applica comunque. Vedi Imposta l'URL del gateway.

`forceLoginOrgUUID`

Da una fonte gestita, richiedi che gli accessi dell'account claude.ai appartengano a un'organizzazione Anthropic, data come un singolo UUID, o a una qualsiasi di diverse organizzazioni, data come un array. Da qualsiasi file di impostazioni, Claude Code utilizza anche un singolo UUID per pre-selezionare quell'organizzazione durante un accesso claude.ai o Claude Console, e non pre-seleziona nulla per un array. Se imposti la chiave in qualsiasi file di impostazioni, Claude Code smette anche di offrire l'accesso Console senza chiave nelle sessioni a cui si applica quel file e crea una chiave API invece.

  • Scope: Any file. Solo una fonte gestita applica la restrizione; un singolo UUID in qualsiasi altro file di impostazioni pre-seleziona l'organizzazione durante l'accesso senza limitarla.
  • Type: string, un UUID, o array di stringhe, diversi UUID
  • Default: non impostato, quindi qualsiasi organizzazione può accedere

Questo esempio accetta accessi da una qualsiasi di due organizzazioni senza pre-selezionarne una:

{
  "forceLoginOrgUUID": ["xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx", "yyyyyyyy-yyyy-yyyy-yyyy-yyyyyyyyyyyy"]
}

Se una fonte gestita imposta un array vuoto, o un valore che Claude Code non può analizzare, Claude Code blocca ogni accesso con un messaggio di configurazione errata.

Vedi Limita l'accesso alla tua organizzazione per come Claude Code tratta gli accessi Claude Console, gli altri percorsi di accesso e le credenziali ambientali.

`gcpAuthRefresh`

Esegui il tuo comando per aggiornare le credenziali predefinite dell'applicazione Google Cloud quando Claude Code scopre che sono scadute o non possono essere caricate, in modo che le richieste di Google Cloud's Agent Platform continuino a funzionare senza che tu ti autentica di nuovo manualmente.

  • Scope: Any file
  • Type: string, una riga di comando shell
  • Default: non impostato, quindi l'errore di credenziale di Claude Code ti dice di eseguire gcloud auth application-default login tu stesso
{
  "gcpAuthRefresh": "gcloud auth application-default login"
}

Vedi configurazione avanzata delle credenziali.

`otelHeadersHelper`

Esegui il tuo comando per generare le intestazioni che Claude Code invia con le esportazioni OpenTelemetry, per backend i cui token ruotano. Claude Code lo esegue all'avvio e periodicamente dopo, e si aspetta un oggetto JSON di valori di intestazione stringa su stdout.

  • Scope: Any file
  • Type: string, un percorso eseguibile o una riga di comando shell
  • Default: non impostato, quindi Claude Code non aggiunge intestazioni generate da helper
{
  "otelHeadersHelper": "/bin/generate_otel_headers.sh"
}

Imposta l'intervallo di aggiornamento con CLAUDE_CODE_OTEL_HEADERS_HELPER_DEBOUNCE_MS. Vedi Dynamic headers per i requisiti dello script e dove Claude Code segnala un helper che fallisce.

Aggiornamenti e versioning

Scegli un canale di aggiornamento e, per le organizzazioni, fissa le versioni che le persone possono eseguire. Vedi Aggiorna Claude Code.

`autoUpdatesChannel`

Scegli quale canale di rilascio seguono gli aggiornamenti automatici in background e claude update. Imposta "stable" per una versione che è tipicamente di circa una settimana fa e salta i rilasci con regressioni importanti, oppure "latest" per il rilascio più recente.

  • Scope: Any file. Impostalo nelle impostazioni gestite per applicare un canale in tutta l'organizzazione.
  • Type: string, uno di:
    • "latest": gli aggiornamenti seguono il rilascio più recente
    • "stable": gli aggiornamenti seguono una versione che è tipicamente di circa una settimana fa e salta i rilasci con regressioni importanti
  • Default: non impostato, quindi Claude Code segue "latest"
{
  "autoUpdatesChannel": "stable"
}

Claude Code scrive "stable" nelle tue impostazioni utente quando lo scegli in Auto-update channel in /config, e rimuove la chiave quando torni a latest lì. claude install stable e claude install latest salvano anche il canale che nomini. Passare da "latest" a "stable" in /config chiede se consentire un downgrade o rimanere sulla versione corrente; rimanere imposta minimumVersion. Gli install di Homebrew ignorano questa chiave: il cask claude-code traccia stable e claude-code@latest traccia latest, e claude update si rimette a brew upgrade. Per disattivare completamente gli aggiornamenti automatici, imposta DISABLE_AUTOUPDATER in env.

`minimumVersion`

Impedisci agli aggiornamenti automatici in background e a claude update di installare qualsiasi versione al di sotto di questa, quindi il passaggio al canale "stable" non ti fa eseguire il downgrade da una build "latest" più recente. Claude Code scrive questa chiave per te quando scegli di rimanere sulla versione corrente mentre cambi canale in /config, e la cancella quando torni a "latest".

  • Scope: Any file. Impostalo nelle impostazioni gestite per fissare un minimo a livello di organizzazione che le impostazioni utente e di progetto non possono abbassare.
  • Type: string, un numero di versione come "2.1.100"
  • Default: non impostato, quindi gli aggiornamenti possono installare qualsiasi versione che il canale offre

Questo esempio segue il canale stable e rifiuta di installare qualsiasi versione al di sotto di 2.1.100:

{
  "autoUpdatesChannel": "stable",
  "minimumVersion": "2.1.100"
}

Questa chiave vincola solo gli aggiornamenti. Per fare in modo che Claude Code rifiuti di avviarsi al di sotto di una versione, usa requiredMinimumVersion invece. Vedi Fissa una versione minima.

`requiredMaximumVersion`

Imposta la versione più recente di Claude Code che la tua organizzazione consente di avviare. Quando la versione in esecuzione è più recente, Claude Code esce all'avvio e dice all'utente di installare una versione approvata attraverso il metodo approvato della tua organizzazione; claude install <version> potrebbe funzionare anche. Richiede Claude Code v2.1.163 o successivo.

  • Scope: Managed. Claude Code non dà alcun avviso quando ignora la chiave altrove.
  • Type: string, un numero di versione come "2.1.150"; un valore che non è una versione valida viene ignorato
  • Default: non impostato, quindi non si applica alcun limite massimo
{
  "requiredMaximumVersion": "2.1.150"
}

Gli aggiornamenti automatici in background e claude update saltano le versioni al di sopra del limite, quindi un'installazione all'interno dell'intervallo rimane all'interno di esso. claude update, claude install, e claude doctor continuano a funzionare al di sopra del limite in modo che gli utenti possano recuperare. Abbinalo a requiredMinimumVersion per applicare un intervallo.

`requiredMinimumVersion`

Imposta la versione più vecchia di Claude Code che la tua organizzazione consente di avviare. Quando la versione in esecuzione è più vecchia, Claude Code esce all'avvio e dice all'utente di aggiornare attraverso il metodo approvato della tua organizzazione. Il controllo viene eseguito solo all'avvio, quindi una sessione già in esecuzione continua. Richiede Claude Code v2.1.163 o successivo.

  • Scope: Managed. Claude Code non dà alcun avviso quando ignora la chiave altrove.
  • Type: string, un numero di versione come "2.1.150"; un valore che non è una versione valida viene ignorato
  • Default: non impostato, quindi non si applica alcun limite minimo
{
  "requiredMinimumVersion": "2.1.150"
}

claude update, claude install, e claude doctor continuano a funzionare al di sotto del limite in modo che gli utenti possano recuperare. A differenza di minimumVersion, che previene solo i downgrade, questa chiave blocca l'avvio. Abbinalo a requiredMaximumVersion per applicare un intervallo.

Tools

Disabilita strumenti specifici nell'app desktop Claude. La CLI del terminale ignora queste chiavi. Per gli strumenti stessi, vedi Strumenti disponibili per Claude.

`browserExternalPageTools`

Impedisci a Claude di utilizzare i suoi strumenti per leggere o agire su pagine esterne nel riquadro Browser dell'app desktop. Le persone nella tua organizzazione possono comunque aprire siti esterni da sole, e le anteprime dei server di sviluppo locali continuano a funzionare con gli strumenti di Claude. L'app desktop legge questa chiave; la CLI del terminale la ignora.

  • Scope: Managed
  • Type: stringa, "disabled"; l'app desktop accetta anche "disable", in entrambi i casi
  • Default: non impostato, quindi gli strumenti di Claude funzionano su pagine esterne
{
  "browserExternalPageTools": "disabled"
}

Qualsiasi altro valore lascia gli strumenti di Claude attivi, e una stringa non vuota che non sia uno dei due valori accettati registra un avviso. Per bloccare i siti esterni sia per le persone che per Claude, imposta invece disableBrowserExternalNavigation. Vedi Limitare la navigazione esterna per la tua organizzazione.

`disableBrowserExternalNavigation`

Disabilita la navigazione esterna nel riquadro Browser dell'app desktop sia per le persone che per Claude. Le anteprime dei server di sviluppo localhost continuano a funzionare. L'app desktop legge questa chiave; la CLI del terminale la ignora.

  • Scope: Managed
  • Type: Booleano; solo il Booleano JSON true ha effetto
    • true: l'app desktop disabilita la navigazione esterna nel riquadro Browser sia per le persone che per Claude; le anteprime localhost continuano a funzionare
    • false: la navigazione esterna rimane attiva
  • Default: non impostato, quindi la navigazione esterna è attiva
{
  "disableBrowserExternalNavigation": true
}

L'app desktop ignora qualsiasi altro valore, e un valore che non sia un Booleano, come la stringa "true" o 1, registra anche un avviso. Per lasciare la navigazione esterna attiva ma mantenere gli strumenti di Claude disabilitati su pagine esterne, imposta invece browserExternalPageTools. Vedi Limitare la navigazione esterna per la tua organizzazione.

`disableMobileSimulatorTools`

Blocca gli strumenti di Claude per il riquadro iOS Simulator dell'app desktop. Le persone mantengono l'uso manuale del riquadro; solo l'accesso di Claude viene rimosso, e nessuno può riattivarlo dall'interno dell'app. L'app desktop legge questa chiave; la CLI del terminale la ignora.

  • Scope: Managed
  • Type: Booleano; solo il Booleano JSON true ha effetto
    • true: l'app desktop blocca gli strumenti di Claude per il riquadro iOS Simulator
    • false: gli strumenti del simulatore di Claude seguono l'interruttore delle impostazioni di ogni persona nell'app desktop
  • Default: non impostato, quindi gli strumenti del simulatore di Claude seguono l'interruttore delle impostazioni di ogni persona nell'app desktop
{
  "disableMobileSimulatorTools": true
}

L'app desktop ignora qualsiasi altro valore, e un valore che non sia un Booleano, come la stringa "true" o 1, registra anche un avviso.

Privacy e telemetria

Controlla per quanto tempo Claude Code mantiene i dati della sessione e cosa invia. Gli interruttori che disattivano le metriche di utilizzo e i rapporti di errore sono variabili di ambiente, non chiavi di impostazione: imposta DISABLE_TELEMETRY, DISABLE_ERROR_REPORTING, o CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC nella chiave env o nella shell. Telemetry services dice cosa disattiva ognuno. Due eccezioni si disattivano da un file di impostazioni: feedbackDrafts di seguito per il feedback redatto da Claude, e feedbackSurveyRate di seguito per il sondaggio della sessione.

`cleanupPeriodDays`

Imposta quanti giorni Claude Code mantiene i trascritti della sessione e altri dati dell'applicazione prima di eliminarli. Claude Code esegue l'eliminazione come una scansione di background dopo l'avvio di una sessione, purché possa determinare in modo sicuro il periodo di conservazione.

  • Scope: Any file
  • Type: numero di giorni, un numero intero, minimo 1
  • Default: 30
{
  "cleanupPeriodDays": 20
}

L'impostazione di 0 non supera la convalida, quindi scegli un valore grande come 3650 per una conservazione a lungo termine. Per impedire a Claude Code di scrivere trascritti, vedi Plaintext storage.

`desktopSessionCleanupPeriodDays`

Imposta un limite di età in giorni per i trascritti delle sessioni che hai avviato o continuato più di recente in Claude Desktop o Cowork. Senza questa chiave, Claude Code mantiene quei trascritti a qualsiasi età. Claude Code elimina ognuno una volta che è più vecchio sia di questo limite che di cleanupPeriodDays, quindi con cleanupPeriodDays al suo valore predefinito di 30, un valore di 7 li mantiene comunque 30 giorni. Quando le impostazioni gestite impostano cleanupPeriodDays, quel periodo si applica invece e questa chiave viene ignorata. Richiede Claude Code v2.1.248 o successivo.

  • Scope: User or managed. Claude Code legge anche la chiave da un file che passi con --settings, e la ignora nelle impostazioni di progetto e locali.
  • Type: numero di giorni, un numero intero, minimo 0
  • Default: 0, che non imposta alcun limite di età
{
  "desktopSessionCleanupPeriodDays": 90
}

`feedbackDrafts`

Controlla il feedback redatto da Claude: se Claude può mettere in coda le bozze di feedback per la tua revisione, e se Claude Code mostra una scheda quando Claude ne mette in coda una.

  • Scope: User or managed
  • Type: stringa, uno di "notify", "quiet", o "off"
    • "notify": Claude Code mostra una scheda sopra il prompt quando Claude mette in coda una bozza, fino a tre schede in una sessione per impostazione predefinita
    • "quiet": Claude redige senza una scheda. Vedi il conteggio delle bozze in coda nel footer del prompt e le rivedi in /feedback
    • "off": Claude Code rimuove lo strumento SendFeedback, quindi Claude non può mettere in coda le bozze
  • Default: "notify"
  • Per-session overrides: CLAUDE_CODE_SEND_FEEDBACK impostato a 0 disattiva la funzione per una sessione
{
  "feedbackDrafts": "quiet"
}

Appare in /config come Claude-drafted feedback, che scrive questa chiave nelle tue impostazioni utente. Vedi la riga /config solo nelle sessioni dove Claude può redigere feedback; l'impostazione di "off" non la nasconde, quindi puoi riattivare la funzione dalla stessa riga. Un valore nelle impostazioni gestite ha la precedenza sulla tua impostazione utente, quindi quando un amministratore imposta questa chiave, la riga mostra il valore gestito e modificarlo non ha effetto. Claude Code ignora questa chiave nelle impostazioni di progetto e locali.

`feedbackSurveyRate`

Imposta la probabilità che il sondaggio sulla qualità della sessione appaia quando una sessione è idonea per esso. Imposta 0 per impedire che il sondaggio appaia.

  • Scope: Any file
  • Type: numero tra 0 e 1
  • Default: non impostato, quindi Claude Code utilizza la velocità che Anthropic imposta da remoto, o la sua velocità incorporata di 0.005 su Amazon Bedrock, Google Cloud's Agent Platform, e Microsoft Foundry, che non ricevono configurazione remota
  • Per-session overrides: CLAUDE_CODE_DISABLE_FEEDBACK_SURVEY impostato a 1 disattiva il sondaggio per una sessione qualunque sia la velocità che questa chiave imposta
{
  "feedbackSurveyRate": 0.05
}

La stessa velocità si applica al sondaggio nell'estensione VS Code.

`skipWebFetchPreflight`

Salta il controllo di sicurezza del dominio WebFetch, che invia ogni nome host richiesto a api.anthropic.com prima di recuperare. Imposta true negli ambienti che bloccano il traffico verso Anthropic, come Amazon Bedrock, Google Cloud's Agent Platform, o distribuzioni Microsoft Foundry con egress restrittivo.

  • Scope: Any file
  • Type: Boolean
    • true: Claude Code salta il controllo di sicurezza del dominio WebFetch
    • false: il controllo viene eseguito prima del primo recupero per ogni nome host in una sessione, e di nuovo per un nome host il cui controllo precedente è stato bloccato o non riuscito
  • Default: non impostato, quindi il controllo viene eseguito prima del primo recupero per ogni nome host in una sessione
{
  "skipWebFetchPreflight": true
}

Con il controllo saltato, WebFetch tenta qualsiasi URL senza consultare la lista di blocco, quindi abbinalo alle regole di autorizzazione WebFetch se hai bisogno di limitare quali domini Claude può raggiungere.

Impostazioni aziendali e gestite

Chiavi che un'organizzazione utilizza per calcolare, aggiornare e combinare le impostazioni gestite. Vedere Configurare le impostazioni gestite.

`disableSideloadFlags`

Rifiuta i flag CLI --plugin-dir, --plugin-url, --agents e --mcp-config all'avvio, che gli utenti potrebbero altrimenti passare per aggirare strictKnownMarketplaces per una singola esecuzione. Claude Code esce con un errore che nomina i flag rifiutati e applica lo stesso controllo alle superfici che avviano la CLI con questi flag internamente, attualmente le sessioni locali di Cowork nell'app desktop. Nelle sessioni cloud, Claude Code elimina i server MCP che il server ha fornito tramite --mcp-config, ad eccezione delle voci in-process type: "sdk", e avvia la sessione. Richiede Claude Code v2.1.193 o successivo.

  • Scope: Managed
  • Type: Boolean
    • true: Claude Code rifiuta --plugin-dir, --plugin-url, --agents e --mcp-config all'avvio e esce con un errore che li nomina, tranne che nelle sessioni cloud dove elimina i server MCP che il server ha fornito tramite --mcp-config, ad eccezione delle voci in-process type: "sdk", e avvia la sessione
    • false: Claude Code accetta questi flag
  • Default: false
{
  "disableSideloadFlags": true
}

Claude Code accetta comunque un --mcp-config i cui server sono tutti voci in-process type: "sdk", quindi l'Agent SDK e l'estensione VS Code continuano a funzionare. Gli utenti possono comunque aggiungere server con claude mcp add o un file .mcp.json; per il controllo per server, impostare anche allowedMcpServers. Richiede Claude Code v2.1.193 o successivo.

Nelle sessioni cloud, Claude Code ignora anche gli aggiornamenti MCP forniti dal server a metà sessione, il percorso dietro la configurazione della sessione cloud e SDK setMcpServers() sui worker remoti. Le voci in-process type: "sdk" rimangono esenti anche lì. Prima della v2.1.239, un --mcp-config fornito dal server bloccava l'avvio di una sessione cloud.

`forceRemoteSettingsRefresh`

Blocca l'avvio della CLI fino a quando Claude Code non ha recuperato di recente le impostazioni gestite dal server. Se il recupero non riesce, Claude Code esce invece di continuare con le impostazioni memorizzate nella cache o nessuna impostazione. Impostarlo quando il tuo ambiente non può accettare nemmeno una breve finestra in cui una sessione viene eseguita senza la sua politica gestita.

Quando la chiave non è impostata, Claude Code non blocca l'avvio sul recupero, anche se quando lo sviluppatore accede all'avvio attende fino a cinque secondi per il recupero. Una sessione del gateway Cloud attende sempre e esce se il gateway non può essere raggiunto.

  • Scope: Managed. Claude Code onora un true da qualsiasi fonte gestita controllata dall'amministratore, anche una che non è la fonte con la priorità più alta.
  • Type: Boolean
    • true: Claude Code blocca l'avvio fino a quando non ha recuperato di recente le impostazioni gestite dal server e esce se il recupero non riesce
    • false: Claude Code non blocca l'avvio sul recupero, anche se all'avvio di un accesso attende fino a cinque secondi per il recupero
  • Default: false
{
  "forceRemoteSettingsRefresh": true
}

Impostarlo in un profilo MDM o nel file delle impostazioni gestite per applicare l'avvio fail-closed prima che arrivi il primo payload del server. Claude Code applica il controllo solo nelle sessioni che recuperano le impostazioni gestite dal server, quindi una sessione che non le recupera si avvia senza attendere. I sottocomandi claude auth sono esenti, quindi gli utenti possono autenticarsi di nuovo quando le credenziali scadute sono il motivo per cui il recupero non riesce. Vedere Applicare l'avvio fail-closed.

`managedSourcesBehavior`

Scegli se Claude Code applica solo la fonte gestita con la priorità più alta che la tua organizzazione fornisce, o combina ogni fonte amministrativa che fornisce. Per impostazione predefinita, Claude Code prende la fonte con la priorità più alta che contiene una chiave di politica e ignora il resto. Una chiave di politica è qualsiasi chiave di impostazioni diversa da questa e da wslInheritsWindowsSettings. Quindi una volta che le impostazioni gestite dal server o una politica MDM forniscono una chiave di politica, un file managed-settings.json contribuisce solo alle chiavi che Claude Code legge da ogni fonte amministrativa. Con "merge", ogni fonte amministrativa che fornisci contribuisce con le sue chiavi a una politica combinata. Richiede Claude Code v2.1.242 o successivo.

Imposta "merge" solo dove ogni fonte classificata al di sotto della tua più alta è sotto il controllo di un amministratore, perché Claude Code quindi aggiunge voci da una fonte inferiore, come le regole permissions.allow, alla politica.

  • Scope: Managed. Claude Code legge questa chiave dalla fonte con la priorità più alta che contiene questa chiave o una chiave di politica, e ignora questa chiave in ogni fonte classificata più in basso, quindi una fonte inferiore non può optare per la combinazione con la fonte sopra di essa. Né il registro HKCU di Windows né le impostazioni padre da un host di incorporamento partecipano alla fusione.
  • Type: string, uno di:
    • "first-wins": la fonte con la priorità più alta che contiene una chiave di politica fornisce la politica, e le fonti inferiori contribuiscono solo alle chiavi che Claude Code legge da ogni fonte amministrativa
    • "merge": ogni fonte amministrativa che fornisci contribuisce con le sue chiavi, combinate secondo le regole sottostanti
  • Default: "first-wins"

Fornisci la chiave nella fonte con la priorità più alta che distribuisci. Una macchina che non riceve mai le impostazioni gestite dal server ha bisogno della chiave anche nel suo profilo MDM, perché Claude Code legge la chiave dalla fonte con la priorità più alta che la contiene o una chiave di politica. Un file managed-settings.json è la fonte amministrativa con la priorità più bassa, quindi "merge" impostato lì non ha alcuna fonte al di sotto di essa con cui combinarsi. Nelle impostazioni gestite dal server, la chiave appare così:

{
  "managedSourcesBehavior": "merge"
}

Sotto "merge", Claude Code combina ogni chiave per il suo tipo. Questa tabella fornisce la regola per ogni tipo. Le righe della lista di restrizioni, valori-presi-interi e solo-fonte-più-alta nominano ogni chiave che coprono, e le altre righe forniscono esempi:

Tipo di chiave Come Claude Code la combina Chiavi
Liste Combina voci da ogni fonte permissions.allow, sandbox.network.allowedDomains e altre chiavi di lista
Blocchi Applica il valore più rigoroso che qualsiasi fonte imposta. Quando nessuna fonte imposta un valore rigoroso, applica un valore più lasco solo dalla fonte con la priorità più alta allowManagedPermissionRulesOnly, permissions.disableBypassPermissionsMode e altri blocchi booleani o enum
Liste di restrizioni Prende la lista intera dalla fonte con la priorità più alta che la imposta, senza aggiungere voci da fonti inferiori. Quando la fonte con la priorità più alta non ne imposta una, la prende intera dalla fonte successiva availableModels, allowedMcpServers, strictKnownMarketplaces, allowedChannelPlugins e la catena fallbackModel
Valori presi interi Prende il valore intero dalla fonte con la priorità più alta che lo imposta, senza combinare voci o campi da fonti inferiori. Quando la fonte con la priorità più alta non lo imposta, lo prende intero dalla fonte successiva sandbox.credentials.awsPairs, sandbox.ripgrep
Server MCP forniti Combina i nomi dei server da ogni fonte. Quando due fonti impostano lo stesso nome, applica la voce intera della fonte più alta managedMcpServers
Leggi solo dalla fonte con la priorità più alta Legge la chiave solo dalla fonte con la priorità più alta che contiene una chiave di politica, quindi il valore di una fonte inferiore viene ignorato anche quando la fonte con la priorità più alta non ne imposta nessuno apiKeyHelper, awsAuthRefresh, awsCredentialExport, gcpAuthRefresh, otelHeadersHelper, proxyAuthHelper, forceLoginOrgUUID, forceLoginMethod, forceLoginGatewayUrl, parentSettingsBehavior, modelPicker, policyHelper, permissions.defaultMode
env Unisce per variabile tra fonti amministrative, sia sotto "first-wins" che "merge" env
Ogni altra chiave Prende il valore dalla fonte con la priorità più alta che lo imposta cleanupPeriodDays, model

Prendere sandbox.credentials.awsPairs e sandbox.ripgrep interi richiede Claude Code v2.1.257 o successivo.

Tre di queste chiavi aggiungono una condizione propria:

  • policyHelper: Claude Code lo onora solo quando la fonte con la priorità più alta che contiene una chiave di politica è una politica MDM o un file di impostazioni gestite, quindi sotto le impostazioni gestite dal server non si applica.
  • modelOverrides: si accoppia con availableModels. Claude Code prende modelOverrides dalla fonte con la priorità più alta che lo imposta, a meno che una fonte più alta non imposti availableModels senza modelOverrides. In quel caso ignora modelOverrides da ogni fonte.
  • forceLoginGatewayUrl e il valore "gateway" di forceLoginMethod: Claude Code li legge solo dalle fonti gestite sulla macchina stessa e li ignora nelle impostazioni gestite dal server. I valori della macchina si applicano anche quando le impostazioni gestite dal server sono presenti.

Per confermare quali fonti si sono combinate su una macchina, esegui /status e leggi la riga Setting sources.

`parentSettingsBehavior`

Scegli se Claude Code applica le impostazioni gestite fornite da un processo host di incorporamento, come l'Agent SDK o un'estensione IDE, quando è presente anche un livello gestito distribuito dall'amministratore. Con "first-wins", Claude Code elimina le impostazioni fornite dall'host; con "merge", le applica sotto il livello amministrativo attraverso un filtro solo restrittivo. Imposta "merge" quando un host ha bisogno di passare le sue stesse restrizioni alle sessioni che avvia, ad esempio Claude Desktop che fornisce la lista di egresso consentita di un gateway.

  • Scope: Managed. Claude Code lo legge dalla fonte gestita controllata dall'amministratore con la priorità più alta.
  • Type: string, uno di:
    • "first-wins": Claude Code elimina le impostazioni fornite dall'host quando è presente un livello gestito distribuito dall'amministratore
    • "merge": Claude Code applica le impostazioni fornite dall'host sotto il livello amministrativo attraverso un filtro solo restrittivo
  • Default: "first-wins"
{
  "parentSettingsBehavior": "merge"
}

Questa chiave non ha effetto quando non esiste un livello gestito distribuito dall'amministratore: le impostazioni dell'host si applicano quindi come l'unico livello gestito, ancora filtrate a valori restrittivi. Per i limiti del filtro e come le fonti gestite interagiscono, vedere Impostazioni padre da host di incorporamento e Limitare le impostazioni padre.

`policyHelper`

Esegui un eseguibile che distribuisci che calcola le impostazioni gestite all'avvio, in modo da poter derivare la politica dalla postura del dispositivo, dall'identità o da un servizio remoto invece di un file statico. Claude Code esegue l'helper prima di accettare il primo prompt e tratta le impostazioni che emette come le impostazioni gestite per la sessione.

  • Scope: Managed. Leggi dal plist macOS, dal registro Windows HKLM o dal file delle impostazioni gestite. Claude Code legge la chiave dalla fonte gestita con la priorità più alta che contiene una chiave di politica e esegue l'helper solo quando quella fonte è una di queste tre; ignora la chiave nelle impostazioni gestite dal server, nel registro HKCU e nelle impostazioni padre fornite dall'host.
  • Type: object con path, timeoutMs e refreshIntervalMs
  • Default: non impostato, quindi nessun helper viene eseguito

Quando le impostazioni gestite dal server forniscono la politica all'avvio, hanno la precedenza sulla fonte dell'helper e l'helper non viene eseguito.

Se un recupero di impostazioni successivo segnala che le impostazioni gestite dal server sono state rimosse, Claude Code esegue l'helper a quel punto piuttosto che attendere il prossimo avvio. Il suo output governa il resto della sessione e un'esecuzione che non riesce termina la sessione con lo stesso messaggio di un'esecuzione di avvio non riuscita.

Questo esempio esegue l'helper con un timeout di 5 secondi e lo riesegue ogni cinque minuti:

{
  "policyHelper": {
    "path": "/usr/local/bin/claude-policy",
    "timeoutMs": 5000,
    "refreshIntervalMs": 300000
  }
}

Scrivi l'output dell'helper

Claude Code esegue l'helper senza argomenti, imposta CLAUDE_CODE_VERSION nel suo ambiente e legge un envelope JSON da stdout, limitato a 1 MiB.

Metti le impostazioni sotto una chiave managedSettings. Un oggetto di impostazioni bare senza una chiave managedSettings analizza con managedSettings non definito e non applica nulla, e Claude Code non segnala alcun errore:

{
  "managedSettings": {
    "permissions": { "deny": ["Read(//etc/secrets/**)"] }
  }
}

Quando l'helper emette managedSettings, quell'oggetto diventa l'unica fonte di impostazioni gestite per l'esecuzione: Claude Code ignora le fonti MDM, file e HKCU, legge le chiavi tra fonti solo dall'output dell'helper e non unisce mai le impostazioni padre.

Il controllo forceRemoteSettingsRefresh all'avvio viene eseguito prima dell'helper e legge qualsiasi fonte amministrativa. Un helper che esce con 0 con un envelope che omette managedSettings non contribuisce con impostazioni gestite e le altre fonti si applicano come al solito.

Errori dell'helper

Un'esecuzione dell'helper non riesce quando:

  • path viola le regole in policyHelper.path.
  • Nessun file regolare è in path. Claude Code controlla il file prima di avviare l'helper, entro lo stesso budget timeoutMs, quindi un mount di rete non responsivo può causare il fallimento dell'esecuzione.
  • L'helper esce con un valore diverso da zero, è ancora in esecuzione quando timeoutMs trascorre, o non si avvia affatto, ad esempio perché non è eseguibile.
  • L'helper scrive più di 1 MiB su stdout o su stderr.
  • stdout non è un singolo oggetto JSON, o il suo managedSettings ha una violazione dello schema che Claude Code non può riparare.

Quando l'esecuzione all'avvio non riesce, Claude Code stampa il motivo e rifiuta di avviarsi. Dopo un'uscita con valore diverso da zero, il motivo include stderr dell'helper, o il suo stdout quando stderr è vuoto. Dopo un timeout, il motivo nomina il limite timeoutMs e non include nessuno dell'output dell'helper. Il rifiuto copre le sessioni interattive, claude -p, le sessioni dell'Agent SDK, le sessioni in background e la maggior parte dei sottocomandi.

Il rifiuto è deliberato, quindi un helper che ha bisogno di resilienza alle interruzioni dovrebbe servire dalla sua stessa cache e uscire con 0.

Quando un aggiornamento in background non riesce, Claude Code mantiene l'ultima politica riuscita in vigore e /status mostra l'aggiornamento non riuscito con il suo motivo fino a quando un aggiornamento non riesce. Ogni aggiornamento viene eseguito secondo le stesse regole di timeoutMs e fallimento dell'esecuzione all'avvio.

Con --debug, Claude Code scrive stderr dell'helper da ogni esecuzione al log di debug.

Claude Code segnala un valore policyHelper non valido come una voce eliminata e avvia la sessione sulle impostazioni gestite rimanenti senza eseguire un helper. I valori non validi includono una stringa di percorso bare e un timeoutMs al di sotto del suo minimo.

Per disattivare un helper, rimuovi la chiave dalla fonte che la imposta.

`policyHelper.path`

Nomina l'eseguibile dell'helper che Claude Code esegue. Per quello che accade quando il percorso viola le regole sottostanti, vedere Errori dell'helper.

  • Scope: Managed. Leggi dal plist macOS, dal registro Windows HKLM o dal file delle impostazioni gestite, ovunque policyHelper sia letto.
  • Type: string, un percorso assoluto in forma normalizzata, senza segmenti . o ..; su Windows, un percorso con lettera di unità o UNC che termina in .exe
  • Default: nessuno; obbligatorio quando policyHelper è impostato
{
  "policyHelper": {
    "path": "/usr/local/bin/claude-policy"
  }
}

`policyHelper.timeoutMs`

Imposta quanto tempo Claude Code attende l'helper prima di trattare l'esecuzione come non riuscita. Un'esecuzione scaduta non riesce allo stesso modo di un'uscita con valore diverso da zero, quindi all'avvio Claude Code rifiuta di avviarsi.

  • Scope: Managed. Leggi dal plist macOS, dal registro Windows HKLM o dal file delle impostazioni gestite, ovunque policyHelper sia letto.
  • Type: integer, millisecondi, minimo 1000
  • Default: 10000
{
  "policyHelper": {
    "path": "/usr/local/bin/claude-policy",
    "timeoutMs": 5000
  }
}

`policyHelper.refreshIntervalMs`

Fai in modo che Claude Code riesegua l'helper in background su un intervallo in modo che i cambiamenti di politica raggiungano una sessione in esecuzione. Quando un aggiornamento ha successo, il suo output sostituisce le impostazioni gestite precedenti senza un riavvio; quando un aggiornamento non riesce, Claude Code mantiene la politica che ha già.

  • Scope: Managed. Leggi dal plist macOS, dal registro Windows HKLM o dal file delle impostazioni gestite, ovunque policyHelper sia letto.
  • Type: integer, millisecondi: 0 per disabilitare l'aggiornamento, altrimenti almeno 60000
  • Default: non impostato, quindi Claude Code esegue l'helper una volta all'avvio

Questo esempio riesegue l'helper ogni cinque minuti:

{
  "policyHelper": {
    "path": "/usr/local/bin/claude-policy",
    "refreshIntervalMs": 300000
  }
}

`wslInheritsWindowsSettings`

Fai in modo che Claude Code su WSL legga le impostazioni gestite dalla catena di politica Windows, con HKLM e il file delle impostazioni gestite Windows che hanno priorità su /etc/claude-code e HKCU al di sotto. Mentre la catena è attiva, Claude Code legge /etc/claude-code solo quando nessun file di impostazioni gestite o drop-in sotto C:\Program Files\ClaudeCode\ fornisce una chiave di politica. Impostalo per estendere la politica che già distribuisci su Windows alle sessioni WSL sulla stessa macchina, in modo che seguano le stesse regole delle sessioni host. Claude Code lo onora solo quando impostato nella chiave del registro HKLM o in un file di impostazioni gestite o drop-in sotto C:\Program Files\ClaudeCode\, entrambi i quali richiedono l'amministratore Windows per scrivere.

  • Scope: Managed. In una fonte Windows controllata dall'amministratore.
  • Type: Boolean
    • true: Claude Code su WSL legge le impostazioni gestite dalla catena di politica Windows e legge /etc/claude-code solo quando nessun file di impostazioni gestite o drop-in sotto C:\Program Files\ClaudeCode\ fornisce una chiave di politica
    • false: WSL legge solo /etc/claude-code
  • Default: false, quindi WSL legge solo /etc/claude-code
{
  "wslInheritsWindowsSettings": true
}

Una volta che una fonte amministrativa attiva la catena, la politica HKCU si unisce ad essa su WSL solo quando HKCU imposta anche la chiave su true. Quella copia non attiva la catena da sola. Una fonte Windows che contiene solo questa chiave non conta come fonte di politica, quindi una fonte con priorità inferiore fornisce comunque la politica. Questa chiave non ha effetto su Windows nativo.

Impostazioni di configurazione globale

Salvate queste chiavi in ~/.claude.json, non in un file di impostazioni. Claude Code le ignora ovunque altrove. Claude Code e /config le scrivono per voi nella maggior parte dei casi, e potete anche modificarle manualmente.

`autoConnectIde`

Connettiti a un IDE in esecuzione automaticamente quando avvii Claude Code da un terminale esterno. Appare in /config come Auto-connect to IDE (external terminal) quando esegui Claude Code al di fuori di un terminale VS Code o JetBrains.

  • Scope: Global config
  • Type: Boolean
    • true: Claude Code si connette a un IDE in esecuzione automaticamente quando lo avvii da un terminale esterno
    • false: Claude Code non si connette automaticamente da un terminale esterno; all'interno di un terminale VS Code o JetBrains, o con --ide, si connette comunque
  • Default: false
  • Per-session overrides: CLAUDE_CODE_AUTO_CONNECT_IDE ha la precedenza su questa chiave per una sessione, in entrambe le direzioni
{
  "autoConnectIde": true
}

Claude Code ignora questa chiave in settings.json.

`autoInstallIdeExtension`

Installa l'estensione IDE di Claude Code automaticamente quando esegui Claude Code da un terminale VS Code. Appare in /config come Auto-install IDE extension quando esegui Claude Code all'interno di un terminale VS Code o JetBrains.

  • Scope: Global config
  • Type: Boolean
    • true: Claude Code installa l'estensione IDE automaticamente quando lo esegui da un terminale VS Code
    • false: Claude Code non installa l'estensione automaticamente
  • Default: true
  • Per-session overrides: CLAUDE_CODE_IDE_SKIP_AUTO_INSTALL impostato su 1 salta l'installazione per una sessione anche quando questa chiave è true
{
  "autoInstallIdeExtension": false
}

Claude Code ignora questa chiave in settings.json.

`copyOnSelect`

Copia il testo negli appunti automaticamente quando finisci di selezionarlo con il mouse nel rendering a schermo intero o nella vista agente. Appare in /config come Copy on select mentre il rendering a schermo intero è attivo.

{
  "copyOnSelect": false
}

Claude Code ignora questa chiave in settings.json.

`diffTool`

Scegli dove Claude Code mostra il diff di una modifica Edit o Write che propone quando un IDE VS Code o JetBrains è connesso: "auto" lo apre nel visualizzatore diff dell'IDE, "terminal" lo mantiene nel terminale. Appare in /config come Diff tool solo mentre Claude Code è connesso a un IDE VS Code o JetBrains.

  • Scope: Global config
  • Type: string, uno di:
    • "auto": Claude Code apre il diff nel visualizzatore diff dell'IDE quando un IDE VS Code o JetBrains è connesso
    • "terminal": Claude Code mantiene il diff nel terminale
  • Default: "auto"
{
  "diffTool": "terminal"
}

Claude Code ignora questa chiave in settings.json.

`externalEditorContext`

Quando premi Ctrl+G, Claude Code apre il prompt che stai digitando nel tuo editor esterno. Con questa chiave attivata, il buffer dell'editor inizia con la risposta precedente di Claude come righe di commento #, così puoi leggerla mentre scrivi, e Claude Code rimuove quelle righe quando salvi. Appare in /config come Show last response in external editor.

  • Scope: Global config
  • Type: Boolean
    • true: il buffer dell'editor inizia con la risposta precedente di Claude come righe di commento #, che Claude Code rimuove quando salvi
    • false: il buffer dell'editor si apre solo con il tuo prompt
  • Default: false
{
  "externalEditorContext": true
}

Con questa opzione attivata, il buffer che Claude Code apre assomiglia a questo, e solo il testo sotto la riga del marcatore viene inviato come tuo prompt:

# ─── Claude's last response (for reference; removed on save) ───
# I added the retry loop to fetchUser in src/api.ts and a test
# for the timeout case. Want me to wire the same retry into
# fetchOrders?
# ─── Write your reply below this line ──────────────────────────

Yes, and cap it at three attempts.

Claude Code mantiene le ultime 50 righe della risposta e contrassegna il taglio con # … (earlier output truncated).

Claude Code ignora questa chiave in settings.json.

`permissionExplainerEnabled`

Fino alla v2.1.256, potevi premere Ctrl+E su un prompt di autorizzazione Bash o PowerShell per vedere una spiegazione generata dal modello del comando, e impostare questa chiave su false per disattivare quella scorciatoia.

  • Scope: Global config. Sulla v2.1.256 e precedenti.
  • Type: Boolean
  • Default: true

`teammateDefaultModel`

Fino alla v2.1.233, impostavi questa chiave sul modello per i compagni di squadra del team agente che il tuo prompt non ha nominato un modello per: un alias come "sonnet", o null per seguire il modello del lead. Per il modello che Claude Code sceglie per tali compagni di squadra ora, vedi specifica compagni di squadra e modelli.

  • Scope: Global config. Sulla v2.1.233 e precedenti.
  • Type: string, un alias di modello o ID modello completo, o null
  • Default: unset

Vedi anche