Impostazioni di Claude Code

Configura Claude Code con impostazioni globali e a livello di progetto, e variabili di ambiente.

Claude Code offre una varietà di impostazioni per configurare il suo comportamento in base alle vostre esigenze. Potete configurare Claude Code eseguendo il comando /config quando utilizzate il REPL interattivo, che apre un'interfaccia Impostazioni con schede dove potete visualizzare le informazioni di stato e modificare le opzioni di configurazione.

Ambiti di configurazione

Claude Code utilizza un sistema di ambiti per determinare dove si applicano le configurazioni e con chi vengono condivise. Comprendere gli ambiti ti aiuta a decidere come configurare Claude Code per uso personale, collaborazione di team o distribuzione aziendale.

Ambiti disponibili

Ambito	Posizione	Chi è interessato	Condiviso con il team?
Managed	Impostazioni gestite dal server, plist / registro, o `managed-settings.json` a livello di sistema	Tutti gli utenti sulla macchina	Sì (distribuito da IT)
User	Directory `~/.claude/`	Tu, in tutti i progetti	No
Project	`.claude/` nel repository	Tutti i collaboratori su questo repository	Sì (committato in git)
Local	`.claude/settings.local.json`	Tu, solo in questo repository	No (gitignored quando Claude Code lo crea)

Quando utilizzare ogni ambito

L'ambito Managed è per:

Politiche di sicurezza che devono essere applicate a livello organizzativo
Requisiti di conformità che non possono essere ignorati
Configurazioni standardizzate distribuite da IT/DevOps

L'ambito User è migliore per:

Preferenze personali che desideri ovunque (temi, impostazioni dell'editor)
Strumenti e plugin che utilizzi in tutti i progetti
Chiavi API e autenticazione (archiviate in modo sicuro)

L'ambito Project è migliore per:

Impostazioni condivise dal team (permessi, hooks, MCP servers)
Plugin che l'intero team dovrebbe avere
Standardizzazione degli strumenti tra i collaboratori

L'ambito Local è migliore per:

Override personali per un progetto specifico
Test delle configurazioni prima di condividerle con il team
Impostazioni specifiche della macchina che non funzioneranno per altri

Come interagiscono gli ambiti

Quando la stessa impostazione è configurata in più ambiti, Claude Code le applica in ordine di priorità:

Managed (più alta) - non può essere ignorata da nulla
Argomenti della riga di comando - override temporanei della sessione
Local - ignora le impostazioni di progetto e utente
Project - ignora le impostazioni utente
User (più bassa) - si applica quando nient'altro specifica l'impostazione

Ad esempio, se le impostazioni utente impostano spinnerTipsEnabled su true e le impostazioni di progetto lo impostano su false, si applica il valore del progetto. Le regole di permesso si comportano diversamente perché si uniscono tra gli ambiti piuttosto che ignorarsi. Vedi Precedenza delle impostazioni.

Cosa utilizza gli ambiti

Gli ambiti si applicano a molte funzionalità di Claude Code:

Funzionalità	Posizione utente	Posizione progetto	Posizione locale
Settings	`~/.claude/settings.json`	`.claude/settings.json`	`.claude/settings.local.json`
Subagents	`~/.claude/agents/`	`.claude/agents/`	Nessuno
MCP servers	`~/.claude.json`	`.mcp.json`	`~/.claude.json` (per-progetto)
Plugins	`~/.claude/settings.json`	`.claude/settings.json`	`.claude/settings.local.json`
CLAUDE.md	`~/.claude/CLAUDE.md`	`CLAUDE.md` o `.claude/CLAUDE.md`	`CLAUDE.local.md`

Su Windows, i percorsi mostrati come ~/.claude si risolvono in %USERPROFILE%\.claude.

File di impostazioni

Il file settings.json è il meccanismo ufficiale per configurare Claude Code attraverso impostazioni gerarchiche:

Le impostazioni utente sono definite in ~/.claude/settings.json e si applicano a tutti i progetti.
Le impostazioni di progetto vengono salvate nella directory del tuo progetto:
- .claude/settings.json per le impostazioni che vengono controllate nel controllo del codice sorgente e condivise con il tuo team
- .claude/settings.local.json per le impostazioni che non vengono controllate, utili per preferenze personali e sperimentazione. Quando Claude Code crea .claude/settings.local.json, configura git per ignorare il file. Se crei il file tu stesso, aggiungilo al tuo gitignore manualmente.
Impostazioni gestite: Per le organizzazioni che necessitano di controllo centralizzato, Claude Code supporta più meccanismi di distribuzione per le impostazioni gestite. Tutti utilizzano lo stesso formato JSON e non possono essere ignorati dalle impostazioni utente o di progetto:
- Impostazioni gestite dal server: consegnate dai server di Anthropic tramite la console di amministrazione Claude.ai. Vedi impostazioni gestite dal server.
- Politiche MDM/a livello di sistema operativo: consegnate tramite la gestione nativa dei dispositivi su macOS e Windows:
  - macOS: dominio delle preferenze gestite com.anthropic.claudecode. Le chiavi di primo livello del plist rispecchiano managed-settings.json, con impostazioni annidate come dizionari e array come array plist. Distribuisci tramite profili di configurazione in Jamf, Iru (Kandji) o strumenti MDM simili.
  - Windows: chiave di registro HKLM\SOFTWARE\Policies\ClaudeCode con un valore Settings (REG_SZ o REG_EXPAND_SZ) contenente JSON (distribuito tramite Criteri di gruppo o Intune)
  - Windows (a livello utente): HKCU\SOFTWARE\Policies\ClaudeCode (priorità di politica più bassa, utilizzata solo quando non esiste alcuna fonte a livello di amministratore)
- Basate su file: managed-settings.json e managed-mcp.json distribuite alle directory di sistema:
  - macOS: /Library/Application Support/ClaudeCode/
  - Linux e WSL: /etc/claude-code/
  - Windows: C:\Program Files\ClaudeCode\
  Warning
  
  Il percorso Windows legacy C:\ProgramData\ClaudeCode\managed-settings.json non è più supportato a partire da v2.1.75. Gli amministratori che hanno distribuito impostazioni in quella posizione devono migrare i file a C:\Program Files\ClaudeCode\managed-settings.json.
  
  Le impostazioni gestite basate su file supportano anche una directory drop-in in managed-settings.d/ nella stessa directory di sistema insieme a managed-settings.json. Questo consente ai team separati di distribuire frammenti di politica indipendenti senza coordinare le modifiche a un singolo file.
  
  Seguendo la convenzione systemd, managed-settings.json viene unito per primo come base, quindi tutti i file *.json nella directory drop-in vengono ordinati alfabeticamente e uniti in cima. I file successivi ignorano quelli precedenti per i valori scalari; gli array vengono concatenati e deduplicati; gli oggetti vengono uniti in profondità. I file nascosti che iniziano con . vengono ignorati.
  
  Usa prefissi numerici per controllare l'ordine di unione, ad esempio 10-telemetry.json e 20-security.json.
Vedi impostazioni gestite e Configurazione MCP gestita per i dettagli.

Questo repository include modelli di distribuzione iniziali per Jamf, Iru (Kandji), Intune e Criteri di gruppo. Usa questi come punti di partenza e adattali alle tue esigenze.

Note

Le distribuzioni gestite possono anche limitare le aggiunte del marketplace dei plugin utilizzando strictKnownMarketplaces. Per ulteriori informazioni, vedi Restrizioni del marketplace gestito.
Altra configurazione è archiviata in ~/.claude.json. Questo file contiene la tua sessione OAuth, configurazioni dei MCP server per gli ambiti utente e locale, stato per-progetto (strumenti consentiti, impostazioni di fiducia), e varie cache. I MCP server con ambito di progetto sono archiviati separatamente in .mcp.json.

{
  "$schema": "https://json.schemastore.org/claude-code-settings.json",
  "permissions": {
    "allow": [
      "Bash(npm run lint)",
      "Bash(npm run test *)",
      "Read(~/.zshrc)"
    ],
    "deny": [
      "Bash(curl *)",
      "Read(./.env)",
      "Read(./.env.*)",
      "Read(./secrets/**)"
    ]
  },
  "env": {
    "CLAUDE_CODE_ENABLE_TELEMETRY": "1",
    "OTEL_METRICS_EXPORTER": "otlp"
  },
  "companyAnnouncements": [
    "Welcome to Acme Corp! Review our code guidelines at docs.acme.com",
    "Reminder: Code reviews required for all PRs",
    "New security policy in effect"
  ]
}

La riga $schema nell'esempio sopra punta allo schema JSON ufficiale per le impostazioni di Claude Code. Aggiungerlo al tuo settings.json abilita l'autocompletamento e la convalida inline in VS Code, Cursor e qualsiasi altro editor che supporta la convalida dello schema JSON.

Lo schema pubblicato viene aggiornato periodicamente e potrebbe non includere le impostazioni aggiunte nei rilasci CLI più recenti, quindi un avviso di convalida su un campo documentato di recente non significa necessariamente che la tua configurazione non sia valida.

Quando gli edits hanno effetto

Claude Code osserva i tuoi file di impostazioni e li ricarica quando cambiano, quindi gli edits alla maggior parte delle chiavi si applicano alla sessione in esecuzione senza un riavvio. Questo include permissions, hooks, e helper di credenziali come apiKeyHelper. Il ricaricamento copre le impostazioni utente, progetto, locale e gestite, e l'hook ConfigChange si attiva per ogni modifica rilevata.

Alcune chiavi vengono lette una sola volta all'avvio della sessione e si applicano al riavvio successivo:

model: usa /model per cambiare durante la sessione
outputStyle: parte del prompt di sistema, che viene ricostruito su /clear o riavvio

Voci non valide nelle impostazioni gestite

Le impostazioni gestite analizzano in modo tollerante. Quando una configurazione gestita contiene una voce che non supera la convalida dello schema, Claude Code rimuove quella voce, registra un avviso e applica ogni politica valida rimanente. Un singolo errore di battitura non può disabilitare il resto della politica della tua organizzazione. Questo comportamento è coerente in tutti e tre i meccanismi di distribuzione: impostazioni gestite dal server, politiche plist e registro distribuite tramite MDM, e file managed-settings.json. Richiede Claude Code v2.1.169 o successivo.

I campi di applicazione della sicurezza vengono gestiti per campo invece di essere rimossi all'ingrosso quando sono presenti ma non validi:

Campo	Comportamento quando presente ma non valido
`allowedMcpServers`	Applicato come una lista di autorizzazione vuota, quindi nessun MCP server viene ammesso fino a quando il valore non viene corretto. Una singola voce non valida viene rimossa e il sottoinsieme valido viene applicato.
`allowManagedMcpServersOnly`	Trattato come `true`.
`availableModels`	{/* min-version: 2.1.175 */}Applicato come una lista di autorizzazione vuota, quindi solo il modello Predefinito è disponibile fino a quando il valore non viene corretto. Una singola voce non stringa viene rimossa e il sottoinsieme valido viene applicato. Si applica in v2.1.175 e successivo.
`enforceAvailableModels`	{/* min-version: 2.1.175 */}Trattato come `true`. Si applica in v2.1.175 e successivo.
`forceLoginOrgUUID`	Nessuna organizzazione è autorizzata ad accedere fino a quando il valore non viene corretto.
`deniedMcpServers`	Una singola voce non valida viene rimossa e il sottoinsieme valido viene applicato. Un valore completamente non valido viene eliminato con un avviso, poiché negare ogni server bloccherebbe i server che la politica non ha mai nominato.

requiredMinimumVersion e requiredMaximumVersion falliscono in modo aperto per progettazione: un valore non valido viene rimosso piuttosto che applicato, quindi una politica errata non può impedire l'avvio di Claude Code.

Gli errori di convalida vengono visualizzati in tre posizioni:

Le sessioni interattive mostrano una finestra di dialogo all'avvio che elenca le voci non valide.
Le esecuzioni headless con -p stampano un riepilogo su stderr.
claude doctor elenca ogni voce non valida con la sua fonte e il campo.

Convalida i cambiamenti di politica eseguendo claude doctor su una macchina di test prima di distribuirli su tutta la flotta.

Questa tolleranza si applica solo alle impostazioni gestite. I file di impostazioni utente, progetto e locale rimangono rigorosi: un file che non supera la convalida viene rifiutato nel complesso e segnalato.

Impostazioni disponibili

settings.json supporta un numero di opzioni:

Chiave	Descrizione	Esempio
`advisorModel`	{/* min-version: 2.1.98 /}Modello per lo strumento advisor lato server. Accetta un alias di modello come `"opus"`, `"sonnet"`, o `"fable"` ({/ min-version: 2.1.170 */}v2.1.170+), o un ID modello completo. Scritto automaticamente quando esegui `/advisor`. Non impostato per disabilitare l'advisor. Richiede Claude Code v2.1.98 o successivo	`"opus"`
`agent`	Esegui il thread principale come un subagent denominato e imposta l'agente predefinito per le sessioni inviate da `claude agents`. Applica il prompt di sistema, le restrizioni degli strumenti e il modello di quel subagent. Vedi Invoca i subagent esplicitamente	`"code-reviewer"`
`agentPushNotifEnabled`	{/* min-version: 2.1.119 /}Quando il Controllo remoto è connesso, consenti a Claude di inviare notifiche push proattive al tuo telefono, ad esempio quando un'attività lunga finisce. Predefinito: `false`. Appare in `/config` come Push when Claude decides*. Vedi Notifiche push mobile. Richiede Claude Code v2.1.119 o successivo	`true`
`allowAllClaudeAiMcps`	(Solo impostazioni gestite) Carica i connettori claude.ai insieme a un `managed-mcp.json` distribuito, che altrimenti assume il controllo esclusivo e li sopprime. Vedi Configurazione MCP gestita	`true`
`allowedChannelPlugins`	(Solo impostazioni gestite) Elenco di autorizzazione dei plugin di canale che possono inviare messaggi. Sostituisce l'elenco di autorizzazione predefinito di Anthropic quando impostato. Non definito = ricaduta al predefinito, array vuoto = blocca tutti i plugin di canale. Richiede `channelsEnabled: true`. Vedi Limita quali plugin di canale possono essere eseguiti	`[{ "marketplace": "claude-plugins-official", "plugin": "telegram" }]`
`allowedHttpHookUrls`	Elenco di autorizzazione dei modelli di URL che gli hook HTTP possono indirizzare. Supporta `*` come carattere jolly. Quando impostato, gli hook con URL non corrispondenti vengono bloccati. Non definito = nessuna restrizione, array vuoto = blocca tutti gli hook HTTP. Gli array si uniscono tra le fonti di impostazioni. Vedi Configurazione hook	`["https://hooks.example.com/*"]`
`allowedMcpServers`	Quando impostato in managed-settings.json, elenco di autorizzazione dei MCP server che gli utenti possono configurare. Non definito = nessuna restrizione, array vuoto = blocco. Si applica a tutti gli ambiti. L'elenco di negazione ha la precedenza. Vedi Configurazione MCP gestita	`[{ "serverName": "github" }]`
`allowManagedHooksOnly`	(Solo impostazioni gestite) Solo gli hook gestiti, gli hook SDK e gli hook dai plugin forzatamente abilitati nelle impostazioni gestite `enabledPlugins` vengono caricati. Gli hook utente, di progetto e di tutti gli altri plugin vengono bloccati. Vedi Configurazione hook	`true`
`allowManagedMcpServersOnly`	(Solo impostazioni gestite) Solo `allowedMcpServers` dalle impostazioni gestite sono rispettati. `deniedMcpServers` si unisce comunque da tutte le fonti. Gli utenti possono ancora aggiungere MCP server, ma si applica solo l'elenco di autorizzazione definito dall'amministratore. Vedi Configurazione MCP gestita	`true`
`allowManagedPermissionRulesOnly`	(Solo impostazioni gestite) Previeni che le impostazioni utente e di progetto definiscano regole di permesso `allow`, `ask` o `deny`. Si applicano solo le regole nelle impostazioni gestite. Vedi Impostazioni solo gestite	`true`
`alwaysThinkingEnabled`	Abilita il pensiero esteso per impostazione predefinita per tutte le sessioni. Tipicamente configurato tramite il comando `/config` piuttosto che modificato direttamente. Per forzare il pensiero disattivato indipendentemente da questa impostazione, imposta `MAX_THINKING_TOKENS=0` in `env`, che disabilita il pensiero sull'API Anthropic tranne su Fable 5, che non può avere il pensiero disattivato. Su provider di terze parti questo omette il parametro `thinking` invece, e i modelli di ragionamento adattivo potrebbero comunque pensare	`true`
`apiKeyHelper`	Script personalizzato, da eseguire in `/bin/sh`, per generare un valore di autenticazione. Questo valore verrà inviato come intestazioni `X-Api-Key` e `Authorization: Bearer` per le richieste di modello. Imposta l'intervallo di aggiornamento con `CLAUDE_CODE_API_KEY_HELPER_TTL_MS`	`/bin/generate_temp_api_key.sh`
`attribution`	Personalizza l'attribuzione per i commit git e le pull request. Vedi Impostazioni di attribuzione	`{"commit": "🤖 Generated with Claude Code", "pr": ""}`
`autoCompactEnabled`	{/* min-version: 2.1.119 /}Compatta automaticamente la conversazione quando il contesto si avvicina al limite. Predefinito: `true`. Appare in `/config` come Auto-compact*. Per disabilitare tramite variabile di ambiente, imposta `DISABLE_AUTO_COMPACT` in `env`	`false`
`autoMemoryDirectory`	Directory personalizzata per l'archiviazione della memoria automatica. Accetta un percorso assoluto o un percorso con prefisso `~/`. Dalle impostazioni di progetto o locale, questo viene onorato solo dopo che accetti la finestra di dialogo di fiducia dell'area di lavoro, poiché un repository clonato può fornire questo file	`"~/my-memory-dir"`
`autoMemoryEnabled`	Abilita la memoria automatica. Quando `false`, Claude non legge da o scrive nella directory di memoria automatica. Predefinito: `true`. Puoi anche attivare/disattivare questo con `/memory` durante una sessione. Per disabilitare tramite variabile di ambiente, imposta `CLAUDE_CODE_DISABLE_AUTO_MEMORY` in `env`	`false`
`autoMode`	Personalizza cosa il classificatore della modalità auto blocca e consente. Contiene array `environment`, `allow`, `soft_deny` e `hard_deny` di regole in prosa. Includi la stringa letterale `"$defaults"` in un array per ereditare le regole incorporate in quella posizione. Vedi Configura la modalità auto. Non letto dalle impostazioni di progetto condivise	`{"soft_deny": ["$defaults", "Never run terraform apply"]}`
`autoScrollEnabled`	Nel rendering fullscreen, segui il nuovo output fino al fondo della conversazione. Predefinito: `true`. Appare in `/config` come Auto-scroll. I prompt di permesso scorrono comunque in vista quando questo è disattivato	`false`
`autoUpdatesChannel`	Canale di rilascio da seguire per gli aggiornamenti. Usa `"stable"` per una versione che è tipicamente circa una settimana vecchia e salta le versioni con regressioni importanti, o `"latest"` (predefinito) per il rilascio più recente. Per disabilitare completamente gli auto-aggiornamenti, imposta `DISABLE_AUTOUPDATER` in `env`	`"stable"`
`availableModels`	Limita quali modelli gli utenti possono selezionare per la sessione principale, i subagent, e l'advisor. Vedi Limita la selezione del modello. Vedi `enforceAvailableModels` per vincolare anche il modello Predefinito	`["sonnet", "haiku"]`
`awaySummaryEnabled`	Mostra un riepilogo di una riga della sessione quando torni al terminale dopo alcuni minuti di assenza. Imposta a `false` o disattiva Riepilogo sessione in `/config` per disabilitare. Uguale a `CLAUDE_CODE_ENABLE_AWAY_SUMMARY`	`true`
`awsAuthRefresh`	Script personalizzato che modifica la directory `.aws` (vedi configurazione avanzata delle credenziali)	`aws sso login --profile myprofile`
`awsCredentialExport`	Script personalizzato che restituisce JSON con le credenziali AWS (vedi configurazione avanzata delle credenziali)	`/bin/generate_aws_grant.sh`
`blockedMarketplaces`	(Solo impostazioni gestite) Elenco di negazione delle fonti del marketplace. Applicato all'aggiunta del marketplace e all'installazione, aggiornamento, aggiornamento e auto-aggiornamento del plugin, quindi un marketplace aggiunto prima che la politica fosse impostata non può essere utilizzato per recuperare i plugin. Le fonti bloccate vengono controllate prima del download, quindi non toccano mai il filesystem. Vedi Restrizioni del marketplace gestito	`[{ "source": "github", "repo": "untrusted/plugins" }]`
`channelsEnabled`	(Solo impostazioni gestite) Consenti channels per l'organizzazione. Nei piani Team e Enterprise di claude.ai, i canali vengono bloccati quando questo non è impostato o è `false`. Per gli account Anthropic Console che utilizzano l'autenticazione con chiave API, i canali sono consentiti per impostazione predefinita a meno che la tua organizzazione non distribuisca impostazioni gestite, nel qual caso questa chiave deve essere impostata a `true`	`true`
`claudeMd`	(Solo impostazioni gestite) Istruzioni in stile CLAUDE.md iniettate come memoria gestita dall'organizzazione. Onorato solo quando impostato nelle impostazioni gestite o di politica e ignorato nelle impostazioni utente, progetto e locale. Vedi CLAUDE.md a livello organizzativo	`"Always run make lint before committing."`
`claudeMdExcludes`	Modelli Glob o percorsi assoluti dei file `CLAUDE.md` da saltare durante il caricamento della memoria. I modelli corrispondono ai percorsi assoluti dei file. Si applica solo alla memoria utente, progetto e locale; i file di politica gestiti non possono essere esclusi	`["/vendor//CLAUDE.md"]`
`cleanupPeriodDays`	I file di sessione più vecchi di questo periodo vengono eliminati all'avvio (predefinito: 30 giorni, minimo 1). L'impostazione a `0` viene rifiutata con un errore di convalida. Controlla anche il limite di età per la rimozione automatica dei worktrees subagent orfani all'avvio. Per disabilitare completamente le scritture di trascritti, imposta la variabile di ambiente `CLAUDE_CODE_SKIP_PROMPT_HISTORY`, o in modalità non interattiva (`-p`) usa il flag `--no-session-persistence` o l'opzione SDK `persistSession: false`.	`20`
`companyAnnouncements`	Annuncio da visualizzare agli utenti all'avvio. Se vengono forniti più annunci, verranno alternati casualmente.	`["Welcome to Acme Corp! Review our code guidelines at docs.acme.com"]`
`defaultShell`	Shell predefinita per i comandi `!` della casella di input. Accetta `"bash"` (predefinito) o `"powershell"`. L'impostazione a `"powershell"` instrada i comandi `!` interattivi tramite PowerShell su Windows. Richiede `CLAUDE_CODE_USE_POWERSHELL_TOOL=1`. Vedi Strumento PowerShell	`"powershell"`
`deniedMcpServers`	Quando impostato in managed-settings.json, elenco di negazione dei MCP server che sono esplicitamente bloccati. Si applica a tutti gli ambiti inclusi i server gestiti. L'elenco di negazione ha la precedenza sull'elenco di autorizzazione. Vedi Configurazione MCP gestita	`[{ "serverName": "filesystem" }]`
`disableAgentView`	Imposta a `true` per disattivare gli agenti in background e la visualizzazione degli agenti: `claude agents`, `--bg`, `/background`, e il supervisore su richiesta. Tipicamente impostato nelle impostazioni gestite. Equivalente all'impostazione di `CLAUDE_CODE_DISABLE_AGENT_VIEW` a `1`	`true`
`disableAllHooks`	Disabilita tutti gli hooks e qualsiasi status line personalizzato	`true`
`disableAutoMode`	Imposta a `"disable"` per prevenire l'attivazione della modalità auto. Rimuove `auto` dal ciclo `Shift+Tab` e rifiuta `--permission-mode auto` all'avvio. Molto utile nelle impostazioni gestite dove gli utenti non possono ignorarla	`"disable"`
`disableBundledSkills`	Imposta a `true` per disabilitare gli skills e i flussi di lavoro che vengono forniti con Claude Code: gli skills bundled e i flussi di lavoro vengono rimossi completamente, mentre i comandi slash incorporati come `/init` rimangono digitabili ma sono nascosti dal modello. Gli skills dai plugin, `.claude/skills/`, e `.claude/commands/` non sono interessati. Equivalente all'impostazione di `CLAUDE_CODE_DISABLE_BUNDLED_SKILLS` a `1`	`true`
`disableDeepLinkRegistration`	Imposta a `"disable"` per prevenire che Claude Code registri il gestore del protocollo `claude-cli://` con il sistema operativo all'avvio. I deep link consentono agli strumenti esterni di aprire una sessione di Claude Code con un prompt pre-compilato. Utile negli ambienti in cui la registrazione del gestore del protocollo è limitata o gestita separatamente	`"disable"`
`disabledMcpjsonServers`	Elenco di MCP server specifici dai file `.mcp.json` da rifiutare	`["filesystem"]`
`disableRemoteControl`	{/* min-version: 2.1.128 */}Disabilita il Controllo remoto: blocca `claude remote-control`, il flag `--remote-control`, l'avvio automatico e l'interruttore in-sessione. Tipicamente posizionato nelle impostazioni gestite per l'applicazione MDM per dispositivo, ma funziona da qualsiasi ambito. Richiede Claude Code v2.1.128 o successivo	`true`
`disableSkillShellExecution`	Disabilita l'esecuzione inline della shell per i blocchi !`...` e ```! negli skills e nei comandi personalizzati da fonti utente, progetto, plugin o directory aggiuntive. I comandi vengono sostituiti con `[shell command execution disabled by policy]` invece di essere eseguiti. Gli skills bundled e gestiti non sono interessati. Molto utile nelle impostazioni gestite dove gli utenti non possono ignorarla	`true`
`disableWorkflows`	Disabilita i flussi di lavoro dinamici e i comandi di flusso di lavoro bundled. Predefinito: `false`. Equivalente all'impostazione di `CLAUDE_CODE_DISABLE_WORKFLOWS` a `1`	`true`
`editorMode`	Modalità di scorciatoie da tastiera per il prompt di input: `"normal"` o `"vim"`. Predefinito: `"normal"`. Appare in `/config` come Editor mode	`"vim"`
`effortLevel`	Persisti il livello di sforzo tra le sessioni. Accetta `"low"`, `"medium"`, `"high"`, o `"xhigh"`. Scritto automaticamente quando esegui `/effort` con uno di questi valori. `--effort` e `CLAUDE_CODE_EFFORT_LEVEL` ignorano questo per una sessione. Vedi Regola il livello di sforzo per i modelli supportati	`"xhigh"`
`enableAllProjectMcpServers`	Approva automaticamente tutti i MCP server definiti nei file `.mcp.json` del progetto	`true`
`enabledMcpjsonServers`	Elenco di MCP server specifici dai file `.mcp.json` da approvare	`["memory", "github"]`
`enforceAvailableModels`	{/* min-version: 2.1.175 */}Quando `true` e `availableModels` è una lista non vuota nelle impostazioni gestite o di politica, il modello Predefinito è anche vincolato all'elenco di autorizzazione. Vedi Limita la selezione del modello per i dettagli e il comportamento di unione quando `availableModels` è impostato a più livelli. Richiede Claude Code v2.1.175 o successivo	`true`
`env`	Variabili di ambiente applicate a ogni sessione e ai sottoprocessi che Claude Code genera da essa. {/* min-version: 2.1.143 */}A partire da v2.1.143, `NO_COLOR` e `FORCE_COLOR` impostati qui vengono passati ai sottoprocessi ma non cambiano i colori dell'interfaccia di Claude Code stesso. Imposta quelli nella tua shell prima di lanciare `claude` per cambiare i colori dell'interfaccia	`{"FOO": "bar"}`
`fallbackModel`	Modello/i di fallback da provare in ordine quando il modello primario è sovraccarico o non disponibile. Claude Code passa al modello disponibile successivo nella catena per il resto del turno e mostra un avviso. `"default"` si espande al modello predefinito. Le catene sono limitate a tre modelli; le voci extra vengono ignorate. A differenza della maggior parte delle impostazioni di array, questa chiave non si unisce tra i file di impostazioni: il file con la precedenza più alta che la definisce fornisce l'intera catena. Il flag `--fallback-model` ignora questo per una sessione. Vedi Catene di modelli di fallback	`["claude-sonnet-4-6", "claude-haiku-4-5"]`
`fastModePerSessionOptIn`	Quando `true`, la modalità veloce non persiste tra le sessioni. Ogni sessione inizia con la modalità veloce disattivata, richiedendo agli utenti di abilitarla con `/fast`. La preferenza della modalità veloce dell'utente viene comunque salvata. Vedi Richiedi opt-in per sessione	`true`
`feedbackSurveyRate`	Probabilità (0–1) che il sondaggio sulla qualità della sessione appaia quando idoneo. Imposta a `0` per sopprimere completamente, o imposta `CLAUDE_CODE_DISABLE_FEEDBACK_SURVEY` in `env`. Utile quando si utilizza Bedrock, Vertex, o Foundry dove il tasso di campionamento predefinito non si applica	`0.05`
`fileCheckpointingEnabled`	{/* min-version: 2.1.119 /}Snapshot dei file prima di ogni edit in modo che `/rewind` possa ripristinarli. Predefinito: `true`. Appare in `/config` come Rewind code (checkpoints)*. Per disabilitare tramite variabile di ambiente, imposta `CLAUDE_CODE_DISABLE_FILE_CHECKPOINTING` in `env`	`false`
`fileSuggestion`	Configura uno script personalizzato per l'autocompletamento dei file `@`. Vedi Impostazioni di suggerimento file	`{"type": "command", "command": "~/.claude/file-suggestion.sh"}`
`footerLinksRegexes`	{/* min-version: 2.1.176 */}Renderizza badge cliccabili extra nel footer quando un regex corrisponde all'output del turno. Ogni voce ha un `pattern`, un modello di URL `url` con placeholder `{name}` riempiti dai gruppi di cattura denominati, e un `label` opzionale. Letto dalle impostazioni utente, dal flag `--settings`, e dalle impostazioni gestite solo. Vedi Badge di link nel footer per i vincoli dell'URL, l'elenco di schemi consentiti, e i limiti. Richiede Claude Code v2.1.176 o successivo	`[{"type": "regex", "pattern": "\\b(?<key>PROJ-\\d+)\\b", "url": "https://issues.example.com/browse/{key}", "label": "{key}"}]`
`forceLoginMethod`	Usa `claudeai` per limitare l'accesso agli account Claude.ai, `console` per limitare l'accesso agli account Claude Console. Quando impostato nelle impostazioni gestite, le sessioni autenticate tramite `ANTHROPIC_API_KEY`, `ANTHROPIC_AUTH_TOKEN`, o `apiKeyHelper` vengono bloccate all'avvio, poiché nessuno dei due valori può essere soddisfatto senza OAuth di prima parte. Le sessioni del provider di terze parti come Bedrock, Vertex e Foundry non vengono bloccate: si autenticano rispetto al tuo provider cloud piuttosto che ad Anthropic	`claudeai`
`forceLoginOrgUUID`	Richiedi che l'accesso appartenga a un'organizzazione specifica di Anthropic. Accetta una singola stringa UUID, che pre-seleziona anche quell'organizzazione durante l'accesso, o un array di UUID dove qualsiasi organizzazione elencata è accettata senza pre-selezione. Quando impostato nelle impostazioni gestite, l'accesso fallisce se l'account autenticato non appartiene a un'organizzazione elencata, e le sessioni autenticate tramite `ANTHROPIC_API_KEY`, `ANTHROPIC_AUTH_TOKEN`, o `apiKeyHelper` vengono bloccate all'avvio poiché l'appartenenza all'organizzazione non può essere verificata per loro. Le sessioni del provider di terze parti come Bedrock, Vertex e Foundry non vengono bloccate: usa il tuo IAM cloud per limitare quali account cloud possono essere utilizzati. Un array vuoto fallisce in modo chiuso e blocca l'accesso con un messaggio di errore di configurazione	`"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"` o `["xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx", "yyyyyyyy-yyyy-yyyy-yyyy-yyyyyyyyyyyy"]`
`forceRemoteSettingsRefresh`	(Solo impostazioni gestite) Blocca l'avvio della CLI fino a quando le impostazioni gestite remote non vengono recuperate di recente dal server. Se il recupero fallisce, la CLI esce invece di continuare con le impostazioni memorizzate nella cache o senza impostazioni. Quando non impostato, l'avvio continua senza attendere le impostazioni remote. Vedi applicazione fail-closed	`true`
`gcpAuthRefresh`	Script personalizzato che aggiorna le credenziali predefinite dell'applicazione GCP quando scadono o non possono essere caricate. Vedi configurazione avanzata delle credenziali	`gcloud auth application-default login`
`hooks`	Configura comandi personalizzati da eseguire agli eventi del ciclo di vita. Vedi documentazione hooks per il formato	Vedi hooks
`httpHookAllowedEnvVars`	Elenco di autorizzazione dei nomi delle variabili di ambiente che gli hook HTTP possono interpolare nelle intestazioni. Quando impostato, l'`allowedEnvVars` effettivo di ogni hook è l'intersezione del suo elenco e di questa impostazione. Non definito = nessuna restrizione. Gli array si uniscono tra le fonti di impostazioni. Vedi Configurazione hook	`["MY_TOKEN", "HOOK_SECRET"]`
`includeCoAuthoredBy`	Deprecato: Usa `attribution` invece. Se includere la riga `co-authored-by Claude` nei commit git e nelle pull request (predefinito: `true`)	`false`
`includeGitInstructions`	Includi le istruzioni integrate del flusso di lavoro di commit e PR e lo snapshot dello stato git nel prompt di sistema di Claude (predefinito: `true`). Imposta a `false` per rimuovere entrambi, ad esempio quando utilizzi le tue skill di flusso di lavoro git. La variabile di ambiente `CLAUDE_CODE_DISABLE_GIT_INSTRUCTIONS` ha la precedenza su questa impostazione quando impostata	`false`
`inputNeededNotifEnabled`	{/* min-version: 2.1.119 /}Quando il Controllo remoto è connesso, invia una notifica push al tuo telefono quando un prompt di permesso o una domanda è in attesa del tuo input. Predefinito: `false`. Appare in `/config` come Push when actions required*. Vedi Notifiche push mobile. Richiede Claude Code v2.1.119 o successivo	`true`
`language`	Configura la lingua di risposta preferita di Claude (ad es., `"japanese"`, `"spanish"`, `"french"`). Claude risponderà in questa lingua per impostazione predefinita. Imposta anche la lingua della dettatura vocale e dei titoli di sessione generati automaticamente. {/* min-version: 2.1.176 */}A partire da v2.1.176, quando non impostato, i titoli delle sessioni corrispondono alla lingua della tua conversazione	`"japanese"`
`maxSkillDescriptionChars`	{/* min-version: 2.1.105 */}Limite di caratteri per skill sul testo combinato `description` e `when_to_use` nell'elenco di skills che Claude vede ogni turno (predefinito: `1536`). Il testo più lungo di questo viene troncato. Aumenta per mantenere le descrizioni lunghe intatte al costo di più contesto per turno; riduci per adattare più skills sotto `skillListingBudgetFraction`. Richiede Claude Code v2.1.105 o successivo	`2048`
`minimumVersion`	Floor che previene l'auto-aggiornamento in background e `claude update` dall'installazione di una versione al di sotto di questa. Passare dal canale `"latest"` a `"stable"` tramite `/config` ti chiede di rimanere sulla versione corrente o di consentire il downgrade. Scegliere di rimanere imposta questo valore. Utile anche nelle impostazioni gestite per fissare un minimo a livello organizzativo. Per un floor rigido che blocca completamente l'avvio, vedi `requiredMinimumVersion`	`"2.1.100"`
`model`	Ignora il modello predefinito da utilizzare per Claude Code. `--model` e `ANTHROPIC_MODEL` ignorano questo per una sessione	`"claude-sonnet-4-6"`
`modelOverrides`	Mappa gli ID dei modelli Anthropic agli ID dei modelli specifici del provider come gli ARN del profilo di inferenza Bedrock. Ogni voce del selettore di modello utilizza il suo valore mappato quando chiama l'API del provider. Vedi Ignora gli ID dei modelli per versione	`{"claude-opus-4-6": "arn:aws:bedrock:..."}`
`otelHeadersHelper`	Script per generare intestazioni OpenTelemetry dinamiche. Viene eseguito all'avvio e periodicamente. Imposta l'intervallo di aggiornamento con `CLAUDE_CODE_OTEL_HEADERS_HELPER_DEBOUNCE_MS`. Vedi Intestazioni dinamiche	`/bin/generate_otel_headers.sh`
`outputStyle`	Configura uno stile di output per regolare il prompt di sistema. Vedi documentazione degli stili di output	`"Explanatory"`
`parentSettingsBehavior`	{/* min-version: 2.1.133 */}(Solo impostazioni gestite) Controlla se le impostazioni gestite fornite programmaticamente da un processo host di incorporamento, come l'Agent SDK o un'estensione IDE, si applicano quando è presente anche un livello gestito distribuito da un amministratore. `"first-wins"`: le impostazioni fornite dal parent vengono eliminate e si applica solo il livello amministrativo. `"merge"`: le impostazioni fornite dal parent si applicano sotto il livello amministrativo, filtrate in modo che possano stringere la politica ma non allentarla. Non ha effetto quando non è distribuito alcun livello amministrativo. Predefinito: `"first-wins"`. Richiede Claude Code v2.1.133 o successivo	`"merge"`
`permissions`	Vedi la tabella sottostante per la struttura dei permessi.
`plansDirectory`	Personalizza dove vengono archiviati i file di piano. Il percorso è relativo alla radice del progetto. Predefinito: `~/.claude/plans`	`"./plans"`
`pluginSuggestionMarketplaces`	(Solo impostazioni gestite) Nomi dei marketplace i cui plugin possono apparire come suggerimenti di installazione contestuali. Nessun suggerimento dichiarato dal marketplace viene visualizzato senza questo elenco di autorizzazione; il suggerimento incorporato di design frontend di prima parte non è interessato. I suggerimenti provengono dalla dichiarazione `relevance` di ogni plugin nella sua voce del marketplace. Un nome ha effetto solo quando il marketplace è registrato sulla macchina e la sua fonte registrata è anche dichiarata nelle impostazioni gestite, come voce `extraKnownMarketplaces` per quel nome o come voce di `strictKnownMarketplaces`. Un marketplace registrato da una fonte diversa con un nome nella lista di autorizzazione viene ignorato. Il marketplace ufficiale è esente dal requisito della fonte: autorizzare il suo nome da solo è sufficiente, poiché quel nome può registrarsi solo dalla fonte Anthropic ufficiale.	`["acme-corp-plugins"]`
`pluginTrustMessage`	(Solo impostazioni gestite) Messaggio personalizzato aggiunto all'avviso di fiducia del plugin mostrato prima dell'installazione. Usa questo per aggiungere contesto specifico dell'organizzazione, ad esempio per confermare che i plugin dal tuo marketplace interno sono controllati.	`"All plugins from our marketplace are approved by IT"`
`policyHelper`	{/* min-version: 2.1.136 */}Eseguibile distribuito dall'amministratore che calcola le impostazioni gestite dinamicamente all'avvio. Onorato solo da MDM o da un file `managed-settings.json` di sistema. Vedi Calcola le impostazioni gestite con un policy helper. Richiede Claude Code v2.1.136 o successivo	`{"path": "/usr/local/bin/claude-policy"}`
`preferredNotifChannel`	Metodo per le notifiche di completamento attività e prompt di permesso: `"auto"`, `"terminal_bell"`, `"iterm2"`, `"iterm2_with_bell"`, `"kitty"`, `"ghostty"`, o `"notifications_disabled"`. Predefinito: `"auto"`, che invia una notifica desktop in iTerm2, Ghostty e Kitty e non fa nulla in altri terminali. Imposta `"terminal_bell"` per suonare il carattere di campanello in qualsiasi terminale. Appare in `/config` come Notifications. Vedi Ottieni un campanello del terminale o una notifica	`"terminal_bell"`
`prefersReducedMotion`	Riduci o disabilita le animazioni dell'interfaccia utente (spinner, shimmer, effetti flash) per l'accessibilità	`true`
`prUrlTemplate`	Modello di URL per il badge PR mostrato nel footer e nei riassunti dei risultati degli strumenti. Sostituisce `{host}`, `{owner}`, `{repo}`, `{number}`, e `{url}` dall'URL PR segnalato da `gh`. Usa per puntare i link PR a uno strumento di revisione del codice interno invece di `github.com`. Non influisce sui link automatici `#123` nella prosa di Claude	`"https://reviews.example.com/{owner}/{repo}/pull/{number}"`
`requiredMaximumVersion`	Solo impostazioni gestite. Versione massima di Claude Code consentita per l'avvio. Se la versione in esecuzione è più recente, Claude Code esce all'avvio e istruisce l'utente a installare una versione approvata tramite il metodo approvato dell'organizzazione; `claude install <version>` potrebbe anche funzionare. L'auto-aggiornamento in background e `claude update` saltano le versioni sopra il limite, quindi un'installazione in intervallo rimane in intervallo. `claude update`, `claude install`, e `claude doctor` continuano a funzionare sopra il limite in modo che gli utenti possano recuperare. Le versioni che precedono questa impostazione la ignorano	`"2.1.150"`
`requiredMinimumVersion`	Solo impostazioni gestite. Versione minima di Claude Code richiesta per l'avvio. Se la versione in esecuzione è più vecchia, Claude Code esce all'avvio e istruisce l'utente ad aggiornare tramite il metodo approvato dell'organizzazione. `claude update`, `claude install`, e `claude doctor` continuano a funzionare sotto il limite in modo che gli utenti possano recuperare. Differisce da `minimumVersion`, che previene i downgrade ma non blocca mai l'avvio. Le versioni che precedono questa impostazione la ignorano	`"2.1.150"`
`respectGitignore`	Controlla se il selettore di file `@` rispetta i modelli `.gitignore`. Quando `true` (predefinito), i file che corrispondono ai modelli `.gitignore` sono esclusi dai suggerimenti	`false`
`showClearContextOnPlanAccept`	Mostra l'opzione "cancella contesto" nella schermata di accettazione del piano. Predefinito: `false`. Imposta a `true` per ripristinare l'opzione	`true`
`showThinkingSummaries`	Mostra i riassunti del pensiero esteso nelle sessioni interattive. Quando non impostato o `false` (predefinito in modalità interattiva), i blocchi di pensiero vengono redatti dall'API e mostrati come uno stub compresso. La redazione cambia solo quello che vedi, non quello che il modello genera: per ridurre la spesa di pensiero, abbassa il budget o disabilita il pensiero invece. Questa impostazione non ha effetto in modalità non interattiva (`-p`), l'Agent SDK, o le estensioni IDE come VS Code	`true`
`showTurnDuration`	Mostra i messaggi di durata del turno dopo le risposte, ad es. "Cooked for 1m 6s". Predefinito: `true`. Appare in `/config` come Show turn duration	`false`
`skillListingBudgetFraction`	{/* min-version: 2.1.105 */}Frazione della finestra di contesto del modello riservata all'elenco di skills che Claude vede ogni turno (predefinito: `0.01` = 1%). Quando l'elenco supera il budget, le descrizioni per gli skills meno utilizzati vengono compresse a soli nomi in modo che Claude possa comunque invocarli ma non vedrà il motivo. Aumenta per mantenere più descrizioni visibili al costo di più contesto per turno. `/doctor` mostra il conteggio di troncamento corrente e quali skills sono interessati. Richiede Claude Code v2.1.105 o successivo	`0.02`
`skillOverrides`	{/* min-version: 2.1.129 */}Override di visibilità per skill, con chiave il nome dello skill. Il valore è `"on"`, `"name-only"`, `"user-invocable-only"`, o `"off"`. Ti consente di nascondere o comprimere uno skill senza modificare il suo SKILL.md. Non si applica ai plugin skills, che vengono gestiti tramite `/plugin`. Il menu `/skills` scrive questi in `.claude/settings.local.json`. Vedi Override della visibilità dello skill dalle impostazioni. Richiede Claude Code v2.1.129 o successivo	`{"legacy-context": "name-only", "deploy": "off"}`
`skipWebFetchPreflight`	Salta il controllo di sicurezza del dominio WebFetch che invia ogni hostname richiesto a `api.anthropic.com` prima del recupero. Imposta a `true` negli ambienti che bloccano il traffico verso Anthropic, come le distribuzioni Bedrock, Vertex AI, o Foundry con egress restrittivo. Quando saltato, WebFetch tenta qualsiasi URL senza consultare l'elenco di blocco	`true`
`spinnerTipsEnabled`	Mostra suggerimenti nello spinner mentre Claude sta lavorando. Imposta a `false` per disabilitare i suggerimenti (predefinito: `true`)	`false`
`spinnerTipsOverride`	Ignora i suggerimenti dello spinner con stringhe personalizzate. `tips`: array di stringhe di suggerimento. `excludeDefault`: se `true`, mostra solo suggerimenti personalizzati; se `false` o assente, i suggerimenti personalizzati vengono uniti ai suggerimenti incorporati	`{ "excludeDefault": true, "tips": ["Use our internal tool X"] }`
`spinnerVerbs`	Personalizza i verbi di azione mostrati mentre un turno è in corso. Imposta `mode` a `"replace"` per utilizzare solo i tuoi verbi, o `"append"` per aggiungerli ai predefiniti	`{"mode": "append", "verbs": ["Pondering", "Crafting"]}`
`sshConfigs`	Connessioni SSH da mostrare nel menu a discesa dell'ambiente Desktop. Ogni voce richiede `id`, `name` e `sshHost`; `sshPort`, `sshIdentityFile` e `startDirectory` sono facoltativi. Quando impostato nelle impostazioni gestite, le connessioni sono di sola lettura per gli utenti. Letto solo dalle impostazioni gestite e utente	`[{"id": "dev-vm", "name": "Dev VM", "sshHost": "user@dev.example.com"}]`
`statusLine`	Configura una status line personalizzata per visualizzare il contesto. Vedi documentazione `statusLine`	`{"type": "command", "command": "~/.claude/statusline.sh"}`
`strictKnownMarketplaces`	(Solo impostazioni gestite) Elenco di autorizzazione dei marketplace dei plugin. Non definito = nessuna restrizione, array vuoto = blocco. Applicato all'aggiunta del marketplace e all'installazione, aggiornamento, aggiornamento e auto-aggiornamento del plugin, quindi un marketplace aggiunto prima che la politica fosse impostata non può essere utilizzato per recuperare i plugin. Vedi Restrizioni del marketplace gestito	`[{ "source": "github", "repo": "acme-corp/plugins" }]`
`strictPluginOnlyCustomization`	(Solo impostazioni gestite) Blocca skills, agenti, hooks e MCP server dalle fonti utente e di progetto, in modo che possano provenire solo da plugin o impostazioni gestite. `true` blocca tutti e quattro; un array blocca solo quelli denominati. Vedi `strictPluginOnlyCustomization`	`["skills", "hooks"]`
`syntaxHighlightingDisabled`	Disabilita l'evidenziazione della sintassi nei diff, nei blocchi di codice e nelle anteprime dei file	`true`
`teammateMode`	Come i compagni di squadra del team di agenti vengono visualizzati: `auto` (sceglie riquadri divisi in tmux o iTerm2, in-process altrimenti), `in-process`, o `tmux` (sceglie riquadri divisi usando tmux o iTerm2, rilevato dal tuo terminale). `--teammate-mode` ignora questo per una sessione. Vedi scegli una modalità di visualizzazione	`"in-process"`
`terminalProgressBarEnabled`	Mostra la barra di avanzamento del terminale nei terminali supportati: ConEmu, Ghostty 1.2.0+, e iTerm2 3.6.6+. Predefinito: `true`. Appare in `/config` come Terminal progress bar	`false`
`theme`	{/* min-version: 2.1.119 /}Tema di colore per l'interfaccia: `"auto"`, `"dark"`, `"light"`, `"dark-daltonized"`, `"light-daltonized"`, `"dark-ansi"`, `"light-ansi"`, o un riferimento a tema personalizzato come `"custom:<slug>"` o `"custom:<plugin-name>:<slug>"`. Predefinito: `"dark"`. Vedi Crea un tema personalizzato. Appare in `/config` come Theme*	`"dark"`
`tui`	Renderer dell'interfaccia utente del terminale. Usa `"fullscreen"` per il renderer alt-screen senza sfarfallio con scrollback virtualizzato. Usa `"default"` per il renderer classico della schermata principale. Imposta tramite `/tui`. Puoi anche impostare la variabile di ambiente `CLAUDE_CODE_NO_FLICKER`	`"fullscreen"`
`ultracode`	Attiva ultracode per la sessione. Solo per sessione e non letto da `settings.json`. Imposta tramite `/effort ultracode`, `--settings`, o una richiesta di controllo dell'Agent SDK	`true`
`useAutoModeDuringPlan`	Se la modalità piano utilizza la semantica della modalità auto quando la modalità auto è disponibile. Predefinito: `true`. Non letto dalle impostazioni di progetto condivise. Appare in `/config` come "Use auto mode during plan"	`false`
`verbose`	{/* min-version: 2.1.119 /}Mostra l'output completo dello strumento invece dei riassunti troncati. Predefinito: `false`. Appare in `/config` come Verbose output*. Il flag `--verbose` ignora questo per una sessione	`true`
`viewMode`	Modalità di visualizzazione della trascrizione predefinita all'avvio: `"default"`, `"verbose"`, o `"focus"`. Ignora la selezione sticky `/focus` quando impostato. Il flag `--verbose` ignora questo per una sessione	`"verbose"`
`voice`	Impostazioni della dettatura vocale: `enabled` attiva la dettatura, `mode` seleziona `"hold"` o `"tap"`, e `autoSubmit` invia il prompt al rilascio del tasto in modalità hold. Scritto automaticamente quando esegui `/voice`. Richiede un account Claude.ai	`{ "enabled": true, "mode": "tap" }`
`voiceEnabled`	Alias legacy per `voice.enabled`. Preferisci l'oggetto `voice`	`true`
`wheelScrollAccelerationEnabled`	{/* min-version: 2.1.174 */}Nel rendering fullscreen, accelera la velocità di scorrimento della rotella del mouse durante gli scorrimenti veloci. Predefinito: `true`. Imposta a `false` per una velocità di scorrimento costante per tacca della rotella. Richiede Claude Code v2.1.174 o successivo	`false`
`workflowKeywordTriggerEnabled`	{/* min-version: 2.1.157 /}Se la parola chiave `ultracode` in un prompt attiva un flusso di lavoro dinamico. Imposta a `false` per digitare la parola senza attivarne uno. L'impostazione ultracode, `/workflows`, e i comandi di flusso di lavoro salvati non sono interessati. Predefinito: `true`. Appare in `/config` come Ultracode keyword trigger*. Aggiunto in v2.1.157; prima di v2.1.160 la parola chiave di attivazione era `workflow`	`false`
`wslInheritsWindowsSettings`	(Solo impostazioni gestite Windows) Quando `true`, Claude Code su WSL legge le impostazioni gestite dalla catena di politiche Windows in aggiunta a `/etc/claude-code`, con le fonti Windows che hanno priorità. Onorato solo quando impostato nella chiave di registro HKLM o in `C:\Program Files\ClaudeCode\managed-settings.json`, entrambi richiedono privilegi di amministratore Windows per scrivere. Affinché la politica HKCU si applichi anche su WSL, il flag deve essere impostato anche in HKCU stesso. Non ha effetto su Windows nativo	`true`

Impostazioni di configurazione globale

Queste impostazioni sono archiviate in ~/.claude.json piuttosto che in settings.json. Aggiungerle a settings.json attiverà un errore di convalida dello schema.

Chiave	Descrizione	Esempio
`autoConnectIde`	Connettiti automaticamente a un IDE in esecuzione quando Claude Code si avvia da un terminale esterno. Predefinito: `false`. Appare in `/config` come Auto-connect to IDE (external terminal) quando eseguito al di fuori di un terminale VS Code o JetBrains. La variabile di ambiente `CLAUDE_CODE_AUTO_CONNECT_IDE` ignora questo quando impostata	`true`
`autoInstallIdeExtension`	Installa automaticamente l'estensione IDE di Claude Code quando eseguito da un terminale VS Code. Predefinito: `true`. Appare in `/config` come Auto-install IDE extension quando eseguito all'interno di un terminale VS Code o JetBrains. Puoi anche impostare la variabile di ambiente `CLAUDE_CODE_IDE_SKIP_AUTO_INSTALL`	`false`
`externalEditorContext`	Prependi la risposta precedente di Claude come contesto commentato con `#` quando apri l'editor esterno con `Ctrl+G`. Predefinito: `false`. Appare in `/config` come Show last response in external editor	`true`
`teammateDefaultModel`	Modello predefinito per i compagni di squadra del team di agenti quando il prompt di spawn non ne specifica uno. Imposta a un alias di modello come `"sonnet"`, o `null` per ereditare la selezione `/model` corrente del lead. Appare in `/config` come Default teammate model	`"sonnet"`

Impostazioni worktree

Configura come --worktree crea e gestisce i git worktrees.

Chiave	Descrizione	Esempio
`worktree.baseRef`	Quale ref i nuovi worktrees si diramano da. `"fresh"` (predefinito) si dirama da `origin/<default-branch>` per un albero pulito che corrisponde al remoto. `"head"` si dirama dal tuo `HEAD` locale corrente, quindi i commit non spinti e lo stato del ramo di funzionalità sono presenti nel worktree. Si applica a `--worktree`, lo strumento `EnterWorktree`, e l'isolamento del subagent	`"head"`
`worktree.symlinkDirectories`	Directory da collegare simbolicamente dal repository principale in ogni worktree per evitare di duplicare grandi directory su disco. Nessuna directory viene collegata simbolicamente per impostazione predefinita	`["node_modules", ".cache"]`
`worktree.sparsePaths`	Directory da estrarre in ogni worktree tramite git sparse-checkout. Solo i percorsi elencati più i file a livello di radice vengono scritti su disco, il che è più veloce nei grandi monorepo	`["packages/my-app", "shared/utils"]`
`worktree.bgIsolation`	{/* min-version: 2.1.143 */}Modalità di isolamento per le sessioni in background. `"worktree"` (predefinito) blocca `Edit`/`Write` nel checkout principale fino a quando non viene chiamato `EnterWorktree`. `"none"` consente ai lavori in background di modificare direttamente la copia di lavoro. Richiede Claude Code v2.1.143 o successivo	`"none"`

Per copiare file gitignored come .env nei nuovi worktrees, usa un file .worktreeinclude nella radice del tuo progetto invece di un'impostazione.

Impostazioni di permesso

Chiavi	Descrizione	Esempio
`allow`	Array di regole di permesso per consentire l'uso dello strumento. I glob dei nomi degli strumenti sono supportati solo nella posizione dello strumento dopo un prefisso letterale `mcp__<server>__`, come `mcp__github__get_*`; il segmento del server deve essere privo di glob. Vedi Sintassi della regola di permesso sottostante per i dettagli della corrispondenza dei modelli	`[ "Bash(git diff *)" ]`
`ask`	Array di regole di permesso per chiedere conferma all'uso dello strumento. Vedi Sintassi della regola di permesso sottostante	`[ "Bash(git push *)" ]`
`deny`	Array di regole di permesso per negare l'uso dello strumento. Usa questo per escludere file sensibili dall'accesso di Claude Code. I nomi degli strumenti accettano modelli glob: `""` nega ogni strumento e `"mcp__"` nega tutti gli strumenti MCP. Vedi Sintassi della regola di permesso e Limitazioni dei permessi Bash	`[ "WebFetch", "Bash(curl )", "Read(./.env)", "Read(./secrets/*)" ]`
`additionalDirectories`	Directory di lavoro aggiuntive per l'accesso ai file. La maggior parte della configurazione `.claude/` non viene scoperta da queste directory	`[ "../docs/" ]`
`defaultMode`	Modalità di permesso predefinita quando si apre Claude Code. Valori validi: `default`, `acceptEdits`, `plan`, `auto`, `dontAsk`, `bypassPermissions`. {/* min-version: 2.1.142 */}A partire da Claude Code v2.1.142, `auto` viene ignorato quando impostato nelle impostazioni di progetto o locale (`.claude/settings.json`, `.claude/settings.local.json`) in modo che un repository non possa concedere a se stesso la modalità auto. Impostalo invece in `~/.claude/settings.json`. Il flag CLI `--permission-mode` ignora questa impostazione per una singola sessione	`"acceptEdits"`
`disableBypassPermissionsMode`	Imposta a `"disable"` per prevenire l'attivazione della modalità `bypassPermissions`. Disabilita il flag della riga di comando `--dangerously-skip-permissions`. Molto utile nelle impostazioni gestite per applicare la politica organizzativa, ma funziona da qualsiasi ambito	`"disable"`
`skipDangerousModePermissionPrompt`	Salta il prompt di conferma mostrato prima di entrare nella modalità bypass dei permessi tramite `--dangerously-skip-permissions` o `defaultMode: "bypassPermissions"`. Ignorato quando impostato nelle impostazioni di progetto (`.claude/settings.json`) per prevenire che i repository non attendibili ignorino automaticamente il prompt	`true`

Sintassi della regola di permesso

Le regole di permesso seguono il formato Tool o Tool(specifier). Le regole vengono valutate in ordine: prima le regole di negazione, poi di richiesta, poi di autorizzazione. La prima regola corrispondente determina il risultato indipendentemente dalla specificità della regola. Vedi l'ordine di valutazione della regola di permesso per i dettagli.

Esempi rapidi:

Regola	Effetto
`Bash`	Corrisponde a tutti i comandi Bash
`Bash(npm run *)`	Corrisponde ai comandi che iniziano con `npm run`
`Read(./.env)`	Corrisponde alla lettura del file `.env`
`WebFetch(domain:example.com)`	Corrisponde alle richieste di fetch a example.com

Per il riferimento completo della sintassi delle regole, incluso il comportamento dei caratteri jolly, i modelli specifici dello strumento per Read, Edit, WebFetch, MCP e Agent, e le limitazioni di sicurezza dei modelli Bash, vedi Sintassi della regola di permesso.

Impostazioni sandbox

Configura il comportamento avanzato del sandboxing. Il sandboxing isola i comandi bash dal tuo filesystem e dalla rete. Vedi Sandboxing per i dettagli.

Chiavi	Descrizione	Esempio
`enabled`	Abilita il sandboxing bash (macOS, Linux e WSL2). Predefinito: false	`true`
`failIfUnavailable`	Esci con un errore all'avvio se `sandbox.enabled` è true ma la sandbox non può avviarsi (dipendenze mancanti, piattaforma non supportata). Quando false (predefinito), viene mostrato un avviso e i comandi vengono eseguiti senza sandbox. Destinato alle distribuzioni di impostazioni gestite che richiedono il sandboxing come gate rigido	`true`
`autoAllowBashIfSandboxed`	Approva automaticamente i comandi bash quando sandboxed. Predefinito: true	`true`
`excludedCommands`	Comandi che dovrebbero essere eseguiti al di fuori della sandbox	`["docker *"]`
`allowUnsandboxedCommands`	Consenti ai comandi di essere eseguiti al di fuori della sandbox tramite il parametro `dangerouslyDisableSandbox`. Quando impostato a `false`, la scappatoia `dangerouslyDisableSandbox` è completamente disabilitata e tutti i comandi devono essere sandboxed (o essere in `excludedCommands`). Utile per le politiche aziendali che richiedono un sandboxing rigoroso. Predefinito: true	`false`
`filesystem.allowWrite`	Percorsi aggiuntivi dove i comandi sandboxed possono scrivere. Gli array vengono uniti in tutti gli ambiti di impostazioni: i percorsi utente, progetto e gestiti vengono combinati, non sostituiti. Anche uniti con i percorsi dalle regole di permesso `Edit(...)` allow. Vedi prefissi di percorso sottostante.	`["/tmp/build", "~/.kube"]`
`filesystem.denyWrite`	Percorsi dove i comandi sandboxed non possono scrivere. Gli array vengono uniti in tutti gli ambiti di impostazioni. Anche uniti con i percorsi dalle regole di permesso `Edit(...)` deny.	`["/etc", "/usr/local/bin"]`
`filesystem.denyRead`	Percorsi dove i comandi sandboxed non possono leggere. Gli array vengono uniti in tutti gli ambiti di impostazioni. Anche uniti con i percorsi dalle regole di permesso `Read(...)` deny.	`["~/.aws/credentials"]`
`filesystem.allowRead`	Percorsi per consentire nuovamente la lettura all'interno delle regioni `denyRead`. Ha la precedenza su `denyRead`. Gli array vengono uniti in tutti gli ambiti di impostazioni. Usa questo per creare modelli di accesso in lettura solo per l'area di lavoro.	`["."]`
`filesystem.allowManagedReadPathsOnly`	(Solo impostazioni gestite) Solo i percorsi `filesystem.allowRead` dalle impostazioni gestite sono rispettati. `denyRead` si unisce comunque da tutte le fonti. Predefinito: false	`true`
`network.allowUnixSockets`	(Solo macOS) Percorsi dei socket Unix accessibili nella sandbox. Ignorato su Linux e WSL2, dove il filtro seccomp non può ispezionare i percorsi dei socket; usa `allowAllUnixSockets` invece.	`["~/.ssh/agent-socket"]`
`network.allowAllUnixSockets`	Consenti tutte le connessioni ai socket Unix nella sandbox. Su Linux e WSL2 questo è l'unico modo per consentire i socket Unix, poiché salta il filtro seccomp che altrimenti blocca le chiamate `socket(AF_UNIX, ...)`. Predefinito: false	`true`
`network.allowLocalBinding`	Consenti il binding alle porte localhost (solo macOS). Predefinito: false	`true`
`network.allowMachLookup`	Nomi di servizi XPC/Mach aggiuntivi che la sandbox può cercare (solo macOS). Supporta un singolo `*` finale per la corrispondenza del prefisso. Necessario per gli strumenti che comunicano tramite XPC come il simulatore iOS o Playwright.	`["com.apple.coresimulator.*"]`
`network.allowedDomains`	Array di domini da consentire per il traffico di rete in uscita. Supporta i caratteri jolly (ad es., `*.example.com`).	`["github.com", "*.npmjs.org"]`
`network.deniedDomains`	Array di domini da bloccare per il traffico di rete in uscita. Supporta la stessa sintassi dei caratteri jolly di `allowedDomains`. Ha la precedenza su `allowedDomains` quando entrambi corrispondono. Unito da tutte le fonti di impostazioni indipendentemente da `allowManagedDomainsOnly`.	`["sensitive.cloud.example.com"]`
`network.allowManagedDomainsOnly`	(Solo impostazioni gestite) Solo `allowedDomains` e le regole allow `WebFetch(domain:...)` dalle impostazioni gestite sono rispettate. I domini dalle impostazioni utente, progetto e locale vengono ignorati. I domini non consentiti vengono bloccati automaticamente senza richiedere all'utente. I domini negati vengono comunque rispettati da tutte le fonti. Predefinito: false	`true`
`network.httpProxyPort`	Porta del proxy HTTP utilizzata se desideri portare il tuo proxy. Se non specificato, Claude eseguirà il suo proxy.	`8080`
`network.socksProxyPort`	Porta del proxy SOCKS5 utilizzata se desideri portare il tuo proxy. Se non specificato, Claude eseguirà il suo proxy.	`8081`
`enableWeakerNestedSandbox`	Abilita una sandbox più debole per gli ambienti Docker senza privilegi (solo Linux e WSL2). Riduce la sicurezza. Predefinito: false	`true`
`enableWeakerNetworkIsolation`	(Solo macOS) Consenti l'accesso al servizio di fiducia TLS del sistema (`com.apple.trustd.agent`) nella sandbox. Richiesto affinché gli strumenti basati su Go come `gh`, `gcloud` e `terraform` verifichino i certificati TLS quando si utilizza `httpProxyPort` con un proxy MITM e una CA personalizzata. Riduce la sicurezza aprendo un potenziale percorso di esfiltrazione dei dati. Predefinito: false	`true`
`bwrapPath`	(Solo impostazioni gestite, Linux/WSL2) Percorso assoluto al binario bubblewrap (`bwrap`). Ignora il rilevamento automatico tramite `PATH`. Onorato solo dalle impostazioni gestite, non dalle impostazioni utente o di progetto. Utile quando `bwrap` è installato in una posizione non standard negli ambienti gestiti.	`/opt/admin/bwrap`
`socatPath`	(Solo impostazioni gestite, Linux/WSL2) Percorso assoluto al binario `socat` utilizzato per il proxy di rete della sandbox. Ignora il rilevamento automatico tramite `PATH`. Onorato solo dalle impostazioni gestite.	`/opt/admin/socat`

Prefissi di percorso sandbox

I percorsi in filesystem.allowWrite, filesystem.denyWrite, filesystem.denyRead e filesystem.allowRead supportano questi prefissi:

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 di progetto, o a `~/.claude` per le impostazioni utente	`./output` in `.claude/settings.json` si risolve in `<project-root>/output`

Il prefisso più vecchio //path per i percorsi assoluti funziona ancora. Se in precedenza hai utilizzato il singolo slash /path aspettandoti una risoluzione relativa al progetto, passa a ./path. Questa sintassi differisce dalle regole di permesso Read e Edit, che utilizzano //path per assoluto e /path per relativo al progetto. I percorsi del filesystem sandbox utilizzano convenzioni standard: /tmp/build è un percorso assoluto.

Esempio di configurazione:

{
  "sandbox": {
    "enabled": true,
    "autoAllowBashIfSandboxed": true,
    "excludedCommands": ["docker *"],
    "filesystem": {
      "allowWrite": ["/tmp/build", "~/.kube"],
      "denyRead": ["~/.aws/credentials"]
    },
    "network": {
      "allowedDomains": ["github.com", "*.npmjs.org", "registry.yarnpkg.com"],
      "deniedDomains": ["uploads.github.com"],
      "allowUnixSockets": [
        "/var/run/docker.sock"
      ],
      "allowLocalBinding": true
    }
  }
}

Le restrizioni del filesystem e della rete possono essere configurate in due modi che vengono uniti insieme:

Impostazioni sandbox.filesystem (mostrate sopra): Controllano i percorsi al confine della sandbox a livello di sistema operativo. Queste restrizioni si applicano a tutti i comandi dei sottoprocessi (ad es., kubectl, terraform, npm), non solo agli strumenti di file di Claude.
Regole di permesso: Usa le regole allow/deny Edit per controllare l'accesso dello strumento di file di Claude, le regole deny Read per bloccare le letture, e le regole allow/deny WebFetch per controllare i domini di rete. I percorsi da queste regole vengono anche uniti nella configurazione della sandbox.

Impostazioni di attribuzione

Claude Code aggiunge attribuzione ai commit git e alle pull request. Questi vengono configurati separatamente:

I commit utilizzano i git trailers (come Co-Authored-By) per impostazione predefinita, che possono essere personalizzati o disabilitati
Le descrizioni delle pull request sono testo semplice

Chiavi	Descrizione
`commit`	Attribuzione per i commit git, inclusi eventuali trailer. La stringa vuota nasconde l'attribuzione del commit
`pr`	Attribuzione per le descrizioni delle pull request. La stringa vuota nasconde l'attribuzione della pull request

Attribuzione predefinita del commit:

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Il nome del modello nel trailer riflette il modello attivo per la sessione.

Attribuzione predefinita della pull request:

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Esempio:

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

Impostazioni di suggerimento file

Configura un comando personalizzato per l'autocompletamento del percorso del file @. Il suggerimento di file incorporato utilizza l'attraversamento veloce del filesystem, ma i grandi monorepo potrebbero beneficiare dell'indicizzazione specifica del progetto come un indice di file pre-costruito o strumenti personalizzati.

{
  "fileSuggestion": {
    "type": "command",
    "command": "~/.claude/file-suggestion.sh"
  }
}

Il comando viene eseguito con le stesse variabili di ambiente degli hooks, incluso CLAUDE_PROJECT_DIR. Riceve JSON tramite stdin con un campo query:

{"query": "src/comp"}

Restituisci i percorsi dei file separati da newline a stdout (attualmente limitati a 15):

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

Esempio:

#!/bin/bash
query=$(cat | jq -r '.query')
# Sostituisci your-repo-file-index con il tuo comando di ricerca file
your-repo-file-index --query "$query" | head -20

L'impostazione footerLinksRegexes renderizza badge cliccabili extra nel footer sotto la casella di input. Usalo per trasformare gli ID stampati dai CLI del progetto, come strumenti di revisione e tracker di problemi, in link di sessione.

Ogni voce del pattern regex viene confrontata con l'output del turno: risultati degli strumenti, inclusi contenuti di file e pagine recuperate, e le risposte di Claude stesso. I placeholder {name} in url e label vengono riempiti dai gruppi di cattura denominati nel pattern.

L'esempio seguente renderizza un badge ogni volta che appare una chiave di problema come PROJ-1234 nell'output del turno. Il gruppo denominato (?<key>...) cattura la chiave, e {key} la sostituisce nell'URL e nell'etichetta:

{
  "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 chip PROJ-1234 appare nel footer collegato a https://issues.example.com/browse/PROJ-1234.

I seguenti vincoli si applicano a ogni voce:

Vincolo	Comportamento
Origine URL	I valori catturati sono codificati in URL e l'URL costruito deve condividere l'origine letterale del modello. Una cattura può riempire un segmento di percorso o un valore di query ma non può cambiare dove punta il link
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	Predefinito al testo corrispondente e viene troncato a 28 colonne di visualizzazione
Conteggio badge	Al massimo 5 badge vengono renderizzati. Il più vecchio viene spostato dai nuovi match e `/clear` li rimuove
Ambito impostazioni	Letto dalle impostazioni utente, dal flag `--settings`, e dalle impostazioni gestite solo. Ignorato in `.claude/settings.json` e `.claude/settings.local.json` del progetto

Quando un turno si completa, Claude Code confronta ogni voce del pattern regex con l'output del turno sul thread principale, quindi un regex lento blocca l'interfaccia utente fino al completamento. I quantificatori annidati come (a+)+$ possono richiedere un tempo esponenziale rispetto a certi input e bloccare la sessione, quindi mantieni ogni pattern lineare ed evita di annidare + o *.

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

Configurazione hook

Queste impostazioni controllano quali hook possono essere eseguiti e a cosa possono accedere gli hook HTTP. L'impostazione allowManagedHooksOnly può essere configurata solo nelle impostazioni gestite. Gli elenchi di autorizzazione degli URL e delle variabili di ambiente possono essere impostati a qualsiasi livello di impostazioni e si uniscono tra le fonti.

Comportamento quando allowManagedHooksOnly è true:

Gli hook gestiti e gli hook SDK vengono caricati
Gli hook dai plugin forzatamente abilitati nelle impostazioni gestite enabledPlugins vengono caricati. Questo consente agli amministratori di distribuire hook controllati tramite un marketplace organizzativo mentre blocca tutto il resto. La fiducia viene concessa dall'ID completo plugin@marketplace, quindi un plugin con lo stesso nome da un marketplace diverso rimane bloccato
Gli hook utente, di progetto e di tutti gli altri plugin vengono bloccati

Limita gli URL degli hook HTTP:

Limita quali URL gli hook HTTP possono indirizzare. Supporta * come carattere jolly per la corrispondenza. Quando l'array è definito, gli hook HTTP che indirizzano URL non corrispondenti vengono silenziosamente bloccati. La corrispondenza del nome host non distingue tra maiuscole e minuscole e ignora un punto FQDN finale, corrispondendo alla semantica DNS.

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

Limita le variabili di ambiente degli hook HTTP:

Limita quali nomi di variabili di ambiente gli hook HTTP possono interpolare nei valori delle intestazioni. L'allowedEnvVars effettivo di ogni hook è l'intersezione del suo elenco e di questa impostazione.

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

Calcola le impostazioni gestite con un policy helper

L'impostazione policyHelper punta a un eseguibile che calcola le impostazioni gestite all'avvio, in modo che gli amministratori possano derivare la politica dalla postura del dispositivo, dall'identità o da un servizio remoto invece di un file statico. Configuralo da MDM o da un file managed-settings.json di sistema. Claude Code ignora policyHelper quando appare in qualsiasi altro ambito, incluse le impostazioni utente, le impostazioni di progetto, l'hive di registro HKCU e le impostazioni gestite dal server.

L'impostazione accetta queste chiavi:

Chiave	Tipo	Descrizione
`path`	string	Percorso assoluto all'eseguibile helper
`timeoutMs`	number	Quanto tempo attendere l'helper prima di trattare l'esecuzione come non riuscita
`refreshIntervalMs`	number	Con quale frequenza ri-eseguire l'helper in background. Imposta a `0` per disabilitare l'aggiornamento, o a almeno `60000`

L'helper scrive un envelope JSON a stdout. Metti le impostazioni sotto una chiave managedSettings piuttosto che al livello superiore, poiché un oggetto di impostazioni nudo analizza con managedSettings non definito e non applica nulla:

{
  "managedSettings": {
    "permissions": { "deny": ["Read(//etc/secrets/**)"] }
  },
  "claudeMd": "# Organization context\n...",
  "appendSystemPrompt": "Always cite the internal style guide."
}

Quando l'helper emette managedSettings, quell'oggetto sostituisce le impostazioni gestite basate su file per l'esecuzione. Quando l'helper esce con codice non zero all'avvio, Claude Code stampa l'errore e rifiuta di avviarsi, quindi un helper che ha bisogno di resilienza di interruzione dovrebbe servire dalla sua cache e uscire con 0.

Precedenza delle impostazioni

Le impostazioni si applicano in ordine di precedenza. Dal più alto al più basso:

Impostazioni gestite (gestite dal server, politiche MDM/a livello di sistema operativo, o impostazioni gestite)
- Politiche distribuite da IT tramite consegna dal server, profili di configurazione MDM, politiche di registro, o file di impostazioni gestite
- Non possono essere ignorate da nessun altro livello, inclusi gli argomenti della riga di comando
- All'interno del livello gestito, la precedenza è: gestite dal server > politiche MDM/a livello di sistema operativo > file-based (managed-settings.d/*.json + managed-settings.json) > registro HKCU (solo Windows). Viene utilizzata una sola fonte gestita; le fonti non si uniscono tra i livelli. All'interno del livello file-based, i file drop-in e il file base vengono uniti insieme.
- Gli host di incorporamento come Claude Desktop possono fornire politica tramite l'opzione SDK managedSettings. Per impostazione predefinita, questo viene ignorato quando è presente un livello gestito. Gli amministratori possono acconsentire impostando parentSettingsBehavior a "merge". I valori dell'embedder vengono filtrati in modo che possano stringere la politica gestita ma non allentarla.
Argomenti della riga di comando
- Override temporanei per una sessione specifica. JSON passato tramite --settings <file-or-json> si unisce con le impostazioni basate su file utilizzando le stesse regole degli altri livelli: una chiave impostata qui ignora la stessa chiave nelle impostazioni locale, di progetto o utente, e omettere una chiave lascia il valore del livello inferiore in posizione
Impostazioni di progetto locale (.claude/settings.local.json)
- Impostazioni personali specifiche del progetto
Impostazioni di progetto condivise (.claude/settings.json)
- Impostazioni di progetto condivise dal team nel controllo del codice sorgente
Impostazioni utente (~/.claude/settings.json)
- Impostazioni globali personali

Questa gerarchia garantisce che le politiche organizzative siano sempre applicate mentre consente comunque ai team e agli individui di personalizzare la loro esperienza. La stessa precedenza si applica se esegui Claude Code dalla CLI, dall'estensione VS Code, o da un IDE JetBrains.

Ad esempio, se le tue impostazioni utente impostano permissions.defaultMode a acceptEdits e le impostazioni condivise di un progetto lo impostano a default, il valore del progetto si applica. L'esempio sottostante copre come le impostazioni con valore di array come le regole di permesso si combinano invece.

Note

Le impostazioni di array si uniscono tra gli ambiti. Quando la stessa impostazione con valore di array (come sandbox.filesystem.allowWrite o permissions.allow) appare in più ambiti, gli array vengono concatenati e deduplicati, non sostituiti. Ciò significa che gli ambiti con priorità inferiore possono aggiungere voci senza ignorare quelle impostate da ambiti con priorità più alta, e viceversa. Ad esempio, se le impostazioni gestite impostano allowWrite a ["/opt/company-tools"] e un utente aggiunge ["~/.kube"], entrambi i percorsi sono inclusi nella configurazione finale. Due eccezioni: fallbackModel, una catena ordinata dove la posizione ha significato in modo che il file con la precedenza più alta che la definisce fornisce l'intero valore, e {/* min-version: 2.1.175 */}a partire da v2.1.175, availableModels, dove un valore gestito o di politica sostituisce completamente le voci con precedenza inferiore. Vedi Comportamento di unione.

Verifica le impostazioni attive

Esegui /status dentro Claude Code per vedere quali fonti di impostazioni sono attive. All'interno del menu, la scheda Status include una riga Setting sources che elenca ogni livello Claude Code ha caricato per la sessione corrente, come User settings o Project local settings. Quando le impostazioni gestite sono in vigore, la voce mostra il canale di distribuzione tra parentesi, ad esempio Enterprise managed settings (remote), (plist), (HKLM), (HKCU), o (file). Un livello appare nell'elenco solo quando quella fonte viene caricata con almeno una chiave, quindi un elenco vuoto significa che non sono state trovate fonti di impostazioni.

La riga Setting sources conferma quali fonti vengono lette. Non mostra quale livello ha fornito ogni singola chiave. La scheda Config nello stesso dialogo è un editor per un insieme fisso di interruttori come tema e output dettagliato, non una visualizzazione dei contenuti del tuo settings.json.

Se un file di impostazioni contiene errori, come JSON non valido o un valore che non supera la convalida, Claude Code mostra un avviso di problemi di configurazione all'avvio e /status elenca i file interessati. Esegui /doctor per i dettagli di ogni errore.

Punti chiave sul sistema di configurazione

File di memoria (CLAUDE.md): Contengono istruzioni e contesto che Claude carica all'avvio
File di impostazioni (JSON): Configurano permessi, variabili di ambiente e comportamento dello strumento
Skills: Prompt personalizzati che possono essere invocati con /skill-name o caricati automaticamente da Claude
MCP server: Estendono Claude Code con strumenti e integrazioni aggiuntivi
Precedenza: Le configurazioni di livello superiore (Managed) ignorano quelle di livello inferiore (User/Project)
Ereditarietà: Le impostazioni vengono unite tra gli ambiti; i valori scalari da ambiti con priorità più alta ignorano, e gli array si concatenano. Eccezioni: fallbackModel, dove l'ambito con la precedenza più alta fornisce l'intera catena, e availableModels, dove un valore gestito o di politica sostituisce le voci con precedenza inferiore

Prompt di sistema

Il prompt di sistema interno di Claude Code non è pubblicato. Per aggiungere istruzioni personalizzate, usa i file CLAUDE.md o il flag --append-system-prompt.

Esclusione di file sensibili

Per prevenire che Claude Code acceda a file contenenti informazioni sensibili come chiavi API, segreti e file di ambiente, usa l'impostazione permissions.deny nel tuo file .claude/settings.json:

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

Questo sostituisce la configurazione deprecata ignorePatterns. I file che corrispondono a questi modelli vengono esclusi dalla scoperta dei file e dai risultati della ricerca, e le operazioni di lettura su questi file vengono negate.

Configurazione subagent

Claude Code supporta subagent AI personalizzati che possono essere configurati sia a livello utente che di progetto. Questi subagent vengono archiviati come file Markdown con frontmatter YAML:

Subagent utente: ~/.claude/agents/ - Disponibili in tutti i tuoi progetti
Subagent di progetto: .claude/agents/ - Specifici del tuo progetto e possono essere condivisi con il tuo team

I file subagent definiscono assistenti AI specializzati con prompt personalizzati e permessi degli strumenti. Scopri di più sulla creazione e l'utilizzo dei subagent nella documentazione dei subagent.

Configurazione plugin

Claude Code supporta un sistema di plugin che ti consente di estendere la funzionalità con skills, agenti, hooks e MCP servers. I plugin vengono distribuiti tramite marketplace e possono essere configurati sia a livello utente che di repository.

Impostazioni plugin

Impostazioni relative ai plugin in settings.json:

{
  "enabledPlugins": {
    "formatter@acme-tools": true,
    "deployer@acme-tools": true,
    "analyzer@security-plugins": false
  },
  "extraKnownMarketplaces": {
    "acme-tools": {
      "source": {
        "source": "github",
        "repo": "acme-corp/claude-plugins"
      }
    }
  }
}

`enabledPlugins`

Controlla quali plugin sono abilitati. Formato: "plugin-name@marketplace-name": true/false. Un plugin senza voce in nessun ambito ricade al suo valore defaultEnabled.

Ambiti:

Impostazioni utente (~/.claude/settings.json): Preferenze personali dei plugin
Impostazioni di progetto (.claude/settings.json): Plugin specifici del progetto condivisi con il team
Impostazioni locali (.claude/settings.local.json): Override per macchina, gitignored quando Claude Code lo crea
Impostazioni gestite (managed-settings.json): Override della politica a livello organizzativo che blocca l'installazione in tutti gli ambiti e nasconde il plugin dal marketplace

Esempio:

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

`extraKnownMarketplaces`

Definisce marketplace aggiuntivi che dovrebbero essere resi disponibili per il repository. Tipicamente utilizzato nelle impostazioni a livello di repository per garantire che i membri del team abbiano accesso alle fonti di plugin richieste.

Quando un repository include extraKnownMarketplaces:

I membri del team vengono invitati a installare il marketplace quando fidano della cartella
I membri del team vengono quindi invitati a installare i plugin da quel marketplace
Gli utenti possono saltare i marketplace o i plugin indesiderati (archiviati nelle impostazioni utente)
L'installazione rispetta i confini di fiducia e richiede il consenso esplicito

Esempio:

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

Tipi di fonte del marketplace:

github: Repository GitHub (utilizza repo)
git: Qualsiasi URL git (utilizza url)
directory: Percorso del filesystem locale (utilizza path, solo per lo sviluppo)
hostPattern: Modello regex per abbinare gli host del marketplace (utilizza hostPattern)
settings: marketplace inline dichiarato direttamente in settings.json senza un repository ospitato separato (utilizza name e plugins)

Il tipo di fonte git funziona con qualsiasi servizio di hosting git, inclusi GitLab e Bitbucket self-hosted. Claude Code clona il repository con la stessa autenticazione che git clone utilizzerebbe su quella macchina: helper di credenziali configurati, chiavi SSH o una variabile di ambiente token specifica dell'host. 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. Utilizza questa opzione quando il repository contiene grandi oggetti LFS non correlati al contenuto del plugin. {/* min-version: 2.1.153 */}Richiede Claude Code v2.1.153 o successivo.

Ogni voce del marketplace accetta anche un Boolean autoUpdate facoltativo. Imposta "autoUpdate": true insieme a source per fare in modo che Claude Code aggiorni quel marketplace e aggiorni i suoi plugin installati all'avvio. Se omesso, i marketplace ufficiali di Anthropic predefiniti a true e tutti gli altri marketplace predefiniti a false. Vedi Configura gli aggiornamenti automatici.

Usa source: 'settings' per dichiarare un piccolo set di plugin inline senza configurare un repository marketplace ospitato. I plugin elencati qui devono fare riferimento a fonti esterne come GitHub o npm. Devi comunque abilitare ogni plugin separatamente in enabledPlugins.

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

`strictKnownMarketplaces`

Solo impostazioni gestite: Controlla quali marketplace dei plugin gli utenti possono aggiungere e installare plugin da. Questa impostazione può essere configurata solo nelle impostazioni gestite e fornisce agli amministratori un controllo rigoroso sulle fonti del marketplace.

Posizioni dei file di impostazioni gestite:

macOS: /Library/Application Support/ClaudeCode/managed-settings.json
Linux e WSL: /etc/claude-code/managed-settings.json
Windows: C:\Program Files\ClaudeCode\managed-settings.json

Caratteristiche chiave:

Disponibile solo nelle impostazioni gestite (managed-settings.json)
Non può essere ignorato da impostazioni utente o di progetto (precedenza più alta)
Applicato PRIMA delle operazioni di rete/filesystem (le fonti bloccate non vengono mai eseguite)
Utilizza la corrispondenza esatta per le specifiche della fonte (incluso ref, path per le fonti git), tranne hostPattern e pathPattern, che utilizzano la corrispondenza regex

Comportamento dell'elenco di autorizzazione:

undefined (predefinito): Nessuna restrizione - gli utenti possono aggiungere qualsiasi marketplace
Array vuoto []: Blocco completo - gli utenti non possono aggiungere nuovi marketplace
Elenco di fonti: Gli utenti possono aggiungere solo i marketplace che corrispondono esattamente

Tutti i tipi di fonte supportati:

L'elenco di autorizzazione supporta più tipi di fonte del marketplace. La maggior parte delle fonti utilizza la corrispondenza esatta, mentre hostPattern e pathPattern utilizzano la corrispondenza regex rispetto all'host del marketplace e al percorso del filesystem rispettivamente.

Repository GitHub:

{ "source": "github", "repo": "acme-corp/approved-plugins" }
{ "source": "github", "repo": "acme-corp/security-tools", "ref": "v2.0" }
{ "source": "github", "repo": "acme-corp/plugins", "ref": "main", "path": "marketplace" }

Campi: repo (obbligatorio), ref (facoltativo: ramo/tag/SHA), path (facoltativo: sottodirectory)

Repository Git:

{ "source": "git", "url": "https://gitlab.example.com/tools/plugins.git" }
{ "source": "git", "url": "https://bitbucket.org/acme-corp/plugins.git", "ref": "production" }
{ "source": "git", "url": "ssh://git@git.example.com/plugins.git", "ref": "v3.1", "path": "approved" }

Campi: url (obbligatorio), ref (facoltativo: ramo/tag/SHA), path (facoltativo: sottodirectory)

Marketplace basati su URL:

{ "source": "url", "url": "https://plugins.example.com/marketplace.json" }
{ "source": "url", "url": "https://cdn.example.com/marketplace.json", "headers": { "Authorization": "Bearer ${TOKEN}" } }

Campi: url (obbligatorio), headers (facoltativo: intestazioni HTTP per l'accesso autenticato)

Pacchetti NPM:

{ "source": "npm", "package": "@acme-corp/claude-plugins" }
{ "source": "npm", "package": "@acme-corp/approved-marketplace" }

Campi: package (obbligatorio, supporta pacchetti con scope)

Percorsi di file:

{ "source": "file", "path": "/usr/local/share/claude/acme-marketplace.json" }
{ "source": "file", "path": "/opt/acme-corp/plugins/marketplace.json" }

Campi: path (obbligatorio: percorso assoluto al file marketplace.json)

Percorsi di directory:

{ "source": "directory", "path": "/usr/local/share/claude/acme-plugins" }
{ "source": "directory", "path": "/opt/acme-corp/approved-marketplaces" }

Campi: path (obbligatorio: percorso assoluto alla directory contenente .claude-plugin/marketplace.json)

Corrispondenza del modello host:

{ "source": "hostPattern", "hostPattern": "^github\\.example\\.com$" }
{ "source": "hostPattern", "hostPattern": "^gitlab\\.internal\\.example\\.com$" }

Campi: hostPattern (obbligatorio: modello regex per abbinare l'host del marketplace)

Utilizza la corrispondenza del modello host quando desideri consentire tutti i marketplace da un host specifico senza enumerare ogni repository individualmente. Questo è utile per le organizzazioni con server GitHub Enterprise o GitLab interni dove gli sviluppatori creano i loro marketplace.

Estrazione dell'host per tipo di fonte:

github: corrisponde sempre a github.com
git: estrae il nome host dall'URL (supporta sia i formati HTTPS che SSH)
url: estrae il nome host dall'URL
npm, file, directory: non supportati per la corrispondenza del modello host

Corrispondenza del modello di percorso:

{ "source": "pathPattern", "pathPattern": "^/opt/approved/" }
{ "source": "pathPattern", "pathPattern": ".*" }

Campi: pathPattern (obbligatorio: modello regex abbinato al campo path delle fonti file e directory)

Utilizza la corrispondenza del modello di percorso per consentire marketplace basati su filesystem insieme alle restrizioni hostPattern per le fonti di rete. Imposta ".*" per consentire tutti i percorsi locali, o un modello più ristretto per limitare a directory specifiche.

Esempi di configurazione:

Esempio: consenti solo marketplace specifici:

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

Esempio - Disabilita tutte le aggiunte del marketplace:

{
  "strictKnownMarketplaces": []
}

Esempio: consenti tutti i marketplace da un server git interno:

{
  "strictKnownMarketplaces": [
    {
      "source": "hostPattern",
      "hostPattern": "^github\\.example\\.com$"
    }
  ]
}

Requisiti di corrispondenza esatta:

Le fonti del marketplace devono corrispondere esattamente affinché l'aggiunta di un utente sia consentita. Per le fonti basate su git (github e git), questo include tutti i campi facoltativi:

Il repo o url deve corrispondere esattamente
Il campo ref deve corrispondere esattamente (o entrambi non essere definiti)
Il campo path deve corrispondere esattamente (o entrambi non essere definiti)

Esempi di fonti che NON corrispondono:

// Queste sono DIVERSE fonti:
{ "source": "github", "repo": "acme-corp/plugins" }
{ "source": "github", "repo": "acme-corp/plugins", "ref": "main" }

// Anche queste sono DIVERSE:
{ "source": "github", "repo": "acme-corp/plugins", "path": "marketplace" }
{ "source": "github", "repo": "acme-corp/plugins" }

Confronto con extraKnownMarketplaces:

Aspetto	`strictKnownMarketplaces`	`extraKnownMarketplaces`
Scopo	Applicazione della politica organizzativa	Comodità del team
File di impostazioni	Solo `managed-settings.json`	Qualsiasi file di impostazioni
Comportamento	Blocca le aggiunte non nell'elenco di autorizzazione	Installa automaticamente i marketplace mancanti
Quando applicato	Prima delle operazioni di rete/filesystem	Dopo il prompt di fiducia dell'utente
Può essere ignorato	No (precedenza più alta)	Sì (da impostazioni con precedenza più alta)
Formato della fonte	Oggetto fonte diretto	Marketplace denominato con fonte nidificata
Caso d'uso	Conformità, restrizioni di sicurezza	Onboarding, standardizzazione

Differenza di formato:

strictKnownMarketplaces utilizza oggetti fonte diretti:

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

extraKnownMarketplaces richiede marketplace denominati:

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

Utilizzo di entrambi insieme:

strictKnownMarketplaces è un gate di politica: controlla cosa gli utenti possono aggiungere ma non registra alcun marketplace. Per limitare e pre-registrare un marketplace per tutti gli utenti, imposta entrambi in managed-settings.json:

{
  "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 il marketplace consentito manualmente tramite /plugin marketplace add, ma non è disponibile automaticamente.

Note importanti:

Le restrizioni vengono controllate PRIMA di qualsiasi richiesta di rete o operazione del filesystem
Quando bloccato, gli utenti vedono messaggi di errore chiari che indicano che la fonte è bloccata dalla politica gestita
La restrizione si applica all'aggiunta del marketplace e all'installazione, aggiornamento, aggiornamento e auto-aggiornamento dei plugin. Un marketplace aggiunto prima che la politica fosse impostata non può essere utilizzato per installare o aggiornare plugin una volta che la sua fonte non corrisponde più all'elenco di autorizzazione
Le impostazioni gestite hanno la precedenza più alta e non possono essere ignorate

Vedi Restrizioni del marketplace gestito per la documentazione rivolta agli utenti.

`strictPluginOnlyCustomization`

Solo impostazioni gestite: blocca skills, agenti, hooks e MCP servers da fonti utente e di progetto, in modo che possano provenire solo da plugin o impostazioni gestite. Combinalo con strictKnownMarketplaces per controllare l'intera catena di approvvigionamento della personalizzazione: l'elenco di autorizzazione del marketplace controlla quali plugin gli utenti possono installare, e questa impostazione blocca tutto ciò che non proviene da un plugin o dalle impostazioni gestite.

Il valore è true per bloccare tutte e quattro le superfici, oppure un array che nomina le superfici da bloccare:

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

Per ogni superficie bloccata, Claude Code salta le fonti a livello utente e di progetto e carica solo le fonti fornite da plugin e gestite:

Superficie	Bloccato quando bloccato	Continua a caricare
`skills`	`~/.claude/skills/`, `.claude/skills/`	Plugin skills, skills in bundle, skills nella directory della politica gestita
`agents`	`~/.claude/agents/`, `.claude/agents/`	Plugin agents, agenti integrati, agenti nella directory della politica gestita
`hooks`	Hooks in user, project, e local `settings.json`	Plugin hooks, hooks nelle impostazioni gestite
`mcp`	Server in `~/.claude.json` e `.mcp.json`	Plugin MCP servers, server `managed-mcp.json`

I nomi di superficie che una versione di Claude Code non riconosce vengono ignorati piuttosto che causare un errore nel file di impostazioni, quindi puoi aggiungere nuovi nomi di superficie prima che tutti i client si aggiornino.

Gestione dei plugin

Usa il comando /plugin per gestire i plugin in modo interattivo:

Sfoglia i plugin disponibili dai marketplace
Installa/disinstalla plugin
Abilita/disabilita plugin
Visualizza i dettagli del plugin (skills, agenti, hooks forniti)
Aggiungi/rimuovi marketplace

Scopri di più sul sistema di plugin nella documentazione dei plugin.

Variabili di ambiente

Le variabili di ambiente consentono di controllare il comportamento di Claude Code senza modificare i file di impostazioni. Qualsiasi variabile può anche essere configurata in settings.json sotto la chiave env per applicarla a ogni sessione o distribuirla al vostro team.

Consultare il riferimento delle variabili di ambiente per l'elenco completo.

Strumenti disponibili per Claude

Claude Code ha accesso a un set di strumenti per leggere, modificare, cercare, eseguire comandi e orchestrare subagent. I nomi degli strumenti sono le stringhe esatte che utilizzi nelle regole di permesso e nei matcher degli hook.

Vedi il riferimento degli strumenti per l'elenco completo e i dettagli del comportamento dello strumento Bash.

Vedi anche

Permissions: sistema di permessi, sintassi delle regole, modelli specifici dello strumento e politiche gestite
Authentication: configura l'accesso degli utenti a Claude Code
Debug your configuration: diagnostica il motivo per cui un'impostazione, un hook o un server MCP non sta avendo effetto
Troubleshoot installation and login: installazione, autenticazione e problemi di piattaforma

settings.md +112 −26

6 6

7> Configura Claude Code con impostazioni globali e a livello di progetto, e variabili di ambiente.7> Configura Claude Code con impostazioni globali e a livello di progetto, e variabili di ambiente.

8 8

9Claude Code offre una varietà di impostazioni per configurare il suo comportamento in base alle tue esigenze. Puoi configurare Claude Code eseguendo il comando `/config` quando utilizzi il REPL interattivo, che apre un'interfaccia Impostazioni con schede dove puoi visualizzare le informazioni di stato e modificare le opzioni di configurazione.9Claude Code offre una varietà di impostazioni per configurare il suo comportamento in base alle vostre esigenze. Potete configurare Claude Code eseguendo il comando `/config` quando utilizzate il REPL interattivo, che apre un'interfaccia Impostazioni con schede dove potete visualizzare le informazioni di stato e modificare le opzioni di configurazione.

10 10

11<h2 id="configuration-scopes">11<h2 id="configuration-scopes">

12 Ambiti di configurazione12 Ambiti di configurazione

19</h3>19</h3>

20 20

~~22| :---------- | :------------------------------------------------------------------------------------------------ | :----------------------------------------- | :--------------------- |~~22| :---------- | :------------------------------------------------------------------------------------------------ | :----------------------------------------- | :----------------------------------------- |

27 27

28<h3 id="when-to-use-each-scope">28<h3 id="when-to-use-each-scope">

29 Quando utilizzare ogni ambito29 Quando utilizzare ogni ambito

94* **Le impostazioni utente** sono definite in `~/.claude/settings.json` e si applicano a tutti i progetti.94* **Le impostazioni utente** sono definite in `~/.claude/settings.json` e si applicano a tutti i progetti.

95* **Le impostazioni di progetto** vengono salvate nella directory del tuo progetto:95* **Le impostazioni di progetto** vengono salvate nella directory del tuo progetto:

96 * `.claude/settings.json` per le impostazioni che vengono controllate nel controllo del codice sorgente e condivise con il tuo team96 * `.claude/settings.json` per le impostazioni che vengono controllate nel controllo del codice sorgente e condivise con il tuo team

97 * `.claude/settings.local.json` per le impostazioni che non vengono controllate, utili per preferenze personali e sperimentazione. Claude Code configurerà git per ignorare `.claude/settings.local.json` quando viene creato.97 * `.claude/settings.local.json` per le impostazioni che non vengono controllate, utili per preferenze personali e sperimentazione. Quando Claude Code crea `.claude/settings.local.json`, configura git per ignorare il file. Se crei il file tu stesso, aggiungilo al tuo gitignore manualmente.

98* **Impostazioni gestite**: Per le organizzazioni che necessitano di controllo centralizzato, Claude Code supporta più meccanismi di distribuzione per le impostazioni gestite. Tutti utilizzano lo stesso formato JSON e non possono essere ignorati dalle impostazioni utente o di progetto:98* **Impostazioni gestite**: Per le organizzazioni che necessitano di controllo centralizzato, Claude Code supporta più meccanismi di distribuzione per le impostazioni gestite. Tutti utilizzano lo stesso formato JSON e non possono essere ignorati dalle impostazioni utente o di progetto:

99 99

100 * **Impostazioni gestite dal server**: consegnate dai server di Anthropic tramite la console di amministrazione Claude.ai. Vedi [impostazioni gestite dal server](/it/server-managed-settings).100 * **Impostazioni gestite dal server**: consegnate dai server di Anthropic tramite la console di amministrazione Claude.ai. Vedi [impostazioni gestite dal server](/it/server-managed-settings).

174* `model`: usa [`/model`](/it/model-config#setting-your-model) per cambiare durante la sessione174* `model`: usa [`/model`](/it/model-config#setting-your-model) per cambiare durante la sessione

175* [`outputStyle`](/it/output-styles): parte del prompt di sistema, che viene ricostruito su `/clear` o riavvio175* [`outputStyle`](/it/output-styles): parte del prompt di sistema, che viene ricostruito su `/clear` o riavvio

176 176

177<h3 id="invalid-entries-in-managed-settings">

178 Voci non valide nelle impostazioni gestite

179</h3>

180

181Le impostazioni gestite analizzano in modo tollerante. Quando una configurazione gestita contiene una voce che non supera la convalida dello schema, Claude Code rimuove quella voce, registra un avviso e applica ogni politica valida rimanente. Un singolo errore di battitura non può disabilitare il resto della politica della tua organizzazione. Questo comportamento è coerente in tutti e tre i meccanismi di distribuzione: [impostazioni gestite dal server](/it/server-managed-settings), politiche plist e registro distribuite tramite MDM, e file `managed-settings.json`. Richiede Claude Code v2.1.169 o successivo.

182

183I campi di applicazione della sicurezza vengono gestiti per campo invece di essere rimossi all'ingrosso quando sono presenti ma non validi:

184

185| Campo | Comportamento quando presente ma non valido |

186| :--------------------------- | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |

187| `allowedMcpServers` | Applicato come una lista di autorizzazione vuota, quindi nessun MCP server viene ammesso fino a quando il valore non viene corretto. Una singola voce non valida viene rimossa e il sottoinsieme valido viene applicato. |

188| `allowManagedMcpServersOnly` | Trattato come `true`. |

189| `availableModels` | {/* min-version: 2.1.175 */}Applicato come una lista di autorizzazione vuota, quindi solo il modello Predefinito è disponibile fino a quando il valore non viene corretto. Una singola voce non stringa viene rimossa e il sottoinsieme valido viene applicato. Si applica in v2.1.175 e successivo. |

190| `enforceAvailableModels` | {/* min-version: 2.1.175 */}Trattato come `true`. Si applica in v2.1.175 e successivo. |

191| `forceLoginOrgUUID` | Nessuna organizzazione è autorizzata ad accedere fino a quando il valore non viene corretto. |

192| `deniedMcpServers` | Una singola voce non valida viene rimossa e il sottoinsieme valido viene applicato. Un valore completamente non valido viene eliminato con un avviso, poiché negare ogni server bloccherebbe i server che la politica non ha mai nominato. |

193

194`requiredMinimumVersion` e `requiredMaximumVersion` falliscono in modo aperto per progettazione: un valore non valido viene rimosso piuttosto che applicato, quindi una politica errata non può impedire l'avvio di Claude Code.

195

196Gli errori di convalida vengono visualizzati in tre posizioni:

197

198* Le sessioni interattive mostrano una finestra di dialogo all'avvio che elenca le voci non valide.

199* Le esecuzioni headless con `-p` stampano un riepilogo su stderr.

200* [`claude doctor`](/it/debug-your-config) elenca ogni voce non valida con la sua fonte e il campo.

201

202Convalida i cambiamenti di politica eseguendo `claude doctor` su una macchina di test prima di distribuirli su tutta la flotta.

203

204Questa tolleranza si applica solo alle impostazioni gestite. I file di impostazioni utente, progetto e locale rimangono rigorosi: un file che non supera la convalida viene rifiutato nel complesso e segnalato.

205

177<h3 id="available-settings">206<h3 id="available-settings">

178 Impostazioni disponibili207 Impostazioni disponibili

179</h3>208</h3>

181`settings.json` supporta un numero di opzioni:210`settings.json` supporta un numero di opzioni:

182 211

184| :-------------------------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | :---------------------------------------------------------------------------------------------------------------------------- |213| :-------------------------------- | :-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :------------------------------------------------------------------------------------------------------------------------------ |

214| `advisorModel` | {/* min-version: 2.1.98 */}Modello per lo [strumento advisor](/it/advisor) lato server. Accetta un alias di modello come `"opus"`, `"sonnet"`, o `"fable"` ({/* min-version: 2.1.170 */}v2.1.170+), o un ID modello completo. Scritto automaticamente quando esegui `/advisor`. Non impostato per disabilitare l'advisor. Richiede Claude Code v2.1.98 o successivo | `"opus"` |

185| `agent` | Esegui il thread principale come un subagent denominato e imposta l'agente predefinito per le sessioni inviate da `claude agents`. Applica il prompt di sistema, le restrizioni degli strumenti e il modello di quel subagent. Vedi [Invoca i subagent esplicitamente](/it/sub-agents#invoke-subagents-explicitly) | `"code-reviewer"` |215| `agent` | Esegui il thread principale come un subagent denominato e imposta l'agente predefinito per le sessioni inviate da `claude agents`. Applica il prompt di sistema, le restrizioni degli strumenti e il modello di quel subagent. Vedi [Invoca i subagent esplicitamente](/it/sub-agents#invoke-subagents-explicitly) | `"code-reviewer"` |

216| `agentPushNotifEnabled` | {/* min-version: 2.1.119 */}Quando il [Controllo remoto](/it/remote-control) è connesso, consenti a Claude di inviare notifiche push proattive al tuo telefono, ad esempio quando un'attività lunga finisce. Predefinito: `false`. Appare in `/config` come **Push when Claude decides**. Vedi [Notifiche push mobile](/it/remote-control#mobile-push-notifications). Richiede Claude Code v2.1.119 o successivo | `true` |

186| `allowAllClaudeAiMcps` | (Solo impostazioni gestite) Carica i connettori claude.ai insieme a un `managed-mcp.json` distribuito, che altrimenti assume il controllo esclusivo e li sopprime. Vedi [Configurazione MCP gestita](/it/managed-mcp) | `true` |217| `allowAllClaudeAiMcps` | (Solo impostazioni gestite) Carica i connettori claude.ai insieme a un `managed-mcp.json` distribuito, che altrimenti assume il controllo esclusivo e li sopprime. Vedi [Configurazione MCP gestita](/it/managed-mcp) | `true` |

187| `allowedChannelPlugins` | (Solo impostazioni gestite) Elenco di autorizzazione dei plugin di canale che possono inviare messaggi. Sostituisce l'elenco di autorizzazione predefinito di Anthropic quando impostato. Non definito = ricaduta al predefinito, array vuoto = blocca tutti i plugin di canale. Richiede `channelsEnabled: true`. Vedi [Limita quali plugin di canale possono essere eseguiti](/it/channels#restrict-which-channel-plugins-can-run) | `[{ "marketplace": "claude-plugins-official", "plugin": "telegram" }]` |218| `allowedChannelPlugins` | (Solo impostazioni gestite) Elenco di autorizzazione dei plugin di canale che possono inviare messaggi. Sostituisce l'elenco di autorizzazione predefinito di Anthropic quando impostato. Non definito = ricaduta al predefinito, array vuoto = blocca tutti i plugin di canale. Richiede `channelsEnabled: true`. Vedi [Limita quali plugin di canale possono essere eseguiti](/it/channels#restrict-which-channel-plugins-can-run) | `[{ "marketplace": "claude-plugins-official", "plugin": "telegram" }]` |

188| `allowedHttpHookUrls` | Elenco di autorizzazione dei modelli di URL che gli hook HTTP possono indirizzare. Supporta `*` come carattere jolly. Quando impostato, gli hook con URL non corrispondenti vengono bloccati. Non definito = nessuna restrizione, array vuoto = blocca tutti gli hook HTTP. Gli array si uniscono tra le fonti di impostazioni. Vedi [Configurazione hook](#hook-configuration) | `["https://hooks.example.com/*"]` |219| `allowedHttpHookUrls` | Elenco di autorizzazione dei modelli di URL che gli hook HTTP possono indirizzare. Supporta `*` come carattere jolly. Quando impostato, gli hook con URL non corrispondenti vengono bloccati. Non definito = nessuna restrizione, array vuoto = blocca tutti gli hook HTTP. Gli array si uniscono tra le fonti di impostazioni. Vedi [Configurazione hook](#hook-configuration) | `["https://hooks.example.com/*"]` |

190| `allowManagedHooksOnly` | (Solo impostazioni gestite) Solo gli hook gestiti, gli hook SDK e gli hook dai plugin forzatamente abilitati nelle impostazioni gestite `enabledPlugins` vengono caricati. Gli hook utente, di progetto e di tutti gli altri plugin vengono bloccati. Vedi [Configurazione hook](#hook-configuration) | `true` |221| `allowManagedHooksOnly` | (Solo impostazioni gestite) Solo gli hook gestiti, gli hook SDK e gli hook dai plugin forzatamente abilitati nelle impostazioni gestite `enabledPlugins` vengono caricati. Gli hook utente, di progetto e di tutti gli altri plugin vengono bloccati. Vedi [Configurazione hook](#hook-configuration) | `true` |

191| `allowManagedMcpServersOnly` | (Solo impostazioni gestite) Solo `allowedMcpServers` dalle impostazioni gestite sono rispettati. `deniedMcpServers` si unisce comunque da tutte le fonti. Gli utenti possono ancora aggiungere MCP server, ma si applica solo l'elenco di autorizzazione definito dall'amministratore. Vedi [Configurazione MCP gestita](/it/managed-mcp) | `true` |222| `allowManagedMcpServersOnly` | (Solo impostazioni gestite) Solo `allowedMcpServers` dalle impostazioni gestite sono rispettati. `deniedMcpServers` si unisce comunque da tutte le fonti. Gli utenti possono ancora aggiungere MCP server, ma si applica solo l'elenco di autorizzazione definito dall'amministratore. Vedi [Configurazione MCP gestita](/it/managed-mcp) | `true` |

192| `allowManagedPermissionRulesOnly` | (Solo impostazioni gestite) Previeni che le impostazioni utente e di progetto definiscano regole di permesso `allow`, `ask` o `deny`. Si applicano solo le regole nelle impostazioni gestite. Vedi [Impostazioni solo gestite](/it/permissions#managed-only-settings) | `true` |223| `allowManagedPermissionRulesOnly` | (Solo impostazioni gestite) Previeni che le impostazioni utente e di progetto definiscano regole di permesso `allow`, `ask` o `deny`. Si applicano solo le regole nelle impostazioni gestite. Vedi [Impostazioni solo gestite](/it/permissions#managed-only-settings) | `true` |

193| `alwaysThinkingEnabled` | Abilita il [pensiero esteso](/it/model-config#extended-thinking) per impostazione predefinita per tutte le sessioni. Tipicamente configurato tramite il comando `/config` piuttosto che modificato direttamente. Per forzare il pensiero disattivato indipendentemente da questa impostazione, imposta [`CLAUDE_CODE_DISABLE_THINKING`](/it/env-vars) in `env` | `true` |224| `alwaysThinkingEnabled` | Abilita il [pensiero esteso](/it/model-config#extended-thinking) per impostazione predefinita per tutte le sessioni. Tipicamente configurato tramite il comando `/config` piuttosto che modificato direttamente. Per forzare il pensiero disattivato indipendentemente da questa impostazione, imposta [`MAX_THINKING_TOKENS=0`](/it/env-vars) in `env`, che disabilita il pensiero sull'API Anthropic tranne su Fable 5, che non può avere il pensiero disattivato. Su [provider di terze parti](/it/third-party-integrations) questo omette il parametro `thinking` invece, e i modelli di ragionamento adattivo potrebbero comunque pensare | `true` |

194| `apiKeyHelper` | Script personalizzato, da eseguire in `/bin/sh`, per generare un valore di autenticazione. Questo valore verrà inviato come intestazioni `X-Api-Key` e `Authorization: Bearer` per le richieste di modello. Imposta l'intervallo di aggiornamento con [`CLAUDE_CODE_API_KEY_HELPER_TTL_MS`](/it/env-vars) | `/bin/generate_temp_api_key.sh` |225| `apiKeyHelper` | Script personalizzato, da eseguire in `/bin/sh`, per generare un valore di autenticazione. Questo valore verrà inviato come intestazioni `X-Api-Key` e `Authorization: Bearer` per le richieste di modello. Imposta l'intervallo di aggiornamento con [`CLAUDE_CODE_API_KEY_HELPER_TTL_MS`](/it/env-vars) | `/bin/generate_temp_api_key.sh` |

195| `attribution` | Personalizza l'attribuzione per i commit git e le pull request. Vedi [Impostazioni di attribuzione](#attribution-settings) | `{"commit": "🤖 Generated with Claude Code", "pr": ""}` |226| `attribution` | Personalizza l'attribuzione per i commit git e le pull request. Vedi [Impostazioni di attribuzione](#attribution-settings) | `{"commit": "🤖 Generated with Claude Code", "pr": ""}` |

227| `autoCompactEnabled` | {/* min-version: 2.1.119 */}Compatta automaticamente la conversazione quando il contesto si avvicina al limite. Predefinito: `true`. Appare in `/config` come **Auto-compact**. Per disabilitare tramite variabile di ambiente, imposta [`DISABLE_AUTO_COMPACT`](/it/env-vars) in `env` | `false` |

196| `autoMemoryDirectory` | Directory personalizzata per l'archiviazione della [memoria automatica](/it/memory#storage-location). Accetta un percorso assoluto o un percorso con prefisso `~/`. Dalle impostazioni di progetto o locale, questo viene onorato solo dopo che accetti la finestra di dialogo di fiducia dell'area di lavoro, poiché un repository clonato può fornire questo file | `"~/my-memory-dir"` |228| `autoMemoryDirectory` | Directory personalizzata per l'archiviazione della [memoria automatica](/it/memory#storage-location). Accetta un percorso assoluto o un percorso con prefisso `~/`. Dalle impostazioni di progetto o locale, questo viene onorato solo dopo che accetti la finestra di dialogo di fiducia dell'area di lavoro, poiché un repository clonato può fornire questo file | `"~/my-memory-dir"` |

197| `autoMemoryEnabled` | Abilita la [memoria automatica](/it/memory#enable-or-disable-auto-memory). Quando `false`, Claude non legge da o scrive nella directory di memoria automatica. Predefinito: `true`. Puoi anche attivare/disattivare questo con `/memory` durante una sessione. Per disabilitare tramite variabile di ambiente, imposta [`CLAUDE_CODE_DISABLE_AUTO_MEMORY`](/it/env-vars) in `env` | `false` |229| `autoMemoryEnabled` | Abilita la [memoria automatica](/it/memory#enable-or-disable-auto-memory). Quando `false`, Claude non legge da o scrive nella directory di memoria automatica. Predefinito: `true`. Puoi anche attivare/disattivare questo con `/memory` durante una sessione. Per disabilitare tramite variabile di ambiente, imposta [`CLAUDE_CODE_DISABLE_AUTO_MEMORY`](/it/env-vars) in `env` | `false` |

198| `autoMode` | Personalizza cosa il classificatore della [modalità auto](/it/permission-modes#eliminate-prompts-with-auto-mode) blocca e consente. Contiene array `environment`, `allow`, `soft_deny` e `hard_deny` di regole in prosa. Includi la stringa letterale `"$defaults"` in un array per ereditare le regole incorporate in quella posizione. Vedi [Configura la modalità auto](/it/auto-mode-config). Non letto dalle impostazioni di progetto condivise | `{"soft_deny": ["$defaults", "Never run terraform apply"]}` |230| `autoMode` | Personalizza cosa il classificatore della [modalità auto](/it/permission-modes#eliminate-prompts-with-auto-mode) blocca e consente. Contiene array `environment`, `allow`, `soft_deny` e `hard_deny` di regole in prosa. Includi la stringa letterale `"$defaults"` in un array per ereditare le regole incorporate in quella posizione. Vedi [Configura la modalità auto](/it/auto-mode-config). Non letto dalle impostazioni di progetto condivise | `{"soft_deny": ["$defaults", "Never run terraform apply"]}` |

199| `autoScrollEnabled` | Nel [rendering fullscreen](/it/fullscreen), segui il nuovo output fino al fondo della conversazione. Predefinito: `true`. Appare in `/config` come **Auto-scroll**. I prompt di permesso scorrono comunque in vista quando questo è disattivato | `false` |231| `autoScrollEnabled` | Nel [rendering fullscreen](/it/fullscreen), segui il nuovo output fino al fondo della conversazione. Predefinito: `true`. Appare in `/config` come **Auto-scroll**. I prompt di permesso scorrono comunque in vista quando questo è disattivato | `false` |

200| `autoUpdatesChannel` | Canale di rilascio da seguire per gli aggiornamenti. Usa `"stable"` per una versione che è tipicamente circa una settimana vecchia e salta le versioni con regressioni importanti, o `"latest"` (predefinito) per il rilascio più recente. Per disabilitare completamente gli auto-aggiornamenti, imposta [`DISABLE_AUTOUPDATER`](/it/setup#disable-auto-updates) in `env` | `"stable"` |232| `autoUpdatesChannel` | Canale di rilascio da seguire per gli aggiornamenti. Usa `"stable"` per una versione che è tipicamente circa una settimana vecchia e salta le versioni con regressioni importanti, o `"latest"` (predefinito) per il rilascio più recente. Per disabilitare completamente gli auto-aggiornamenti, imposta [`DISABLE_AUTOUPDATER`](/it/setup#disable-auto-updates) in `env` | `"stable"` |

201| `availableModels` | Limita quali modelli gli utenti possono selezionare tramite `/model`, `--model`, o `ANTHROPIC_MODEL`. Non influisce sull'opzione Predefinito. Vedi [Limita la selezione del modello](/it/model-config#restrict-model-selection) | `["sonnet", "haiku"]` |233| `availableModels` | Limita quali modelli gli utenti possono selezionare per la sessione principale, i [subagent](/it/sub-agents), e l'[advisor](/it/advisor). Vedi [Limita la selezione del modello](/it/model-config#restrict-model-selection). Vedi `enforceAvailableModels` per vincolare anche il modello Predefinito | `["sonnet", "haiku"]` |

202| `awaySummaryEnabled` | Mostra un riepilogo di una riga della sessione quando torni al terminale dopo alcuni minuti di assenza. Imposta a `false` o disattiva Riepilogo sessione in `/config` per disabilitare. Uguale a [`CLAUDE_CODE_ENABLE_AWAY_SUMMARY`](/it/env-vars) | `true` |234| `awaySummaryEnabled` | Mostra un riepilogo di una riga della sessione quando torni al terminale dopo alcuni minuti di assenza. Imposta a `false` o disattiva Riepilogo sessione in `/config` per disabilitare. Uguale a [`CLAUDE_CODE_ENABLE_AWAY_SUMMARY`](/it/env-vars) | `true` |

203| `awsAuthRefresh` | Script personalizzato che modifica la directory `.aws` (vedi [configurazione avanzata delle credenziali](/it/amazon-bedrock#advanced-credential-configuration)) | `aws sso login --profile myprofile` |235| `awsAuthRefresh` | Script personalizzato che modifica la directory `.aws` (vedi [configurazione avanzata delle credenziali](/it/amazon-bedrock#advanced-credential-configuration)) | `aws sso login --profile myprofile` |

204| `awsCredentialExport` | Script personalizzato che restituisce JSON con le credenziali AWS (vedi [configurazione avanzata delle credenziali](/it/amazon-bedrock#advanced-credential-configuration)) | `/bin/generate_aws_grant.sh` |236| `awsCredentialExport` | Script personalizzato che restituisce JSON con le credenziali AWS (vedi [configurazione avanzata delle credenziali](/it/amazon-bedrock#advanced-credential-configuration)) | `/bin/generate_aws_grant.sh` |

213| `disableAgentView` | Imposta a `true` per disattivare gli [agenti in background e la visualizzazione degli agenti](/it/agent-view): `claude agents`, `--bg`, `/background`, e il supervisore su richiesta. Tipicamente impostato nelle [impostazioni gestite](/it/permissions#managed-settings). Equivalente all'impostazione di `CLAUDE_CODE_DISABLE_AGENT_VIEW` a `1` | `true` |245| `disableAgentView` | Imposta a `true` per disattivare gli [agenti in background e la visualizzazione degli agenti](/it/agent-view): `claude agents`, `--bg`, `/background`, e il supervisore su richiesta. Tipicamente impostato nelle [impostazioni gestite](/it/permissions#managed-settings). Equivalente all'impostazione di `CLAUDE_CODE_DISABLE_AGENT_VIEW` a `1` | `true` |

215| `disableAutoMode` | Imposta a `"disable"` per prevenire l'attivazione della [modalità auto](/it/permission-modes#eliminate-prompts-with-auto-mode). Rimuove `auto` dal ciclo `Shift+Tab` e rifiuta `--permission-mode auto` all'avvio. Molto utile nelle [impostazioni gestite](/it/permissions#managed-settings) dove gli utenti non possono ignorarla | `"disable"` |247| `disableAutoMode` | Imposta a `"disable"` per prevenire l'attivazione della [modalità auto](/it/permission-modes#eliminate-prompts-with-auto-mode). Rimuove `auto` dal ciclo `Shift+Tab` e rifiuta `--permission-mode auto` all'avvio. Molto utile nelle [impostazioni gestite](/it/permissions#managed-settings) dove gli utenti non possono ignorarla | `"disable"` |

248| `disableBundledSkills` | Imposta a `true` per disabilitare gli [skills](/it/skills) e i flussi di lavoro che vengono forniti con Claude Code: gli skills bundled e i flussi di lavoro vengono rimossi completamente, mentre i comandi slash incorporati come `/init` rimangono digitabili ma sono nascosti dal modello. Gli skills dai plugin, `.claude/skills/`, e `.claude/commands/` non sono interessati. Equivalente all'impostazione di `CLAUDE_CODE_DISABLE_BUNDLED_SKILLS` a `1` | `true` |

216| `disableDeepLinkRegistration` | Imposta a `"disable"` per prevenire che Claude Code registri il gestore del protocollo `claude-cli://` con il sistema operativo all'avvio. I [deep link](/it/deep-links) consentono agli strumenti esterni di aprire una sessione di Claude Code con un prompt pre-compilato. Utile negli ambienti in cui la registrazione del gestore del protocollo è limitata o gestita separatamente | `"disable"` |249| `disableDeepLinkRegistration` | Imposta a `"disable"` per prevenire che Claude Code registri il gestore del protocollo `claude-cli://` con il sistema operativo all'avvio. I [deep link](/it/deep-links) consentono agli strumenti esterni di aprire una sessione di Claude Code con un prompt pre-compilato. Utile negli ambienti in cui la registrazione del gestore del protocollo è limitata o gestita separatamente | `"disable"` |

218| `disableRemoteControl` | {/* min-version: 2.1.128 */}Disabilita il [Controllo remoto](/it/remote-control): blocca `claude remote-control`, il flag `--remote-control`, l'avvio automatico e l'interruttore in-sessione. Tipicamente posizionato nelle [impostazioni gestite](/it/permissions#managed-settings) per l'applicazione MDM per dispositivo, ma funziona da qualsiasi ambito. Richiede Claude Code v2.1.128 o successivo | `true` |251| `disableRemoteControl` | {/* min-version: 2.1.128 */}Disabilita il [Controllo remoto](/it/remote-control): blocca `claude remote-control`, il flag `--remote-control`, l'avvio automatico e l'interruttore in-sessione. Tipicamente posizionato nelle [impostazioni gestite](/it/permissions#managed-settings) per l'applicazione MDM per dispositivo, ma funziona da qualsiasi ambito. Richiede Claude Code v2.1.128 o successivo | `true` |

219| `disableSkillShellExecution` | Disabilita l'esecuzione inline della shell per i blocchi `` !`...` `` e ` ```! ` nei [skills](/it/skills) e nei comandi personalizzati da fonti utente, progetto, plugin o directory aggiuntive. I comandi vengono sostituiti con `[shell command execution disabled by policy]` invece di essere eseguiti. I skills bundled e gestiti non sono interessati. Molto utile nelle [impostazioni gestite](/it/permissions#managed-settings) dove gli utenti non possono ignorarla | `true` |252| `disableSkillShellExecution` | Disabilita l'esecuzione inline della shell per i blocchi `` !`...` `` e ` ```! ` negli [skills](/it/skills) e nei comandi personalizzati da fonti utente, progetto, plugin o directory aggiuntive. I comandi vengono sostituiti con `[shell command execution disabled by policy]` invece di essere eseguiti. Gli skills bundled e gestiti non sono interessati. Molto utile nelle [impostazioni gestite](/it/permissions#managed-settings) dove gli utenti non possono ignorarla | `true` |

220| `disableWorkflows` | Disabilita i [flussi di lavoro dinamici](/it/workflows#turn-workflows-off) e i comandi di flusso di lavoro bundled. Predefinito: `false`. Equivalente all'impostazione di `CLAUDE_CODE_DISABLE_WORKFLOWS` a `1` | `true` |253| `disableWorkflows` | Disabilita i [flussi di lavoro dinamici](/it/workflows#turn-workflows-off) e i comandi di flusso di lavoro bundled. Predefinito: `false`. Equivalente all'impostazione di `CLAUDE_CODE_DISABLE_WORKFLOWS` a `1` | `true` |

221| `editorMode` | Modalità di scorciatoie da tastiera per il prompt di input: `"normal"` o `"vim"`. Predefinito: `"normal"`. Appare in `/config` come **Editor mode** | `"vim"` |254| `editorMode` | Modalità di scorciatoie da tastiera per il prompt di input: `"normal"` o `"vim"`. Predefinito: `"normal"`. Appare in `/config` come **Editor mode** | `"vim"` |

222| `effortLevel` | Persisti il [livello di sforzo](/it/model-config#adjust-effort-level) tra le sessioni. Accetta `"low"`, `"medium"`, `"high"`, o `"xhigh"`. Scritto automaticamente quando esegui `/effort` con uno di questi valori. `--effort` e [`CLAUDE_CODE_EFFORT_LEVEL`](/it/env-vars) ignorano questo per una sessione. Vedi [Regola il livello di sforzo](/it/model-config#adjust-effort-level) per i modelli supportati | `"xhigh"` |255| `effortLevel` | Persisti il [livello di sforzo](/it/model-config#adjust-effort-level) tra le sessioni. Accetta `"low"`, `"medium"`, `"high"`, o `"xhigh"`. Scritto automaticamente quando esegui `/effort` con uno di questi valori. `--effort` e [`CLAUDE_CODE_EFFORT_LEVEL`](/it/env-vars) ignorano questo per una sessione. Vedi [Regola il livello di sforzo](/it/model-config#adjust-effort-level) per i modelli supportati | `"xhigh"` |

258| `enforceAvailableModels` | {/* min-version: 2.1.175 */}Quando `true` e `availableModels` è una lista non vuota nelle impostazioni gestite o di politica, il modello Predefinito è anche vincolato all'elenco di autorizzazione. Vedi [Limita la selezione del modello](/it/model-config#restrict-model-selection) per i dettagli e il [comportamento di unione](/it/model-config#merge-behavior) quando `availableModels` è impostato a più livelli. Richiede Claude Code v2.1.175 o successivo | `true` |

225| `env` | Variabili di ambiente applicate a ogni sessione e ai sottoprocessi che Claude Code genera da essa. {/* min-version: 2.1.143 */}A partire da v2.1.143, `NO_COLOR` e `FORCE_COLOR` impostati qui vengono passati ai sottoprocessi ma non cambiano i colori dell'interfaccia di Claude Code stesso. Imposta quelli nella tua shell prima di lanciare `claude` per cambiare i colori dell'interfaccia | `{"FOO": "bar"}` |259| `env` | Variabili di ambiente applicate a ogni sessione e ai sottoprocessi che Claude Code genera da essa. {/* min-version: 2.1.143 */}A partire da v2.1.143, `NO_COLOR` e `FORCE_COLOR` impostati qui vengono passati ai sottoprocessi ma non cambiano i colori dell'interfaccia di Claude Code stesso. Imposta quelli nella tua shell prima di lanciare `claude` per cambiare i colori dell'interfaccia | `{"FOO": "bar"}` |

260| `fallbackModel` | Modello/i di fallback da provare in ordine quando il modello primario è sovraccarico o non disponibile. Claude Code passa al modello disponibile successivo nella catena per il resto del turno e mostra un avviso. `"default"` si espande al modello predefinito. Le catene sono limitate a tre modelli; le voci extra vengono ignorate. A differenza della maggior parte delle impostazioni di array, questa chiave non si unisce tra i file di impostazioni: il file con la precedenza più alta che la definisce fornisce l'intera catena. Il flag [`--fallback-model`](/it/cli-reference#cli-flags) ignora questo per una sessione. Vedi [Catene di modelli di fallback](/it/model-config#fallback-model-chains) | `["claude-sonnet-4-6", "claude-haiku-4-5"]` |

226| `fastModePerSessionOptIn` | Quando `true`, la modalità veloce non persiste tra le sessioni. Ogni sessione inizia con la modalità veloce disattivata, richiedendo agli utenti di abilitarla con `/fast`. La preferenza della modalità veloce dell'utente viene comunque salvata. Vedi [Richiedi opt-in per sessione](/it/fast-mode#require-per-session-opt-in) | `true` |261| `fastModePerSessionOptIn` | Quando `true`, la modalità veloce non persiste tra le sessioni. Ogni sessione inizia con la modalità veloce disattivata, richiedendo agli utenti di abilitarla con `/fast`. La preferenza della modalità veloce dell'utente viene comunque salvata. Vedi [Richiedi opt-in per sessione](/it/fast-mode#require-per-session-opt-in) | `true` |

227| `feedbackSurveyRate` | Probabilità (0–1) che il [sondaggio sulla qualità della sessione](/it/data-usage#session-quality-surveys) appaia quando idoneo. Imposta a `0` per sopprimere completamente, o imposta [`CLAUDE_CODE_DISABLE_FEEDBACK_SURVEY`](/it/env-vars) in `env`. Utile quando si utilizza Bedrock, Vertex, o Foundry dove il tasso di campionamento predefinito non si applica | `0.05` |262| `feedbackSurveyRate` | Probabilità (0–1) che il [sondaggio sulla qualità della sessione](/it/data-usage#session-quality-surveys) appaia quando idoneo. Imposta a `0` per sopprimere completamente, o imposta [`CLAUDE_CODE_DISABLE_FEEDBACK_SURVEY`](/it/env-vars) in `env`. Utile quando si utilizza Bedrock, Vertex, o Foundry dove il tasso di campionamento predefinito non si applica | `0.05` |

263| `fileCheckpointingEnabled` | {/* min-version: 2.1.119 */}Snapshot dei file prima di ogni edit in modo che [`/rewind`](/it/checkpointing) possa ripristinarli. Predefinito: `true`. Appare in `/config` come **Rewind code (checkpoints)**. Per disabilitare tramite variabile di ambiente, imposta [`CLAUDE_CODE_DISABLE_FILE_CHECKPOINTING`](/it/env-vars) in `env` | `false` |

228| `fileSuggestion` | Configura uno script personalizzato per l'autocompletamento dei file `@`. Vedi [Impostazioni di suggerimento file](#file-suggestion-settings) | `{"type": "command", "command": "~/.claude/file-suggestion.sh"}` |264| `fileSuggestion` | Configura uno script personalizzato per l'autocompletamento dei file `@`. Vedi [Impostazioni di suggerimento file](#file-suggestion-settings) | `{"type": "command", "command": "~/.claude/file-suggestion.sh"}` |

265| `footerLinksRegexes` | {/* min-version: 2.1.176 */}Renderizza badge cliccabili extra nel footer quando un regex corrisponde all'output del turno. Ogni voce ha un `pattern`, un modello di URL `url` con placeholder `{name}` riempiti dai gruppi di cattura denominati, e un `label` opzionale. Letto dalle impostazioni utente, dal flag `--settings`, e dalle impostazioni gestite solo. Vedi [Badge di link nel footer](#footer-link-badges) per i vincoli dell'URL, l'elenco di schemi consentiti, e i limiti. Richiede Claude Code v2.1.176 o successivo | `[{"type": "regex", "pattern": "\\b(?<key>PROJ-\\d+)\\b", "url": "https://issues.example.com/browse/{key}", "label": "{key}"}]` |

229| `forceLoginMethod` | Usa `claudeai` per limitare l'accesso agli account Claude.ai, `console` per limitare l'accesso agli account Claude Console. Quando impostato nelle impostazioni gestite, le sessioni autenticate tramite `ANTHROPIC_API_KEY`, `ANTHROPIC_AUTH_TOKEN`, o `apiKeyHelper` vengono bloccate all'avvio, poiché nessuno dei due valori può essere soddisfatto senza OAuth di prima parte. Le sessioni del provider di terze parti come Bedrock, Vertex e Foundry non vengono bloccate: si autenticano rispetto al tuo provider cloud piuttosto che ad Anthropic | `claudeai` |266| `forceLoginMethod` | Usa `claudeai` per limitare l'accesso agli account Claude.ai, `console` per limitare l'accesso agli account Claude Console. Quando impostato nelle impostazioni gestite, le sessioni autenticate tramite `ANTHROPIC_API_KEY`, `ANTHROPIC_AUTH_TOKEN`, o `apiKeyHelper` vengono bloccate all'avvio, poiché nessuno dei due valori può essere soddisfatto senza OAuth di prima parte. Le sessioni del provider di terze parti come Bedrock, Vertex e Foundry non vengono bloccate: si autenticano rispetto al tuo provider cloud piuttosto che ad Anthropic | `claudeai` |

230| `forceLoginOrgUUID` | Richiedi che l'accesso appartenga a un'organizzazione specifica di Anthropic. Accetta una singola stringa UUID, che pre-seleziona anche quell'organizzazione durante l'accesso, o un array di UUID dove qualsiasi organizzazione elencata è accettata senza pre-selezione. Quando impostato nelle impostazioni gestite, l'accesso fallisce se l'account autenticato non appartiene a un'organizzazione elencata, e le sessioni autenticate tramite `ANTHROPIC_API_KEY`, `ANTHROPIC_AUTH_TOKEN`, o `apiKeyHelper` vengono bloccate all'avvio poiché l'appartenenza all'organizzazione non può essere verificata per loro. Le sessioni del provider di terze parti come Bedrock, Vertex e Foundry non vengono bloccate: usa il tuo IAM cloud per limitare quali account cloud possono essere utilizzati. Un array vuoto fallisce in modo chiuso e blocca l'accesso con un messaggio di errore di configurazione | `"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"` o `["xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx", "yyyyyyyy-yyyy-yyyy-yyyy-yyyyyyyyyyyy"]` |267| `forceLoginOrgUUID` | Richiedi che l'accesso appartenga a un'organizzazione specifica di Anthropic. Accetta una singola stringa UUID, che pre-seleziona anche quell'organizzazione durante l'accesso, o un array di UUID dove qualsiasi organizzazione elencata è accettata senza pre-selezione. Quando impostato nelle impostazioni gestite, l'accesso fallisce se l'account autenticato non appartiene a un'organizzazione elencata, e le sessioni autenticate tramite `ANTHROPIC_API_KEY`, `ANTHROPIC_AUTH_TOKEN`, o `apiKeyHelper` vengono bloccate all'avvio poiché l'appartenenza all'organizzazione non può essere verificata per loro. Le sessioni del provider di terze parti come Bedrock, Vertex e Foundry non vengono bloccate: usa il tuo IAM cloud per limitare quali account cloud possono essere utilizzati. Un array vuoto fallisce in modo chiuso e blocca l'accesso con un messaggio di errore di configurazione | `"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"` o `["xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx", "yyyyyyyy-yyyy-yyyy-yyyy-yyyyyyyyyyyy"]` |

231| `forceRemoteSettingsRefresh` | (Solo impostazioni gestite) Blocca l'avvio della CLI fino a quando le impostazioni gestite remote non vengono recuperate di recente dal server. Se il recupero fallisce, la CLI esce invece di continuare con le impostazioni memorizzate nella cache o senza impostazioni. Quando non impostato, l'avvio continua senza attendere le impostazioni remote. Vedi [applicazione fail-closed](/it/server-managed-settings#enforce-fail-closed-startup) | `true` |268| `forceRemoteSettingsRefresh` | (Solo impostazioni gestite) Blocca l'avvio della CLI fino a quando le impostazioni gestite remote non vengono recuperate di recente dal server. Se il recupero fallisce, la CLI esce invece di continuare con le impostazioni memorizzate nella cache o senza impostazioni. Quando non impostato, l'avvio continua senza attendere le impostazioni remote. Vedi [applicazione fail-closed](/it/server-managed-settings#enforce-fail-closed-startup) | `true` |

234| `httpHookAllowedEnvVars` | Elenco di autorizzazione dei nomi delle variabili di ambiente che gli hook HTTP possono interpolare nelle intestazioni. Quando impostato, l'`allowedEnvVars` effettivo di ogni hook è l'intersezione del suo elenco e di questa impostazione. Non definito = nessuna restrizione. Gli array si uniscono tra le fonti di impostazioni. Vedi [Configurazione hook](#hook-configuration) | `["MY_TOKEN", "HOOK_SECRET"]` |271| `httpHookAllowedEnvVars` | Elenco di autorizzazione dei nomi delle variabili di ambiente che gli hook HTTP possono interpolare nelle intestazioni. Quando impostato, l'`allowedEnvVars` effettivo di ogni hook è l'intersezione del suo elenco e di questa impostazione. Non definito = nessuna restrizione. Gli array si uniscono tra le fonti di impostazioni. Vedi [Configurazione hook](#hook-configuration) | `["MY_TOKEN", "HOOK_SECRET"]` |

235| `includeCoAuthoredBy` | **Deprecato**: Usa `attribution` invece. Se includere la riga `co-authored-by Claude` nei commit git e nelle pull request (predefinito: `true`) | `false` |272| `includeCoAuthoredBy` | **Deprecato**: Usa `attribution` invece. Se includere la riga `co-authored-by Claude` nei commit git e nelle pull request (predefinito: `true`) | `false` |

236| `includeGitInstructions` | Includi le istruzioni integrate del flusso di lavoro di commit e PR e lo snapshot dello stato git nel prompt di sistema di Claude (predefinito: `true`). Imposta a `false` per rimuovere entrambi, ad esempio quando utilizzi le tue skill di flusso di lavoro git. La variabile di ambiente `CLAUDE_CODE_DISABLE_GIT_INSTRUCTIONS` ha la precedenza su questa impostazione quando impostata | `false` |273| `includeGitInstructions` | Includi le istruzioni integrate del flusso di lavoro di commit e PR e lo snapshot dello stato git nel prompt di sistema di Claude (predefinito: `true`). Imposta a `false` per rimuovere entrambi, ad esempio quando utilizzi le tue skill di flusso di lavoro git. La variabile di ambiente `CLAUDE_CODE_DISABLE_GIT_INSTRUCTIONS` ha la precedenza su questa impostazione quando impostata | `false` |

237| `language` | Configura la lingua di risposta preferita di Claude (ad es., `"japanese"`, `"spanish"`, `"french"`). Claude risponderà in questa lingua per impostazione predefinita. Imposta anche la lingua della [dettatura vocale](/it/voice-dictation#change-the-dictation-language) | `"japanese"` |274| `inputNeededNotifEnabled` | {/* min-version: 2.1.119 */}Quando il [Controllo remoto](/it/remote-control) è connesso, invia una notifica push al tuo telefono quando un prompt di permesso o una domanda è in attesa del tuo input. Predefinito: `false`. Appare in `/config` come **Push when actions required**. Vedi [Notifiche push mobile](/it/remote-control#mobile-push-notifications). Richiede Claude Code v2.1.119 o successivo | `true` |

275| `language` | Configura la lingua di risposta preferita di Claude (ad es., `"japanese"`, `"spanish"`, `"french"`). Claude risponderà in questa lingua per impostazione predefinita. Imposta anche la lingua della [dettatura vocale](/it/voice-dictation#change-the-dictation-language) e dei titoli di sessione generati automaticamente. {/* min-version: 2.1.176 */}A partire da v2.1.176, quando non impostato, i titoli delle sessioni corrispondono alla lingua della tua conversazione | `"japanese"` |

238| `maxSkillDescriptionChars` | {/* min-version: 2.1.105 */}Limite di caratteri per skill sul testo combinato `description` e `when_to_use` nell'[elenco di skills](/it/skills#skill-descriptions-are-cut-short) che Claude vede ogni turno (predefinito: `1536`). Il testo più lungo di questo viene troncato. Aumenta per mantenere le descrizioni lunghe intatte al costo di più contesto per turno; riduci per adattare più skills sotto [`skillListingBudgetFraction`](#available-settings). Richiede Claude Code v2.1.105 o successivo | `2048` |276| `maxSkillDescriptionChars` | {/* min-version: 2.1.105 */}Limite di caratteri per skill sul testo combinato `description` e `when_to_use` nell'[elenco di skills](/it/skills#skill-descriptions-are-cut-short) che Claude vede ogni turno (predefinito: `1536`). Il testo più lungo di questo viene troncato. Aumenta per mantenere le descrizioni lunghe intatte al costo di più contesto per turno; riduci per adattare più skills sotto [`skillListingBudgetFraction`](#available-settings). Richiede Claude Code v2.1.105 o successivo | `2048` |

239| `minimumVersion` | Floor che previene l'auto-aggiornamento in background e `claude update` dall'installazione di una versione al di sotto di questa. Passare dal canale `"latest"` a `"stable"` tramite `/config` ti chiede di rimanere sulla versione corrente o di consentire il downgrade. Scegliere di rimanere imposta questo valore. Utile anche nelle [impostazioni gestite](/it/permissions#managed-settings) per fissare un minimo a livello organizzativo | `"2.1.100"` |277| `minimumVersion` | Floor che previene l'auto-aggiornamento in background e `claude update` dall'installazione di una versione al di sotto di questa. Passare dal canale `"latest"` a `"stable"` tramite `/config` ti chiede di rimanere sulla versione corrente o di consentire il downgrade. Scegliere di rimanere imposta questo valore. Utile anche nelle [impostazioni gestite](/it/permissions#managed-settings) per fissare un minimo a livello organizzativo. Per un floor rigido che blocca completamente l'avvio, vedi `requiredMinimumVersion` | `"2.1.100"` |

240| `model` | Ignora il modello predefinito da utilizzare per Claude Code. `--model` e [`ANTHROPIC_MODEL`](/it/model-config#environment-variables) ignorano questo per una sessione | `"claude-sonnet-4-6"` |278| `model` | Ignora il modello predefinito da utilizzare per Claude Code. `--model` e [`ANTHROPIC_MODEL`](/it/model-config#environment-variables) ignorano questo per una sessione | `"claude-sonnet-4-6"` |

241| `modelOverrides` | Mappa gli ID dei modelli Anthropic agli ID dei modelli specifici del provider come gli ARN del profilo di inferenza Bedrock. Ogni voce del selettore di modello utilizza il suo valore mappato quando chiama l'API del provider. Vedi [Ignora gli ID dei modelli per versione](/it/model-config#override-model-ids-per-version) | `{"claude-opus-4-6": "arn:aws:bedrock:..."}` |279| `modelOverrides` | Mappa gli ID dei modelli Anthropic agli ID dei modelli specifici del provider come gli ARN del profilo di inferenza Bedrock. Ogni voce del selettore di modello utilizza il suo valore mappato quando chiama l'API del provider. Vedi [Ignora gli ID dei modelli per versione](/it/model-config#override-model-ids-per-version) | `{"claude-opus-4-6": "arn:aws:bedrock:..."}` |

242| `otelHeadersHelper` | Script per generare intestazioni OpenTelemetry dinamiche. Viene eseguito all'avvio e periodicamente. Imposta l'intervallo di aggiornamento con [`CLAUDE_CODE_OTEL_HEADERS_HELPER_DEBOUNCE_MS`](/it/env-vars). Vedi [Intestazioni dinamiche](/it/monitoring-usage#dynamic-headers) | `/bin/generate_otel_headers.sh` |280| `otelHeadersHelper` | Script per generare intestazioni OpenTelemetry dinamiche. Viene eseguito all'avvio e periodicamente. Imposta l'intervallo di aggiornamento con [`CLAUDE_CODE_OTEL_HEADERS_HELPER_DEBOUNCE_MS`](/it/env-vars). Vedi [Intestazioni dinamiche](/it/monitoring-usage#dynamic-headers) | `/bin/generate_otel_headers.sh` |

244| `parentSettingsBehavior` | {/* min-version: 2.1.133 */}(Solo impostazioni gestite) Controlla se le impostazioni gestite fornite programmaticamente da un processo host di incorporamento, come l'Agent SDK o un'estensione IDE, si applicano quando è presente anche un livello gestito distribuito da un amministratore. `"first-wins"`: le impostazioni fornite dal parent vengono eliminate e si applica solo il livello amministrativo. `"merge"`: le impostazioni fornite dal parent si applicano sotto il livello amministrativo, filtrate in modo che possano stringere la politica ma non allentarla. Non ha effetto quando non è distribuito alcun livello amministrativo. Predefinito: `"first-wins"`. Richiede Claude Code v2.1.133 o successivo | `"merge"` |282| `parentSettingsBehavior` | {/* min-version: 2.1.133 */}(Solo impostazioni gestite) Controlla se le impostazioni gestite fornite programmaticamente da un processo host di incorporamento, come l'Agent SDK o un'estensione IDE, si applicano quando è presente anche un livello gestito distribuito da un amministratore. `"first-wins"`: le impostazioni fornite dal parent vengono eliminate e si applica solo il livello amministrativo. `"merge"`: le impostazioni fornite dal parent si applicano sotto il livello amministrativo, filtrate in modo che possano stringere la politica ma non allentarla. Non ha effetto quando non è distribuito alcun livello amministrativo. Predefinito: `"first-wins"`. Richiede Claude Code v2.1.133 o successivo | `"merge"` |

246| `plansDirectory` | Personalizza dove vengono archiviati i file di piano. Il percorso è relativo alla radice del progetto. Predefinito: `~/.claude/plans` | `"./plans"` |284| `plansDirectory` | Personalizza dove vengono archiviati i file di piano. Il percorso è relativo alla radice del progetto. Predefinito: `~/.claude/plans` | `"./plans"` |

247| `pluginSuggestionMarketplaces` | (Solo impostazioni gestite) Nomi dei marketplace i cui plugin possono apparire come suggerimenti di installazione contestuali, oltre al marketplace ufficiale. I suggerimenti provengono dalla dichiarazione `relevance` di ogni plugin nella sua voce del marketplace. Un nome ha effetto solo quando il marketplace è registrato sulla macchina e la sua fonte registrata è anche dichiarata nelle impostazioni gestite, come voce `extraKnownMarketplaces` per quel nome o come voce di `strictKnownMarketplaces`. Un marketplace registrato da una fonte diversa con un nome nella lista di autorizzazione viene ignorato. | `["acme-corp-plugins"]` |285| `pluginSuggestionMarketplaces` | (Solo impostazioni gestite) Nomi dei marketplace i cui plugin possono apparire come suggerimenti di installazione contestuali. Nessun suggerimento dichiarato dal marketplace viene visualizzato senza questo elenco di autorizzazione; il suggerimento incorporato di design frontend di prima parte non è interessato. I suggerimenti provengono dalla dichiarazione `relevance` di ogni plugin nella sua voce del marketplace. Un nome ha effetto solo quando il marketplace è registrato sulla macchina e la sua fonte registrata è anche dichiarata nelle impostazioni gestite, come voce `extraKnownMarketplaces` per quel nome o come voce di `strictKnownMarketplaces`. Un marketplace registrato da una fonte diversa con un nome nella lista di autorizzazione viene ignorato. Il marketplace ufficiale è esente dal requisito della fonte: autorizzare il suo nome da solo è sufficiente, poiché quel nome può registrarsi solo dalla fonte Anthropic ufficiale. | `["acme-corp-plugins"]` |

248| `pluginTrustMessage` | (Solo impostazioni gestite) Messaggio personalizzato aggiunto all'avviso di fiducia del plugin mostrato prima dell'installazione. Usa questo per aggiungere contesto specifico dell'organizzazione, ad esempio per confermare che i plugin dal tuo marketplace interno sono controllati. | `"All plugins from our marketplace are approved by IT"` |286| `pluginTrustMessage` | (Solo impostazioni gestite) Messaggio personalizzato aggiunto all'avviso di fiducia del plugin mostrato prima dell'installazione. Usa questo per aggiungere contesto specifico dell'organizzazione, ad esempio per confermare che i plugin dal tuo marketplace interno sono controllati. | `"All plugins from our marketplace are approved by IT"` |

249| `policyHelper` | {/* min-version: 2.1.136 */}Eseguibile distribuito dall'amministratore che calcola le impostazioni gestite dinamicamente all'avvio. Onorato solo da MDM o da un file `managed-settings.json` di sistema. Vedi [Calcola le impostazioni gestite con un policy helper](#compute-managed-settings-with-a-policy-helper). Richiede Claude Code v2.1.136 o successivo | `{"path": "/usr/local/bin/claude-policy"}` |287| `policyHelper` | {/* min-version: 2.1.136 */}Eseguibile distribuito dall'amministratore che calcola le impostazioni gestite dinamicamente all'avvio. Onorato solo da MDM o da un file `managed-settings.json` di sistema. Vedi [Calcola le impostazioni gestite con un policy helper](#compute-managed-settings-with-a-policy-helper). Richiede Claude Code v2.1.136 o successivo | `{"path": "/usr/local/bin/claude-policy"}` |

250| `preferredNotifChannel` | Metodo per le notifiche di completamento attività e prompt di permesso: `"auto"`, `"terminal_bell"`, `"iterm2"`, `"iterm2_with_bell"`, `"kitty"`, `"ghostty"`, o `"notifications_disabled"`. Predefinito: `"auto"`, che invia una notifica desktop in iTerm2, Ghostty e Kitty e non fa nulla in altri terminali. Imposta `"terminal_bell"` per suonare il carattere di campanello in qualsiasi terminale. Appare in `/config` come **Notifications**. Vedi [Ottieni un campanello del terminale o una notifica](/it/terminal-config#get-a-terminal-bell-or-notification) | `"terminal_bell"` |288| `preferredNotifChannel` | Metodo per le notifiche di completamento attività e prompt di permesso: `"auto"`, `"terminal_bell"`, `"iterm2"`, `"iterm2_with_bell"`, `"kitty"`, `"ghostty"`, o `"notifications_disabled"`. Predefinito: `"auto"`, che invia una notifica desktop in iTerm2, Ghostty e Kitty e non fa nulla in altri terminali. Imposta `"terminal_bell"` per suonare il carattere di campanello in qualsiasi terminale. Appare in `/config` come **Notifications**. Vedi [Ottieni un campanello del terminale o una notifica](/it/terminal-config#get-a-terminal-bell-or-notification) | `"terminal_bell"` |

252| `prUrlTemplate` | Modello di URL per il badge PR mostrato nel footer e nei riassunti dei risultati degli strumenti. Sostituisce `{host}`, `{owner}`, `{repo}`, `{number}`, e `{url}` dall'URL PR segnalato da `gh`. Usa per puntare i link PR a uno strumento di revisione del codice interno invece di `github.com`. Non influisce sui link automatici `#123` nella prosa di Claude | `"https://reviews.example.com/{owner}/{repo}/pull/{number}"` |290| `prUrlTemplate` | Modello di URL per il badge PR mostrato nel footer e nei riassunti dei risultati degli strumenti. Sostituisce `{host}`, `{owner}`, `{repo}`, `{number}`, e `{url}` dall'URL PR segnalato da `gh`. Usa per puntare i link PR a uno strumento di revisione del codice interno invece di `github.com`. Non influisce sui link automatici `#123` nella prosa di Claude | `"https://reviews.example.com/{owner}/{repo}/pull/{number}"` |

291| `requiredMaximumVersion` | Solo impostazioni gestite. Versione massima di Claude Code consentita per l'avvio. Se la versione in esecuzione è più recente, Claude Code esce all'avvio e istruisce l'utente a installare una versione approvata tramite il metodo approvato dell'organizzazione; `claude install <version>` potrebbe anche funzionare. L'auto-aggiornamento in background e `claude update` saltano le versioni sopra il limite, quindi un'installazione in intervallo rimane in intervallo. `claude update`, `claude install`, e `claude doctor` continuano a funzionare sopra il limite in modo che gli utenti possano recuperare. Le versioni che precedono questa impostazione la ignorano | `"2.1.150"` |

292| `requiredMinimumVersion` | Solo impostazioni gestite. Versione minima di Claude Code richiesta per l'avvio. Se la versione in esecuzione è più vecchia, Claude Code esce all'avvio e istruisce l'utente ad aggiornare tramite il metodo approvato dell'organizzazione. `claude update`, `claude install`, e `claude doctor` continuano a funzionare sotto il limite in modo che gli utenti possano recuperare. Differisce da `minimumVersion`, che previene i downgrade ma non blocca mai l'avvio. Le versioni che precedono questa impostazione la ignorano | `"2.1.150"` |

253| `respectGitignore` | Controlla se il selettore di file `@` rispetta i modelli `.gitignore`. Quando `true` (predefinito), i file che corrispondono ai modelli `.gitignore` sono esclusi dai suggerimenti | `false` |293| `respectGitignore` | Controlla se il selettore di file `@` rispetta i modelli `.gitignore`. Quando `true` (predefinito), i file che corrispondono ai modelli `.gitignore` sono esclusi dai suggerimenti | `false` |

254| `showClearContextOnPlanAccept` | Mostra l'opzione "cancella contesto" nella schermata di accettazione del piano. Predefinito: `false`. Imposta a `true` per ripristinare l'opzione | `true` |294| `showClearContextOnPlanAccept` | Mostra l'opzione "cancella contesto" nella schermata di accettazione del piano. Predefinito: `false`. Imposta a `true` per ripristinare l'opzione | `true` |

255| `showThinkingSummaries` | Mostra i riassunti del [pensiero esteso](/it/model-config#extended-thinking) nelle sessioni interattive. Quando non impostato o `false` (predefinito in modalità interattiva), i blocchi di pensiero vengono redatti dall'API e mostrati come uno stub compresso. La redazione cambia solo quello che vedi, non quello che il modello genera: per ridurre la spesa di pensiero, [abbassa il budget o disabilita il pensiero](/it/model-config#extended-thinking) invece. Questa impostazione non ha effetto in modalità non interattiva (`-p`), l'Agent SDK, o le estensioni IDE come VS Code | `true` |295| `showThinkingSummaries` | Mostra i riassunti del [pensiero esteso](/it/model-config#extended-thinking) nelle sessioni interattive. Quando non impostato o `false` (predefinito in modalità interattiva), i blocchi di pensiero vengono redatti dall'API e mostrati come uno stub compresso. La redazione cambia solo quello che vedi, non quello che il modello genera: per ridurre la spesa di pensiero, [abbassa il budget o disabilita il pensiero](/it/model-config#extended-thinking) invece. Questa impostazione non ha effetto in modalità non interattiva (`-p`), l'Agent SDK, o le estensioni IDE come VS Code | `true` |

265| `strictKnownMarketplaces` | (Solo impostazioni gestite) Elenco di autorizzazione dei marketplace dei plugin. Non definito = nessuna restrizione, array vuoto = blocco. Applicato all'aggiunta del marketplace e all'installazione, aggiornamento, aggiornamento e auto-aggiornamento del plugin, quindi un marketplace aggiunto prima che la politica fosse impostata non può essere utilizzato per recuperare i plugin. Vedi [Restrizioni del marketplace gestito](/it/plugin-marketplaces#managed-marketplace-restrictions) | `[{ "source": "github", "repo": "acme-corp/plugins" }]` |305| `strictKnownMarketplaces` | (Solo impostazioni gestite) Elenco di autorizzazione dei marketplace dei plugin. Non definito = nessuna restrizione, array vuoto = blocco. Applicato all'aggiunta del marketplace e all'installazione, aggiornamento, aggiornamento e auto-aggiornamento del plugin, quindi un marketplace aggiunto prima che la politica fosse impostata non può essere utilizzato per recuperare i plugin. Vedi [Restrizioni del marketplace gestito](/it/plugin-marketplaces#managed-marketplace-restrictions) | `[{ "source": "github", "repo": "acme-corp/plugins" }]` |

266| `strictPluginOnlyCustomization` | (Solo impostazioni gestite) Blocca skills, agenti, hooks e MCP server dalle fonti utente e di progetto, in modo che possano provenire solo da plugin o impostazioni gestite. `true` blocca tutti e quattro; un array blocca solo quelli denominati. Vedi [`strictPluginOnlyCustomization`](#strictpluginonlycustomization) | `["skills", "hooks"]` |306| `strictPluginOnlyCustomization` | (Solo impostazioni gestite) Blocca skills, agenti, hooks e MCP server dalle fonti utente e di progetto, in modo che possano provenire solo da plugin o impostazioni gestite. `true` blocca tutti e quattro; un array blocca solo quelli denominati. Vedi [`strictPluginOnlyCustomization`](#strictpluginonlycustomization) | `["skills", "hooks"]` |

268| `teammateMode` | Come i compagni di squadra del [team di agenti](/it/agent-teams) vengono visualizzati: `auto` (sceglie riquadri divisi in tmux o iTerm2, in-process altrimenti), `in-process`, o `tmux`. `--teammate-mode` ignora questo per una sessione. Vedi [scegli una modalità di visualizzazione](/it/agent-teams#choose-a-display-mode) | `"in-process"` |308| `teammateMode` | Come i compagni di squadra del [team di agenti](/it/agent-teams) vengono visualizzati: `auto` (sceglie riquadri divisi in tmux o iTerm2, in-process altrimenti), `in-process`, o `tmux` (sceglie riquadri divisi usando tmux o iTerm2, rilevato dal tuo terminale). `--teammate-mode` ignora questo per una sessione. Vedi [scegli una modalità di visualizzazione](/it/agent-teams#choose-a-display-mode) | `"in-process"` |

269| `terminalProgressBarEnabled` | Mostra la barra di avanzamento del terminale nei terminali supportati: ConEmu, Ghostty 1.2.0+, e iTerm2 3.6.6+. Predefinito: `true`. Appare in `/config` come **Terminal progress bar** | `false` |309| `terminalProgressBarEnabled` | Mostra la barra di avanzamento del terminale nei terminali supportati: ConEmu, Ghostty 1.2.0+, e iTerm2 3.6.6+. Predefinito: `true`. Appare in `/config` come **Terminal progress bar** | `false` |

310| `theme` | {/* min-version: 2.1.119 */}Tema di colore per l'interfaccia: `"auto"`, `"dark"`, `"light"`, `"dark-daltonized"`, `"light-daltonized"`, `"dark-ansi"`, `"light-ansi"`, o un riferimento a tema personalizzato come `"custom:<slug>"` o `"custom:<plugin-name>:<slug>"`. Predefinito: `"dark"`. Vedi [Crea un tema personalizzato](/it/terminal-config#create-a-custom-theme). Appare in `/config` come **Theme** | `"dark"` |

270| `tui` | Renderer dell'interfaccia utente del terminale. Usa `"fullscreen"` per il renderer [alt-screen](/it/fullscreen) senza sfarfallio con scrollback virtualizzato. Usa `"default"` per il renderer classico della schermata principale. Imposta tramite `/tui`. Puoi anche impostare la variabile di ambiente [`CLAUDE_CODE_NO_FLICKER`](/it/env-vars) | `"fullscreen"` |311| `tui` | Renderer dell'interfaccia utente del terminale. Usa `"fullscreen"` per il renderer [alt-screen](/it/fullscreen) senza sfarfallio con scrollback virtualizzato. Usa `"default"` per il renderer classico della schermata principale. Imposta tramite `/tui`. Puoi anche impostare la variabile di ambiente [`CLAUDE_CODE_NO_FLICKER`](/it/env-vars) | `"fullscreen"` |

271| `ultracode` | Attiva [ultracode](/it/workflows#let-claude-decide-with-ultracode) per la sessione. Solo per sessione e non letto da `settings.json`. Imposta tramite `/effort ultracode`, `--settings`, o una richiesta di controllo dell'Agent SDK | `true` |312| `ultracode` | Attiva [ultracode](/it/workflows#let-claude-decide-with-ultracode) per la sessione. Solo per sessione e non letto da `settings.json`. Imposta tramite `/effort ultracode`, `--settings`, o una richiesta di controllo dell'Agent SDK | `true` |

272| `useAutoModeDuringPlan` | Se la modalità piano utilizza la semantica della modalità auto quando la modalità auto è disponibile. Predefinito: `true`. Non letto dalle impostazioni di progetto condivise. Appare in `/config` come "Use auto mode during plan" | `false` |313| `useAutoModeDuringPlan` | Se la modalità piano utilizza la semantica della modalità auto quando la modalità auto è disponibile. Predefinito: `true`. Non letto dalle impostazioni di progetto condivise. Appare in `/config` come "Use auto mode during plan" | `false` |

314| `verbose` | {/* min-version: 2.1.119 */}Mostra l'output completo dello strumento invece dei riassunti troncati. Predefinito: `false`. Appare in `/config` come **Verbose output**. Il flag `--verbose` ignora questo per una sessione | `true` |

273| `viewMode` | Modalità di visualizzazione della trascrizione predefinita all'avvio: `"default"`, `"verbose"`, o `"focus"`. Ignora la selezione sticky `/focus` quando impostato. Il flag `--verbose` ignora questo per una sessione | `"verbose"` |315| `viewMode` | Modalità di visualizzazione della trascrizione predefinita all'avvio: `"default"`, `"verbose"`, o `"focus"`. Ignora la selezione sticky `/focus` quando impostato. Il flag `--verbose` ignora questo per una sessione | `"verbose"` |

274| `voice` | Impostazioni della [dettatura vocale](/it/voice-dictation): `enabled` attiva la dettatura, `mode` seleziona `"hold"` o `"tap"`, e `autoSubmit` invia il prompt al rilascio del tasto in modalità hold. Scritto automaticamente quando esegui `/voice`. Richiede un account Claude.ai | `{ "enabled": true, "mode": "tap" }` |316| `voice` | Impostazioni della [dettatura vocale](/it/voice-dictation): `enabled` attiva la dettatura, `mode` seleziona `"hold"` o `"tap"`, e `autoSubmit` invia il prompt al rilascio del tasto in modalità hold. Scritto automaticamente quando esegui `/voice`. Richiede un account Claude.ai | `{ "enabled": true, "mode": "tap" }` |

318| `wheelScrollAccelerationEnabled` | {/* min-version: 2.1.174 */}Nel [rendering fullscreen](/it/fullscreen#mouse-wheel-scrolling), accelera la velocità di scorrimento della rotella del mouse durante gli scorrimenti veloci. Predefinito: `true`. Imposta a `false` per una velocità di scorrimento costante per tacca della rotella. Richiede Claude Code v2.1.174 o successivo | `false` |

276| `workflowKeywordTriggerEnabled` | {/* min-version: 2.1.157 */}Se la parola chiave `ultracode` in un prompt attiva un [flusso di lavoro dinamico](/it/workflows#ask-for-a-workflow-in-your-prompt). Imposta a `false` per digitare la parola senza attivarne uno. L'impostazione ultracode, `/workflows`, e i comandi di flusso di lavoro salvati non sono interessati. Predefinito: `true`. Appare in `/config` come **Ultracode keyword trigger**. Aggiunto in v2.1.157; prima di v2.1.160 la parola chiave di attivazione era `workflow` | `false` |319| `workflowKeywordTriggerEnabled` | {/* min-version: 2.1.157 */}Se la parola chiave `ultracode` in un prompt attiva un [flusso di lavoro dinamico](/it/workflows#ask-for-a-workflow-in-your-prompt). Imposta a `false` per digitare la parola senza attivarne uno. L'impostazione ultracode, `/workflows`, e i comandi di flusso di lavoro salvati non sono interessati. Predefinito: `true`. Appare in `/config` come **Ultracode keyword trigger**. Aggiunto in v2.1.157; prima di v2.1.160 la parola chiave di attivazione era `workflow` | `false` |

277| `wslInheritsWindowsSettings` | (Solo impostazioni gestite Windows) Quando `true`, Claude Code su WSL legge le impostazioni gestite dalla catena di politiche Windows in aggiunta a `/etc/claude-code`, con le fonti Windows che hanno priorità. Onorato solo quando impostato nella chiave di registro HKLM o in `C:\Program Files\ClaudeCode\managed-settings.json`, entrambi richiedono privilegi di amministratore Windows per scrivere. Affinché la politica HKCU si applichi anche su WSL, il flag deve essere impostato anche in HKCU stesso. Non ha effetto su Windows nativo | `true` |320| `wslInheritsWindowsSettings` | (Solo impostazioni gestite Windows) Quando `true`, Claude Code su WSL legge le impostazioni gestite dalla catena di politiche Windows in aggiunta a `/etc/claude-code`, con le fonti Windows che hanno priorità. Onorato solo quando impostato nella chiave di registro HKLM o in `C:\Program Files\ClaudeCode\managed-settings.json`, entrambi richiedono privilegi di amministratore Windows per scrivere. Affinché la politica HKCU si applichi anche su WSL, il flag deve essere impostato anche in HKCU stesso. Non ha effetto su Windows nativo | `true` |

278 321

283Queste impostazioni sono archiviate in `~/.claude.json` piuttosto che in `settings.json`. Aggiungerle a `settings.json` attiverà un errore di convalida dello schema.326Queste impostazioni sono archiviate in `~/.claude.json` piuttosto che in `settings.json`. Aggiungerle a `settings.json` attiverà un errore di convalida dello schema.

284 327

285<Note>328<Note>

286 Le versioni precedenti a v2.1.119 archiviano anche `autoScrollEnabled`, `editorMode`, `showTurnDuration`, `teammateMode`, e `terminalProgressBarEnabled` qui invece che in `settings.json`.329 Le versioni precedenti a v2.1.119 archiviano anche un numero di chiavi di preferenza `/config` qui invece che in `settings.json`, inclusi `theme`, `verbose`, `editorMode`, `autoCompactEnabled`, e `preferredNotifChannel`.

287</Note>330</Note>

288 331

314 357

316| :---------------------------------- | :-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :--------------------------------------------------------------------- |359| :---------------------------------- | :-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :--------------------------------------------------------------------- |

317| `allow` | Array di regole di permesso per consentire l'uso dello strumento. Vedi [Sintassi della regola di permesso](#permission-rule-syntax) sottostante per i dettagli della corrispondenza dei modelli | `[ "Bash(git diff *)" ]` |360| `allow` | Array di regole di permesso per consentire l'uso dello strumento. I glob dei nomi degli strumenti sono supportati solo nella posizione dello strumento dopo un prefisso letterale `mcp__<server>__`, come `mcp__github__get_*`; il segmento del server deve essere privo di glob. Vedi [Sintassi della regola di permesso](#permission-rule-syntax) sottostante per i dettagli della corrispondenza dei modelli | `[ "Bash(git diff *)" ]` |

318| `ask` | Array di regole di permesso per chiedere conferma all'uso dello strumento. Vedi [Sintassi della regola di permesso](#permission-rule-syntax) sottostante | `[ "Bash(git push *)" ]` |361| `ask` | Array di regole di permesso per chiedere conferma all'uso dello strumento. Vedi [Sintassi della regola di permesso](#permission-rule-syntax) sottostante | `[ "Bash(git push *)" ]` |

319| `deny` | Array di regole di permesso per negare l'uso dello strumento. Usa questo per escludere file sensibili dall'accesso di Claude Code. Vedi [Sintassi della regola di permesso](#permission-rule-syntax) e [Limitazioni dei permessi Bash](/it/permissions#tool-specific-permission-rules) | `[ "WebFetch", "Bash(curl *)", "Read(./.env)", "Read(./secrets/**)" ]` |362| `deny` | Array di regole di permesso per negare l'uso dello strumento. Usa questo per escludere file sensibili dall'accesso di Claude Code. I nomi degli strumenti accettano modelli glob: `"*"` nega ogni strumento e `"mcp__*"` nega tutti gli strumenti MCP. Vedi [Sintassi della regola di permesso](#permission-rule-syntax) e [Limitazioni dei permessi Bash](/it/permissions#tool-specific-permission-rules) | `[ "WebFetch", "Bash(curl *)", "Read(./.env)", "Read(./secrets/**)" ]` |

320| `additionalDirectories` | [Directory di lavoro](/it/permissions#working-directories) aggiuntive per l'accesso ai file. La maggior parte della configurazione `.claude/` [non viene scoperta](/it/permissions#additional-directories-grant-file-access-not-configuration) da queste directory | `[ "../docs/" ]` |363| `additionalDirectories` | [Directory di lavoro](/it/permissions#working-directories) aggiuntive per l'accesso ai file. La maggior parte della configurazione `.claude/` [non viene scoperta](/it/permissions#additional-directories-grant-file-access-not-configuration) da queste directory | `[ "../docs/" ]` |

321| `defaultMode` | [Modalità di permesso](/it/permission-modes) predefinita quando si apre Claude Code. Valori validi: `default`, `acceptEdits`, `plan`, `auto`, `dontAsk`, `bypassPermissions`. {/* min-version: 2.1.142 */}A partire da Claude Code v2.1.142, `auto` viene ignorato quando impostato nelle impostazioni di progetto o locale (`.claude/settings.json`, `.claude/settings.local.json`) in modo che un repository non possa concedere a se stesso la modalità auto. Impostalo invece in `~/.claude/settings.json`. Il flag CLI `--permission-mode` ignora questa impostazione per una singola sessione | `"acceptEdits"` |364| `defaultMode` | [Modalità di permesso](/it/permission-modes) predefinita quando si apre Claude Code. Valori validi: `default`, `acceptEdits`, `plan`, `auto`, `dontAsk`, `bypassPermissions`. {/* min-version: 2.1.142 */}A partire da Claude Code v2.1.142, `auto` viene ignorato quando impostato nelle impostazioni di progetto o locale (`.claude/settings.json`, `.claude/settings.local.json`) in modo che un repository non possa concedere a se stesso la modalità auto. Impostalo invece in `~/.claude/settings.json`. Il flag CLI `--permission-mode` ignora questa impostazione per una singola sessione | `"acceptEdits"` |

322| `disableBypassPermissionsMode` | Imposta a `"disable"` per prevenire l'attivazione della modalità `bypassPermissions`. Disabilita il flag della riga di comando `--dangerously-skip-permissions`. Molto utile nelle [impostazioni gestite](/it/permissions#managed-settings) per applicare la politica organizzativa, ma funziona da qualsiasi ambito | `"disable"` |365| `disableBypassPermissionsMode` | Imposta a `"disable"` per prevenire l'attivazione della modalità `bypassPermissions`. Disabilita il flag della riga di comando `--dangerously-skip-permissions`. Molto utile nelle [impostazioni gestite](/it/permissions#managed-settings) per applicare la politica organizzativa, ma funziona da qualsiasi ambito | `"disable"` |

326 Sintassi della regola di permesso369 Sintassi della regola di permesso

327</h3>370</h3>

328 371

329Le regole di permesso seguono il formato `Tool` o `Tool(specifier)`. Le regole vengono valutate in ordine: prima le regole di negazione, poi di richiesta, poi di autorizzazione. La prima regola corrispondente vince.372Le regole di permesso seguono il formato `Tool` o `Tool(specifier)`. Le regole vengono valutate in ordine: prima le regole di negazione, poi di richiesta, poi di autorizzazione. La prima regola corrispondente determina il risultato indipendentemente dalla specificità della regola. Vedi l'[ordine di valutazione della regola di permesso](/it/permissions#manage-permissions) per i dettagli.

330 373

331Esempi rapidi:374Esempi rapidi:

332 375

431**Attribuzione predefinita del commit:**474**Attribuzione predefinita del commit:**

432 475

433```text theme={null}476```text theme={null}

434🤖 Generated with [Claude Code](https://claude.com/claude-code)477Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

~~435~~

436 Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

437```478```

438 479

480Il nome del modello nel trailer riflette il modello attivo per la sessione.

481

439**Attribuzione predefinita della pull request:**482**Attribuzione predefinita della pull request:**

440 483

441```text theme={null}484```text theme={null}

491```bash theme={null}534```bash theme={null}

492#!/bin/bash535#!/bin/bash

493query=$(cat | jq -r '.query')536query=$(cat | jq -r '.query')

537# Sostituisci your-repo-file-index con il tuo comando di ricerca file

494your-repo-file-index --query "$query" | head -20538your-repo-file-index --query "$query" | head -20

495```539```

496 540

541<h3 id="footer-link-badges">

542 Badge di link nel footer

543</h3>

544

545L'impostazione `footerLinksRegexes` renderizza badge cliccabili extra nel footer sotto la casella di input. Usalo per trasformare gli ID stampati dai CLI del progetto, come strumenti di revisione e tracker di problemi, in link di sessione.

546

547Ogni voce del `pattern` regex viene confrontata con l'output del turno: risultati degli strumenti, inclusi contenuti di file e pagine recuperate, e le risposte di Claude stesso. I placeholder `{name}` in `url` e `label` vengono riempiti dai gruppi di cattura denominati nel pattern.

548

549L'esempio seguente renderizza un badge ogni volta che appare una chiave di problema come `PROJ-1234` nell'output del turno. Il gruppo denominato `(?<key>...)` cattura la chiave, e `{key}` la sostituisce nell'URL e nell'etichetta:

550

551```json ~/.claude/settings.json theme={null}

552{

553 "footerLinksRegexes": [

554 {

555 "type": "regex",

556 "pattern": "\\b(?<key>PROJ-\\d+)\\b",

557 "url": "https://issues.example.com/browse/{key}",

558 "label": "{key}"

559 }

560 ]

561}

562```

563

564Con questo configurato, quando `PROJ-1234` appare in un risultato dello strumento o nella risposta di Claude, un chip `PROJ-1234` appare nel footer collegato a `https://issues.example.com/browse/PROJ-1234`.

565

566I seguenti vincoli si applicano a ogni voce:

567

568| Vincolo | Comportamento |

569| :------------------ | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |

570| Origine URL | I valori catturati sono codificati in URL e l'URL costruito deve condividere l'origine letterale del modello. Una cattura può riempire un segmento di percorso o un valore di query ma non può cambiare dove punta il link |

571| Lunghezza URL | Gli URL costruiti più lunghi di 2048 caratteri vengono eliminati |

572| 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` |

573| Etichetta | Predefinito al testo corrispondente e viene troncato a 28 colonne di visualizzazione |

574| Conteggio badge | Al massimo 5 badge vengono renderizzati. Il più vecchio viene spostato dai nuovi match e `/clear` li rimuove |

575| Ambito impostazioni | Letto dalle impostazioni utente, dal flag `--settings`, e dalle impostazioni gestite solo. Ignorato in `.claude/settings.json` e `.claude/settings.local.json` del progetto |

576

577Quando un turno si completa, Claude Code confronta ogni voce del `pattern` regex con l'output del turno sul thread principale, quindi un regex lento blocca l'interfaccia utente fino al completamento. I quantificatori annidati come `(a+)+$` possono richiedere un tempo esponenziale rispetto a certi input e bloccare la sessione, quindi mantieni ogni `pattern` lineare ed evita di annidare `+` o `*`.

578

579I badge del footer vengono renderizzati insieme a una [status line personalizzata](/it/statusline) quando una è configurata; nessuno sostituisce l'altro. Usa una status line per una riga guidata da script che calcola il suo contenuto dai dati della sessione, e i badge del footer per trasformare gli ID dalla conversazione in link senza uno script.

580

497<h3 id="hook-configuration">581<h3 id="hook-configuration">

498 Configurazione hook582 Configurazione hook

499</h3>583</h3>

583Ad esempio, se le tue impostazioni utente impostano `permissions.defaultMode` a `acceptEdits` e le impostazioni condivise di un progetto lo impostano a `default`, il valore del progetto si applica. L'esempio sottostante copre come le impostazioni con valore di array come le regole di permesso si combinano invece.667Ad esempio, se le tue impostazioni utente impostano `permissions.defaultMode` a `acceptEdits` e le impostazioni condivise di un progetto lo impostano a `default`, il valore del progetto si applica. L'esempio sottostante copre come le impostazioni con valore di array come le regole di permesso si combinano invece.

584 668

585<Note>669<Note>

586 **Le impostazioni di array si uniscono tra gli ambiti.** Quando la stessa impostazione con valore di array (come `sandbox.filesystem.allowWrite` o `permissions.allow`) appare in più ambiti, gli array vengono **concatenati e deduplicati**, non sostituiti. Ciò significa che gli ambiti con priorità inferiore possono aggiungere voci senza ignorare quelle impostate da ambiti con priorità più alta, e viceversa. Ad esempio, se le impostazioni gestite impostano `allowWrite` a `["/opt/company-tools"]` e un utente aggiunge `["~/.kube"]`, entrambi i percorsi sono inclusi nella configurazione finale.670 **Le impostazioni di array si uniscono tra gli ambiti.** Quando la stessa impostazione con valore di array (come `sandbox.filesystem.allowWrite` o `permissions.allow`) appare in più ambiti, gli array vengono **concatenati e deduplicati**, non sostituiti. Ciò significa che gli ambiti con priorità inferiore possono aggiungere voci senza ignorare quelle impostate da ambiti con priorità più alta, e viceversa. Ad esempio, se le impostazioni gestite impostano `allowWrite` a `["/opt/company-tools"]` e un utente aggiunge `["~/.kube"]`, entrambi i percorsi sono inclusi nella configurazione finale. Due eccezioni: [`fallbackModel`](#available-settings), una catena ordinata dove la posizione ha significato in modo che il file con la precedenza più alta che la definisce fornisce l'intero valore, e {/* min-version: 2.1.175 */}a partire da v2.1.175, [`availableModels`](#available-settings), dove un valore gestito o di politica sostituisce completamente le voci con precedenza inferiore. Vedi [Comportamento di unione](/it/model-config#merge-behavior).

587</Note>671</Note>

588 672

589<h3 id="verify-active-settings">673<h3 id="verify-active-settings">

590 Verifica le impostazioni attive674 Verifica le impostazioni attive

591</h3>675</h3>

592 676

593Esegui `/status` all'interno di Claude Code per vedere quali fonti di impostazioni sono attive. La scheda Status include una riga `Setting sources` che elenca ogni livello di configurazione che Claude Code ha caricato per la sessione corrente, come `User settings` o `Project local settings`. Quando le [impostazioni gestite](/it/admin-setup#decide-how-settings-reach-devices) sono in vigore, la voce mostra il canale di distribuzione tra parentesi, ad esempio `Enterprise managed settings (remote)`, `(plist)`, `(HKLM)`, `(HKCU)`, o `(file)`. Un livello appare nell'elenco solo quando quella fonte viene caricata con almeno una chiave, quindi un elenco vuoto significa che non sono state trovate fonti di impostazioni.677Esegui `/status` dentro Claude Code per vedere quali fonti di impostazioni sono attive. All'interno del menu, la scheda **Status** include una riga `Setting sources` che elenca ogni livello Claude Code ha caricato per la sessione corrente, come `User settings` o `Project local settings`. Quando le [impostazioni gestite](/it/admin-setup#decide-how-settings-reach-devices) sono in vigore, la voce mostra il canale di distribuzione tra parentesi, ad esempio `Enterprise managed settings (remote)`, `(plist)`, `(HKLM)`, `(HKCU)`, o `(file)`. Un livello appare nell'elenco solo quando quella fonte viene caricata con almeno una chiave, quindi un elenco vuoto significa che non sono state trovate fonti di impostazioni.

678

679La riga `Setting sources` conferma quali fonti vengono lette. Non mostra quale livello ha fornito ogni singola chiave. La scheda **Config** nello stesso dialogo è un editor per un insieme fisso di interruttori come tema e output dettagliato, non una visualizzazione dei contenuti del tuo `settings.json`.

594 680

595La riga `Setting sources` conferma quali fonti vengono lette. Non mostra quale livello ha fornito ogni singola chiave. La scheda Config nello stesso dialogo è un editor per un insieme fisso di interruttori come tema e output dettagliato, non una visualizzazione dei contenuti del tuo `settings.json`. Se un file di impostazioni contiene errori, come JSON non valido o un valore che non supera la convalida, `/status` segnala il problema in modo che tu possa risolverlo.681Se un file di impostazioni contiene errori, come JSON non valido o un valore che non supera la convalida, Claude Code mostra un avviso di problemi di configurazione all'avvio e `/status` elenca i file interessati. Esegui `/doctor` per i dettagli di ogni errore.

596 682

597<h3 id="key-points-about-the-configuration-system">683<h3 id="key-points-about-the-configuration-system">

598 Punti chiave sul sistema di configurazione684 Punti chiave sul sistema di configurazione

603* **Skills**: Prompt personalizzati che possono essere invocati con `/skill-name` o caricati automaticamente da Claude689* **Skills**: Prompt personalizzati che possono essere invocati con `/skill-name` o caricati automaticamente da Claude

604* **MCP server**: Estendono Claude Code con strumenti e integrazioni aggiuntivi690* **MCP server**: Estendono Claude Code con strumenti e integrazioni aggiuntivi

605* **Precedenza**: Le configurazioni di livello superiore (Managed) ignorano quelle di livello inferiore (User/Project)691* **Precedenza**: Le configurazioni di livello superiore (Managed) ignorano quelle di livello inferiore (User/Project)

606* **Ereditarietà**: Le impostazioni vengono unite, con impostazioni più specifiche che aggiungono o ignorano quelle più ampie692* **Ereditarietà**: Le impostazioni vengono unite tra gli ambiti; i valori scalari da ambiti con priorità più alta ignorano, e gli array si concatenano. Eccezioni: `fallbackModel`, dove l'ambito con la precedenza più alta fornisce l'intera catena, e `availableModels`, dove un valore gestito o di politica sostituisce le voci con precedenza inferiore

607 693

608<h3 id="system-prompt">694<h3 id="system-prompt">

609 Prompt di sistema695 Prompt di sistema

684 770

685* **Impostazioni utente** (`~/.claude/settings.json`): Preferenze personali dei plugin771* **Impostazioni utente** (`~/.claude/settings.json`): Preferenze personali dei plugin

686* **Impostazioni di progetto** (`.claude/settings.json`): Plugin specifici del progetto condivisi con il team772* **Impostazioni di progetto** (`.claude/settings.json`): Plugin specifici del progetto condivisi con il team

687* **Impostazioni locali** (`.claude/settings.local.json`): Override per macchina (non committati)773* **Impostazioni locali** (`.claude/settings.local.json`): Override per macchina, gitignored quando Claude Code lo crea

688* **Impostazioni gestite** (`managed-settings.json`): Override della politica a livello organizzativo che blocca l'installazione in tutti gli ambiti e nasconde il plugin dal marketplace774* **Impostazioni gestite** (`managed-settings.json`): Override della politica a livello organizzativo che blocca l'installazione in tutti gli ambiti e nasconde il plugin dal marketplace

689 775

690<Note>776<Note>

1075 Variabili di ambiente1161 Variabili di ambiente

1076</h2>1162</h2>

1077 1163

1078Le variabili di ambiente ti consentono di controllare il comportamento di Claude Code senza modificare i file di impostazioni. Qualsiasi variabile può anche essere configurata in [`settings.json`](#available-settings) sotto la chiave `env` per applicarla a ogni sessione o distribuirla al tuo team.1164Le variabili di ambiente consentono di controllare il comportamento di Claude Code senza modificare i file di impostazioni. Qualsiasi variabile può anche essere configurata in [`settings.json`](#available-settings) sotto la chiave `env` per applicarla a ogni sessione o distribuirla al vostro team.

1079 1165

1080Vedi il [riferimento delle variabili di ambiente](/it/env-vars) per l'elenco completo.1166Consultare il [riferimento delle variabili di ambiente](/it/env-vars) per l'elenco completo.

1081 1167

1082<h2 id="tools-available-to-claude">1168<h2 id="tools-available-to-claude">

1083 Strumenti disponibili per Claude1169 Strumenti disponibili per Claude

settings.md 2026-06-16 21:57 UTC to 2026-06-17 17:02 UTC

Impostazioni di Claude Code

Ambiti di configurazione

Ambiti disponibili

Quando utilizzare ogni ambito

Come interagiscono gli ambiti

Cosa utilizza gli ambiti

File di impostazioni

Quando gli edits hanno effetto

Voci non valide nelle impostazioni gestite

Impostazioni disponibili

Impostazioni di configurazione globale

Impostazioni worktree

Impostazioni di permesso

Sintassi della regola di permesso

Impostazioni sandbox

Prefissi di percorso sandbox

Impostazioni di attribuzione

Impostazioni di suggerimento file

Badge di link nel footer

Configurazione hook

Calcola le impostazioni gestite con un policy helper

Precedenza delle impostazioni

Verifica le impostazioni attive

Punti chiave sul sistema di configurazione

Prompt di sistema

Esclusione di file sensibili

Configurazione subagent

Configurazione plugin

Impostazioni plugin

`enabledPlugins`

`extraKnownMarketplaces`

`strictKnownMarketplaces`

`strictPluginOnlyCustomization`

Gestione dei plugin

Variabili di ambiente

Strumenti disponibili per Claude

Vedi anche