> ## Documentation Index
> Fetch the complete documentation index at: https://code.claude.com/docs/llms.txt
> Use this file to discover all available pages before exploring further.
# 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`, che apre un'interfaccia Impostazioni con schede dove potete visualizzare le informazioni di stato e modificare le opzioni di configurazione. {/* min-version: 2.1.181 */}A partire dalla versione 2.1.181, potete modificare una singola opzione senza aprire l'interfaccia passando `key=value` a `/config`, ad esempio `/config verbose=true`.
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 i membri dell'organizzazione per la distribuzione gestita dal server; tutti gli utenti sulla macchina per plist, registro HKLM e distribuzione di file; l'utente corrente per la distribuzione del registro HKCU | Sì (distribuito da IT) |
| **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à:
1. **Managed** (più alta): non può essere ignorata da nulla
2. **Argomenti della riga di comando**: override temporanei della sessione
3. **Local**: ignora le impostazioni di progetto e utente
4. **Project**: ignora le impostazioni utente
5. **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](#settings-precedence).
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 da remoto al momento dell'accesso, sia dai server di Anthropic tramite la console di amministrazione claude.ai che da un [gateway di app Claude](/it/claude-apps-gateway) auto-ospitato. Vedi [impostazioni gestite dal server](/it/server-managed-settings).
* **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\`
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](/it/permissions#managed-only-settings) e [Configurazione MCP gestita](/it/managed-mcp) per i dettagli.
Questo [repository](https://github.com/anthropics/claude-code/tree/main/examples/mdm) include modelli di distribuzione iniziali per Jamf, Iru (Kandji), Intune e Criteri di gruppo. Usa questi come punti di partenza e adattali alle tue esigenze.
Le distribuzioni gestite possono anche limitare **le aggiunte del marketplace dei plugin** utilizzando `strictKnownMarketplaces`. Per ulteriori informazioni, vedi [Restrizioni del marketplace gestito](/it/plugin-marketplaces#managed-marketplace-restrictions).
* **Altra configurazione** è archiviata in `~/.claude.json`. Questo file contiene la tua sessione OAuth, configurazioni dei [MCP server](/it/mcp) per gli ambiti utente e locale, stato per-progetto (strumenti consentiti, impostazioni di fiducia), e varie cache. I MCP server con ambito di progetto sono archiviati separatamente in `.mcp.json`.
Claude Code crea automaticamente backup con timestamp dei file di configurazione e conserva i cinque backup più recenti per prevenire la perdita di dati.
```JSON Esempio settings.json theme={null}
{
"$schema": "https://json.schemastore.org/claude-code-settings.json",
"permissions": {
"allow": [
"Bash(npm run lint)",
"Bash(npm run test *)",
"Read(~/.zshrc)"
],
"deny": [
"Bash(curl *)",
"Read(./.env)",
"Read(./.env.*)",
"Read(./secrets/**)"
]
},
"env": {
"CLAUDE_CODE_ENABLE_TELEMETRY": "1",
"OTEL_METRICS_EXPORTER": "otlp"
},
"companyAnnouncements": [
"Welcome to Acme Corp! Review our code guidelines at docs.acme.com",
"Reminder: Code reviews required for all PRs",
"New security policy in effect"
]
}
```
La riga `$schema` nell'esempio sopra punta allo [schema JSON ufficiale](https://json.schemastore.org/claude-code-settings.json) per le impostazioni di Claude Code. Aggiungerlo al tuo `settings.json` abilita l'autocompletamento e la convalida inline in VS Code, Cursor e qualsiasi altro editor che supporta la convalida dello schema JSON.
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`](/it/hooks#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`](/it/model-config#setting-your-model) per cambiare durante la sessione
* [`outputStyle`](/it/output-styles): 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](/it/server-managed-settings), 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. |
| `sandbox.credentials` | {/* min-version: 2.1.191 */}Una singola voce non valida in `files` o `envVars` viene rimossa con un avviso e il sottoinsieme valido viene applicato. Un valore `credentials` completamente non valido viene eliminato con un avviso mentre il resto di `sandbox` continua ad applicarsi. Si applica in v2.1.191 e successivo. |
`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`](/it/debug-your-config) 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](/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"` |
| `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"` |
| `agentPushNotifEnabled` | {/* min-version: 2.1.119 */}**Predefinito**: `false`. 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. 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` |
| `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` |
| `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" }]` |
| `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/*"]` |
| `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](/it/managed-mcp) | `[{ "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](#hook-configuration) | `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](/it/managed-mcp) | `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](/it/permissions#managed-only-settings) | `true` |
| `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` |
| `apiKeyHelper` | Script personalizzato, da eseguire tramite la shell di sistema (`/bin/sh` su macOS e Linux, `cmd` su Windows), per generare un valore di autenticazione. Questo valore verrà inviato come intestazioni `X-Api-Key` e `Authorization: Bearer` per le richieste di modello. Imposta l'intervallo di aggiornamento con [`CLAUDE_CODE_API_KEY_HELPER_TTL_MS`](/it/env-vars) | `/bin/generate_temp_api_key.sh` |
| `attribution` | Personalizza l'attribuzione per i commit git e le pull request. Vedi [Impostazioni di attribuzione](#attribution-settings) | `{"commit": "🤖 Generated with Claude Code", "pr": ""}` |
| `autoCompactEnabled` | {/* min-version: 2.1.119 */}**Predefinito**: `true`. Compatta automaticamente la conversazione quando il contesto si avvicina al limite. Appare in `/config` come **Auto-compact**. Per disabilitare tramite variabile di ambiente, imposta [`DISABLE_AUTO_COMPACT`](/it/env-vars) in `env` | `false` |
| `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"` |
| `autoMemoryEnabled` | **Predefinito**: `true`. Abilita la [memoria automatica](/it/memory#enable-or-disable-auto-memory). Quando `false`, Claude non legge da o scrive nella directory di memoria automatica. Puoi anche attivare/disattivare questo con `/memory` durante una sessione. Per disabilitare tramite variabile di ambiente, imposta [`CLAUDE_CODE_DISABLE_AUTO_MEMORY`](/it/env-vars) in `env` | `false` |
| `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"]}` |
| `autoMode.classifyAllShell` | {/* min-version: 2.1.193 */}**Predefinito**: `false`. Quando `true`, sospende ogni regola allow di Bash e PowerShell mentre la modalità auto è attiva in modo che tutti i comandi shell vengono instradati attraverso il classificatore, non solo le regole che corrispondono ai modelli di esecuzione di codice arbitrario. Vedi [Instrada tutti i comandi shell attraverso il classificatore](/it/auto-mode-config#route-all-shell-commands-through-the-classifier). Richiede Claude Code v2.1.193 o successivo | `true` |
| `autoScrollEnabled` | **Predefinito**: `true`. Nel [rendering fullscreen](/it/fullscreen), segui il nuovo output fino al fondo della conversazione. Appare in `/config` come **Auto-scroll**. I prompt di permesso scorrono comunque in vista quando questo è disattivato | `false` |
| `autoUpdatesChannel` | **Predefinito**: `"latest"`. Canale di rilascio da seguire per gli aggiornamenti. Usa `"stable"` per una versione che è tipicamente circa una settimana vecchia e salta le versioni con regressioni importanti, o `"latest"` per il rilascio più recente. Per disabilitare completamente gli auto-aggiornamenti, imposta [`DISABLE_AUTOUPDATER`](/it/setup#disable-auto-updates) in `env` | `"stable"` |
| `availableModels` | Limita quali modelli gli utenti possono selezionare per la sessione principale, i [subagent](/it/sub-agents), i [skills](/it/skills) e l'[advisor](/it/advisor). Non influisce sull'opzione Predefinito a meno che `enforceAvailableModels` non sia anche impostato. Vedi [Limita la selezione del modello](/it/model-config#restrict-model-selection) | `["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`](/it/env-vars) | `true` |
| `awsAuthRefresh` | Script personalizzato che modifica la directory `.aws` (vedi [configurazione avanzata delle credenziali](/it/amazon-bedrock#advanced-credential-configuration)) | `aws sso login --profile myprofile` |
| `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` |
| `axScreenReader` | {/* min-version: 2.1.181 */}Renderizza output compatibile con lo screen reader: testo piatto senza bordi decorativi o animazioni. La modalità screen reader utilizza sempre il renderer classico, quindi l'impostazione `tui` non ha effetto mentre è attiva. La variabile di ambiente [`CLAUDE_AX_SCREEN_READER`](/it/env-vars) e il flag [`--ax-screen-reader`](/it/cli-reference#cli-flags) hanno la precedenza. Richiede Claude Code v2.1.181 o successivo | `true` |
| `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](/it/plugin-marketplaces#managed-marketplace-restrictions) | `[{ "source": "github", "repo": "untrusted/plugins" }]` |
| `channelsEnabled` | (Solo impostazioni gestite) Consenti [channels](/it/channels) per l'organizzazione. Nei piani Team e Enterprise di claude.ai, i canali vengono bloccati quando questo non è impostato o è `false`. Per gli account [Anthropic Console](/it/authentication#claude-console-authentication) che utilizzano l'autenticazione con chiave API, i canali sono consentiti per impostazione predefinita a meno che la tua organizzazione non distribuisca impostazioni gestite, nel qual caso questa chiave deve essere impostata a `true` | `true` |
| `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](/it/memory#deploy-organization-wide-claude-md) | `"Always run make lint before committing."` |
| `claudeMdExcludes` | Modelli Glob o percorsi assoluti dei file `CLAUDE.md` da saltare durante il caricamento della [memoria](/it/memory). I modelli corrispondono ai percorsi assoluti dei file. Si applica solo alla memoria utente, progetto e locale; i file di politica gestiti non possono essere esclusi | `["**/vendor/**/CLAUDE.md"]` |
| `cleanupPeriodDays` | **Predefinito**: `30` giorni, minimo `1`. I file di sessione più vecchi di questo periodo vengono eliminati all'avvio. 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](/it/worktrees#clean-up-worktrees) all'avvio. Per disabilitare completamente le scritture di trascritti, imposta la variabile di ambiente [`CLAUDE_CODE_SKIP_PROMPT_HISTORY`](/it/env-vars), 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` | **Predefinito**: `"bash"`, o `"powershell"` su Windows quando Bash non è disponibile. Shell predefinita per i comandi `!` della casella di input. Accetta `"bash"` o `"powershell"`. L'impostazione a `"powershell"` instrada i comandi `!` interattivi tramite PowerShell su Windows. Richiede `CLAUDE_CODE_USE_POWERSHELL_TOOL=1`. Vedi [Strumento PowerShell](/it/tools-reference#powershell-tool) | `"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](/it/managed-mcp) | `[{ "serverName": "filesystem" }]` |
| `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` |
| `disableAllHooks` | Disabilita tutti gli [hooks](/it/hooks) e qualsiasi [status line](/it/statusline) personalizzato | `true` |
| `disableArtifact` | Imposta a `true` per disabilitare lo strumento [Artifact](/it/artifacts), che pubblica l'output della sessione come pagina web privata su claude.ai. Equivalente all'impostazione di `CLAUDE_CODE_DISABLE_ARTIFACT` a `1` | `true` |
| `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"` |
| `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` |
| `disableClaudeAiConnectors` | {/* min-version: 2.1.182 */}Disabilita i [connettori MCP di claude.ai](/it/mcp#use-mcp-servers-from-claude-ai) in modo che non vengano recuperati automaticamente o connessi. Imposta in qualsiasi ambito di impostazioni. `true` in qualsiasi fonte ha la precedenza, quindi un `.claude/settings.json` di progetto controllato può escludere un repository dai connettori cloud, ma un `false` a livello di progetto non può ignorare un `true` a livello utente o di politica. I server passati esplicitamente tramite `--mcp-config` non sono interessati. Per negare i singoli connettori invece di tutti loro, usa [`deniedMcpServers`](/it/managed-mcp). Richiede Claude Code v2.1.182 o successivo | `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](/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"` |
| `disabledMcpjsonServers` | Elenco di MCP server specifici dai file `.mcp.json` da rifiutare | `["filesystem"]` |
| `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` |
| `disableSideloadFlags` | {/* min-version: 2.1.193 */}(Solo impostazioni gestite) Rifiuta i flag CLI `--plugin-dir`, `--plugin-url`, `--agents`, e `--mcp-config` all'avvio, che gli utenti potrebbero altrimenti passare per ignorare [`strictKnownMarketplaces`](#strictknownmarketplaces) per una singola esecuzione. Rifiuta anche questi flag da qualsiasi superficie che genera la CLI con loro internamente, attualmente le sessioni locali di [Cowork](/it/desktop) nell'app desktop. Un `--mcp-config` i cui server sono tutti voci `type: "sdk"` in-process è comunque accettato, quindi l'Agent SDK e l'estensione VS Code continuano a funzionare. Non blocca `claude mcp add`, `.mcp.json`, o SDK `setMcpServers()`; abbina con [`allowedMcpServers`](/it/managed-mcp) per il controllo MCP per server. Richiede Claude Code v2.1.193 o successivo | `true` |
| `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` |
| `disableWorkflows` | **Predefinito**: `false`. Disabilita i [flussi di lavoro dinamici](/it/workflows#turn-workflows-off) e i comandi di flusso di lavoro bundled. Equivalente all'impostazione di `CLAUDE_CODE_DISABLE_WORKFLOWS` a `1` | `true` |
| `editorMode` | **Predefinito**: `"normal"`. Modalità di scorciatoie da tastiera per il prompt di input: `"normal"` o `"vim"`. Appare in `/config` come **Editor mode** | `"vim"` |
| `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"` |
| `enableAllProjectMcpServers` | Approva automaticamente tutti i MCP server definiti nei file `.mcp.json` del progetto. {/* min-version: 2.1.196 */}A partire da v2.1.196, `claude mcp list` e `claude mcp get` onorano questa chiave in una cartella non attendibile solo dai [file di impostazioni che non vengono controllati nel repository](/it/mcp#managing-your-servers) | `true` |
| `enableArtifact` | {/* min-version: 2.1.196 */}Abilita o disabilita lo strumento [Artifact](/it/artifacts) per questo utente. Quando non impostato, il predefinito segue la [disponibilità](/it/artifacts#availability) della funzione per il tuo account. La riga **Artifacts** in `/config` scrive questa chiave. Un `disableArtifact` gestito e l'[impostazione di amministrazione](/it/artifacts#manage-artifacts-for-your-organization) della tua organizzazione hanno la precedenza, e la chiave viene ignorata nelle impostazioni di progetto e locale (`.claude/settings.json`, `.claude/settings.local.json`), che un repository potrebbe altrimenti controllare. Richiede Claude Code v2.1.196 o successivo | `true` |
| `enabledMcpjsonServers` | Elenco di MCP server specifici dai file `.mcp.json` da approvare. {/* min-version: 2.1.196 */}A partire da v2.1.196, `claude mcp list` e `claude mcp get` onorano questa chiave in una cartella non attendibile solo dai [file di impostazioni che non vengono controllati nel repository](/it/mcp#managing-your-servers) | `["memory", "github"]` |
| `enforceAvailableModels` | {/* min-version: 2.1.175 */}Estendi l'elenco di autorizzazione `availableModels` al modello Predefinito. Quando `true` nelle impostazioni gestite e `availableModels` è un array non vuoto, l'opzione Predefinito ricade alla prima voce nella lista di autorizzazione che è disponibile, ma solo quando il modello predefinito per il tipo di account dell'utente non è nell'elenco di autorizzazione; un predefinito nella lista di autorizzazione viene mantenuto così com'è. Non ha effetto quando `availableModels` non è impostato o è vuoto. Vedi [Applica l'elenco di autorizzazione al modello Predefinito](/it/model-config#enforce-the-allowlist-for-the-default-model). 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. {/* min-version: 2.1.195 */}A partire da v2.1.195, le variabili di identità che gli ambienti di hosting di Claude Code impostano, ad esempio `CLAUDE_CODE_REMOTE` e `CLAUDE_CODE_ACCOUNT_UUID`, vengono ignorate quando impostate qui | `{"FOO": "bar"}` |
| `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-5", "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](/it/fast-mode#require-per-session-opt-in) | `true` |
| `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` |
| `fileCheckpointingEnabled` | {/* min-version: 2.1.119 */}**Predefinito**: `true`. Snapshot dei file prima di ogni edit in modo che [`/rewind`](/it/checkpointing) possa ripristinarli. 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` |
| `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"}` |
| `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(?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, o `gateway` per limitare l'accesso a un gateway cloud; vedi [gateway di app Claude](/it/claude-apps-gateway). Quando impostato a qualsiasi valore nelle impostazioni gestite, le sessioni autenticate tramite `ANTHROPIC_API_KEY`, `ANTHROPIC_AUTH_TOKEN`, o `apiKeyHelper` vengono bloccate all'avvio, poiché nessuno di questi valori può soddisfare il metodo di accesso richiesto. Le sessioni del provider di terze parti come Bedrock, Vertex e Foundry non vengono bloccate: si autenticano rispetto al tuo provider cloud piuttosto che ad Anthropic | `claudeai` |
| `forceLoginGatewayUrl` | Pre-compila e blocca l'URL del gateway nella schermata `/login` Cloud gateway. O questa chiave o `forceLoginMethod: "gateway"` visualizza quella schermata; imposta entrambi in modo che l'URL sia compilato. Onorato solo al livello di politica gestita; ignorato nelle impostazioni utente e di progetto. Vedi [gateway di app Claude](/it/claude-apps-gateway#set-the-gateway-url) | `"https://claude-gateway.example.com"` |
| `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](/it/server-managed-settings#enforce-fail-closed-startup) | `true` |
| `gcpAuthRefresh` | Script personalizzato che aggiorna le credenziali predefinite dell'applicazione GCP quando scadono o non possono essere caricate. Vedi [configurazione avanzata delle credenziali](/it/google-vertex-ai#advanced-credential-configuration) | `gcloud auth application-default login` |
| `hooks` | Configura comandi personalizzati da eseguire agli eventi del ciclo di vita. Vedi [documentazione hooks](/it/hooks) per il formato | Vedi [hooks](/it/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](#hook-configuration) | `["MY_TOKEN", "HOOK_SECRET"]` |
| `includeGitInstructions` | **Predefinito**: `true`. Includi le istruzioni integrate del flusso di lavoro di commit e PR e lo snapshot dello stato git nel prompt di sistema di Claude. Imposta a `false` per rimuovere entrambi, ad esempio quando utilizzi le tue skill di flusso di lavoro git. La variabile di ambiente `CLAUDE_CODE_DISABLE_GIT_INSTRUCTIONS` ha la precedenza su questa impostazione quando impostata | `false` |
| `inputNeededNotifEnabled` | {/* min-version: 2.1.119 */}**Predefinito**: `false`. 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. 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` |
| `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"` |
| `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"` |
| `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-5"` |
| `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:..."}` |
| `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` |
| `outputStyle` | Configura uno stile di output per regolare il prompt di sistema. Vedi [documentazione degli stili di output](/it/output-styles) | `"Explanatory"` |
| `parentSettingsBehavior` | {/* min-version: 2.1.133 */}(Solo impostazioni gestite) **Predefinito**: `"first-wins"`. Controlla se le impostazioni gestite fornite programmaticamente da un processo host di incorporamento, come l'Agent SDK o un'estensione IDE, si applicano quando è presente anche un livello gestito distribuito da un amministratore. `"first-wins"`: le impostazioni fornite dal parent vengono eliminate e si applica solo il livello amministrativo. `"merge"`: le impostazioni fornite dal parent si applicano sotto il livello amministrativo, filtrate in modo che possano stringere la politica ma non allentarla. Non ha effetto quando non è distribuito alcun livello amministrativo. Richiede Claude Code v2.1.133 o successivo | `"merge"` |
| `permissions` | Vedi la tabella sottostante per la struttura dei permessi. | |
| `plansDirectory` | **Predefinito**: `~/.claude/plans`. Personalizza dove vengono archiviati i file di piano. Il percorso è relativo alla radice del progetto. | `"./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](#compute-managed-settings-with-a-policy-helper). Richiede Claude Code v2.1.136 o successivo | `{"path": "/usr/local/bin/claude-policy"}` |
| `preferredNotifChannel` | **Predefinito**: `"auto"`. Metodo per le notifiche di completamento attività e prompt di permesso: `"auto"`, `"terminal_bell"`, `"iterm2"`, `"iterm2_with_bell"`, `"kitty"`, `"ghostty"`, o `"notifications_disabled"`. `"auto"` invia una notifica desktop in iTerm2, Ghostty e Kitty e non fa nulla in altri terminali. Imposta `"terminal_bell"` per suonare il carattere di campanello in qualsiasi terminale. Appare in `/config` come **Notifications**. Vedi [Ottieni un campanello del terminale o una notifica](/it/terminal-config#get-a-terminal-bell-or-notification) | `"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}"` |
| `remoteControlAtStartup` | {/* min-version: 2.1.119 */}Connetti il [Controllo remoto](/it/remote-control) automaticamente quando ogni sessione interattiva si avvia, invece di attendere `/remote-control`. Imposta a `true` per connettersi sempre automaticamente, `false` per non connettersi mai automaticamente, o lascia non impostato per seguire il predefinito della tua organizzazione. Appare in `/config` come **Enable Remote Control for all sessions**. Vedi [Abilita il Controllo remoto per tutte le sessioni](/it/remote-control#enable-remote-control-for-all-sessions) | `false` |
| `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 ` 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` | **Predefinito**: `true`. Controlla se il selettore di file `@` rispetta i modelli `.gitignore`. Quando `true`, i file che corrispondono ai modelli `.gitignore` sono esclusi dai suggerimenti | `false` |
| `respondToBashCommands` | {/* min-version: 2.1.186 */}**Predefinito**: `true`. Se Claude risponde dopo l'esecuzione di un comando shell `!` della casella di input. Imposta a `false` per aggiungere l'output del comando al contesto senza una risposta. Vedi [Modalità shell con prefisso `!`](/it/interactive-mode#shell-mode-with-prefix). Richiede Claude Code v2.1.186 o successivo | `false` |
| `showClearContextOnPlanAccept` | **Predefinito**: `false`. Mostra l'opzione "cancella contesto" nella schermata di accettazione del piano. Imposta a `true` per ripristinare l'opzione | `true` |
| `showThinkingSummaries` | **Predefinito**: `false`. Mostra i riassunti del [pensiero esteso](/it/model-config#extended-thinking) nelle sessioni interattive. Quando non impostato o `false`, i blocchi di pensiero vengono redatti dall'API e mostrati come uno stub compresso. La redazione cambia solo quello che vedi, non quello che il modello genera: per ridurre la spesa di pensiero, [abbassa il budget o disabilita il pensiero](/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` |
| `showTurnDuration` | **Predefinito**: `true`. Mostra i messaggi di durata del turno dopo le risposte, ad es. "Cooked for 1m 6s". Appare in `/config` come **Show turn duration** | `false` |
| `skillListingBudgetFraction` | {/* min-version: 2.1.105 */}**Predefinito**: `0.01` (1%). Frazione della finestra di contesto del modello riservata all'[elenco di skills](/it/skills#skill-descriptions-are-cut-short) che Claude vede ogni turno. 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` |
| `skillListingMaxDescChars` | {/* min-version: 2.1.105 */}**Predefinito**: `1536`. 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. 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` |
| `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](/it/skills#override-skill-visibility-from-settings). Richiede Claude Code v2.1.129 o successivo | `{"legacy-context": "name-only", "deploy": "off"}` |
| `skipWebFetchPreflight` | Salta il [controllo di sicurezza del dominio WebFetch](/it/data-usage#webfetch-domain-safety-check) che invia ogni hostname richiesto a `api.anthropic.com` prima del recupero. Imposta a `true` negli ambienti che bloccano il traffico verso Anthropic, come le distribuzioni Bedrock, Vertex AI, o Foundry con egress restrittivo. Quando saltato, WebFetch tenta qualsiasi URL senza consultare l'elenco di blocco | `true` |
| `spinnerTipsEnabled` | **Predefinito**: `true`. Mostra suggerimenti nello spinner mentre Claude sta lavorando. Imposta a `false` per disabilitare i suggerimenti | `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](/it/desktop#pre-configure-ssh-connections-for-your-team). Ogni voce richiede `id`, `name` e `sshHost`; `sshPort`, `sshIdentityFile` e `startDirectory` sono facoltativi. Quando impostato nelle impostazioni gestite, le connessioni sono di sola lettura per gli utenti. Letto solo dalle impostazioni gestite e utente | `[{"id": "dev-vm", "name": "Dev VM", "sshHost": "user@dev.example.com"}]` |
| `statusLine` | Configura una status line personalizzata per visualizzare il contesto. L'oggetto ha campi opzionali `padding`, `refreshInterval`, e `hideVimModeIndicator` che controllano la spaziatura, le ri-esecuzioni periodiche, e se l'indicatore della modalità vim incorporato sotto il prompt è nascosto. Vedi [documentazione `statusLine`](/it/statusline#manually-configure-a-status-line) | `{"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](/it/plugin-marketplaces#managed-marketplace-restrictions) | `[{ "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`](#strictpluginonlycustomization) | `["skills", "hooks"]` |
| `syntaxHighlightingDisabled` | Disabilita l'evidenziazione della sintassi nei diff, nei blocchi di codice e nelle anteprime dei file | `true` |
| `teammateMode` | **Predefinito**: `in-process`. Come i compagni di squadra del [team di agenti](/it/agent-teams) vengono visualizzati: `in-process`, `auto` (sceglie riquadri divisi in tmux o iTerm2, in-process altrimenti), `tmux` (sceglie riquadri divisi usando tmux o iTerm2, rilevato dal tuo terminale), o {/* min-version: 2.1.186 */}`iterm2` (riquadri divisi nativi iTerm2 tramite la CLI `it2`, aggiunto in v2.1.186). Il predefinito è cambiato da `auto` in v2.1.179. `--teammate-mode` ignora questo per una sessione. Vedi [scegli una modalità di visualizzazione](/it/agent-teams#choose-a-display-mode) | `"auto"` |
| `terminalProgressBarEnabled` | **Predefinito**: `true`. Mostra la barra di avanzamento del terminale nei terminali supportati: ConEmu, Ghostty 1.2.0+, e iTerm2 3.6.6+. Appare in `/config` come **Terminal progress bar** | `false` |
| `theme` | {/* min-version: 2.1.119 */}**Predefinito**: `"dark"`. Tema di colore per l'interfaccia: `"auto"`, `"dark"`, `"light"`, `"dark-daltonized"`, `"light-daltonized"`, `"dark-ansi"`, `"light-ansi"`, o un riferimento a tema personalizzato come `"custom:"` o `"custom::"`. Vedi [Crea un tema personalizzato](/it/terminal-config#create-a-custom-theme). Appare in `/config` come **Theme** | `"dark"` |
| `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"` |
| `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` |
| `useAutoModeDuringPlan` | **Predefinito**: `true`. Se la modalità piano utilizza la semantica della modalità auto quando la modalità auto è disponibile. Non letto dalle impostazioni di progetto condivise. Appare in `/config` come "Use auto mode during plan" | `false` |
| `verbose` | {/* min-version: 2.1.119 */}**Predefinito**: `false`. Mostra l'output completo dello strumento invece dei riassunti troncati. Appare in `/config` come **Verbose output**. Il flag `--verbose` ignora questo per una sessione | `true` |
| `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](/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" }` |
| `voiceEnabled` | Alias legacy per `voice.enabled`. Preferisci l'oggetto `voice` | `true` |
| `wheelScrollAccelerationEnabled` | {/* min-version: 2.1.174 */}**Predefinito**: `true`. Nel [rendering fullscreen](/it/fullscreen#mouse-wheel-scrolling), accelera la velocità di scorrimento della rotella del mouse durante gli scorrimenti veloci. Imposta a `false` per una velocità di scorrimento costante per tacca della rotella. Richiede Claude Code v2.1.174 o successivo | `false` |
| `workflowKeywordTriggerEnabled` | {/* min-version: 2.1.157 */}**Predefinito**: `true`. 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. 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.
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`.
| Chiave | Descrizione | Esempio |
| :------------------------ | :---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :--------- |
| `autoConnectIde` | **Predefinito**: `false`. Connettiti automaticamente a un IDE in esecuzione quando Claude Code si avvia da un terminale esterno. Appare in `/config` come **Auto-connect to IDE (external terminal)** quando eseguito al di fuori di un terminale VS Code o JetBrains. La variabile di ambiente [`CLAUDE_CODE_AUTO_CONNECT_IDE`](/it/env-vars) ignora questo quando impostata | `true` |
| `autoInstallIdeExtension` | **Predefinito**: `true`. Installa automaticamente l'estensione IDE di Claude Code quando eseguito da un terminale VS Code. Appare in `/config` come **Auto-install IDE extension** quando eseguito all'interno di un terminale VS Code o JetBrains. Puoi anche impostare la variabile di ambiente [`CLAUDE_CODE_IDE_SKIP_AUTO_INSTALL`](/it/env-vars) | `false` |
| `externalEditorContext` | **Predefinito**: `false`. Prependi la risposta precedente di Claude come contesto commentato con `#` quando apri l'editor esterno con `Ctrl+G`. Appare in `/config` come **Show last response in external editor** | `true` |
| `teammateDefaultModel` | Modello predefinito per i compagni di squadra del [team di agenti](/it/agent-teams) quando il prompt di spawn non ne specifica uno. Imposta a un alias di modello come `"sonnet"`, o `null` per ereditare la selezione `/model` corrente del lead. Appare in `/config` come **Default teammate model** | `"sonnet"` |
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/` 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](/it/agent-view#how-file-edits-are-isolated). `"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`](/it/worktrees#copy-gitignored-files-into-worktrees) 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____`, 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 *)" ]` |
| `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 *)" ]` |
| `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/**)" ]` |
| `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/" ]` |
| `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"` |
| `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"` |
| `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](/it/permissions#manage-permissions) 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](/it/permissions#permission-rule-syntax).
Impostazioni sandbox
Configura il comportamento avanzato del sandboxing. Il sandboxing isola i comandi bash dal tuo filesystem e dalla rete. Vedi [Sandboxing](/it/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](#sandbox-path-prefixes) 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` |
| `credentials.files` | File o directory di credenziali che i comandi sandboxed non possono leggere. Applica lo stesso blocco di lettura di `filesystem.denyRead`; la chiave separata mantiene i percorsi delle credenziali raggruppati con `credentials.envVars` e separati dalle regole generali del filesystem. Ogni voce è `{ "path": "...", "mode": "deny" }`. I percorsi utilizzano gli stessi [prefissi](#sandbox-path-prefixes) di `filesystem.*` impostazioni. Gli array vengono uniti in tutti gli ambiti di impostazioni. Solo `deny` è supportato. Richiede Claude Code v2.1.187 o successivo. | `[{ "path": "~/.aws/credentials", "mode": "deny" }]` |
| `credentials.envVars` | Variabili di ambiente da annullare prima di eseguire i comandi sandboxed. Ogni voce è `{ "name": "...", "mode": "deny" }`. Gli array vengono uniti in tutti gli ambiti di impostazioni. Solo `deny` è supportato. Richiede Claude Code v2.1.187 o successivo. | `[{ "name": "GITHUB_TOKEN", "mode": "deny" }]` |
| `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` |
| `allowAppleEvents` | (Solo macOS) Consenti ai comandi sandboxed di inviare Apple Events. Richiesto per `open`, `osascript`, e strumenti che aprono URL in un browser, che altrimenti falliscono con errore `-600`. **Rimuove l'isolamento dell'esecuzione del codice.** I comandi sandboxed possono lanciare altre applicazioni senza sandbox senza prompt dell'utente; possono anche inviare comandi AppleScript alle applicazioni in esecuzione come Terminal, soggetto al prompt di consenso per-app macOS automation (TCC). Onorato solo dalle impostazioni utente, gestite, o CLI, non dalle impostazioni di progetto. Predefinito: false | `true` |
| `bwrapPath` | (Solo impostazioni gestite, Linux/WSL2) Percorso assoluto al binario bubblewrap (`bwrap`). Ignora il rilevamento automatico tramite `PATH`. Onorato solo dalle [impostazioni gestite](/it/settings#settings-files), non dalle impostazioni utente o di progetto. Utile quando `bwrap` è installato in una posizione non standard negli ambienti gestiti. | `/opt/admin/bwrap` |
| `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`, `filesystem.allowRead`, e `credentials.files` 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 `/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](/it/permissions#read-and-edit), che utilizzano `//path` per assoluto e `/path` per relativo al progetto. I percorsi del filesystem sandbox utilizzano convenzioni standard: `/tmp/build` è un percorso assoluto.
**Esempio di configurazione:**
```json theme={null}
{
"sandbox": {
"enabled": true,
"autoAllowBashIfSandboxed": true,
"excludedCommands": ["docker *"],
"filesystem": {
"allowWrite": ["/tmp/build", "~/.kube"],
"denyRead": ["~/.aws/credentials"]
},
"network": {
"allowedDomains": ["github.com", "*.npmjs.org", "registry.yarnpkg.com"],
"deniedDomains": ["uploads.github.com"],
"allowUnixSockets": [
"/var/run/docker.sock"
],
"allowLocalBinding": true
}
}
}
```
**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](https://git-scm.com/docs/git-interpret-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 |
| `sessionUrl` | Se aggiungere il link della sessione claude.ai come trailer `Claude-Session` nei commit e un link nelle descrizioni delle pull request quando eseguito da una sessione web o Controllo remoto. Predefinito: `true`. Imposta a `false` per omettere il link |
**Attribuzione predefinita del commit:**
```text theme={null}
Co-Authored-By: Claude Sonnet 5
```
Il nome del modello nel trailer riflette il modello attivo per la sessione.
**Attribuzione predefinita della pull request:**
```text theme={null}
🤖 Generated with [Claude Code](https://claude.com/claude-code)
```
**Esempio:**
```json theme={null}
{
"attribution": {
"commit": "Generated with AI\n\nCo-Authored-By: AI ",
"pr": ""
}
}
```
L'impostazione `attribution` ha la precedenza sull'impostazione deprecata `includeCoAuthoredBy`. Per nascondere tutta l'attribuzione, imposta `commit` e `pr` a stringhe vuote e `sessionUrl` a `false`.
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.
```json theme={null}
{
"fileSuggestion": {
"type": "command",
"command": "~/.claude/file-suggestion.sh"
}
}
```
Il comando viene eseguito con le stesse variabili di ambiente degli [hooks](/it/hooks), incluso `CLAUDE_PROJECT_DIR`. Riceve JSON tramite stdin con un campo `query`:
```json theme={null}
{"query": "src/comp"}
```
Restituisci i percorsi dei file separati da newline a stdout (attualmente limitati a 15):
```text theme={null}
src/components/Button.tsx
src/components/Modal.tsx
src/components/Form.tsx
```
**Esempio:**
```bash theme={null}
#!/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 `(?...)` cattura la chiave, e `{key}` la sostituisce nell'URL e nell'etichetta:
```json ~/.claude/settings.json theme={null}
{
"footerLinksRegexes": [
{
"type": "regex",
"pattern": "\\b(?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](/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.
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](#settings-files). Gli elenchi di autorizzazione degli URL e delle variabili di ambiente possono essere impostati a qualsiasi livello di impostazioni e si uniscono tra le fonti.
**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.
```json theme={null}
{
"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.
```json theme={null}
{
"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](/it/server-managed-settings).
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:
```json theme={null}
{
"managedSettings": {
"permissions": { "deny": ["Read(//etc/secrets/**)"] }
},
"claudeMd": "# Organization context\n...",
"appendSystemPrompt": "Always cite the internal style guide."
}
```
Quando l'helper emette `managedSettings`, quell'oggetto diventa l'unica fonte di impostazioni gestite per l'esecuzione, prendendo la precedenza su fonti remote, MDM e basate su file. Quando l'helper esce con codice non zero all'avvio, Claude Code stampa l'errore e rifiuta di avviarsi, quindi un helper che ha bisogno di resilienza di interruzione dovrebbe servire dalla sua cache e uscire con `0`.
Precedenza delle impostazioni
Le impostazioni si applicano in ordine di precedenza. Dal più alto al più basso:
1. **Impostazioni gestite** ([gestite dal server](/it/server-managed-settings), [politiche MDM/a livello di sistema operativo](#configuration-scopes), o [impostazioni gestite](/it/settings#settings-files))
* 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 è: [`policyHelper`](#compute-managed-settings-with-a-policy-helper) output, che quando configurato è l'unica fonte gestita utilizzata > remoto (impostazioni gestite dal server di [claude.ai](/it/server-managed-settings) o [gateway di app Claude](/it/claude-apps-gateway)-consegnate) > politiche MDM/a livello di sistema operativo > basate su file (`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, con un'eccezione: le chiavi di blocco sandbox `sandbox.network.allowManagedDomainsOnly` e `sandbox.filesystem.allowManagedReadPathsOnly`, con i loro elenchi di autorizzazione associati, `allowAllClaudeAiMcps`, e i percorsi binari sandbox `sandbox.bwrapPath` e `sandbox.socatPath` vengono onorati quando qualsiasi fonte gestita controllata dall'amministratore li imposta; il livello HKCU scrivibile dall'utente è escluso. All'interno del livello basato su file, 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 una fonte gestita distribuita da un amministratore: impostazioni gestite dal server, una politica MDM o a livello di sistema operativo, o un file di impostazioni gestite. Il fallback del registro HKCU scrivibile dall'utente non conta come una fonte gestita distribuita da un amministratore. Gli amministratori possono acconsentire impostando [`parentSettingsBehavior`](#available-settings) a `"merge"`. I valori dell'embedder vengono filtrati in modo che possano stringere la politica gestita ma non allentarla.
2. **Argomenti della riga di comando**
* Override temporanei per una sessione specifica. JSON passato tramite `--settings ` 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
3. **Impostazioni di progetto locale** (`.claude/settings.local.json`)
* Impostazioni personali specifiche del progetto
4. **Impostazioni di progetto condivise** (`.claude/settings.json`)
* Impostazioni di progetto condivise dal team nel controllo del codice sorgente
5. **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](/it/vs-code), o da un [IDE JetBrains](/it/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.
**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 impostazioni di array non si uniscono in questo modo:
* [`fallbackModel`](#available-settings) è una catena ordinata dove la posizione ha significato: il file con la precedenza più alta che la definisce fornisce l'intero valore.
* [`availableModels`](#available-settings): {/* min-version: 2.1.175 */}quando la [fonte gestita con la precedenza più alta](/it/server-managed-settings#settings-precedence) la definisce, quella lista si applica così com'è e le voci utente, progetto e locale non possono estenderla. Tra gli ambiti non gestiti gli array si uniscono come al solito. Vedi [Comportamento di unione](/it/model-config#merge-behavior).
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](/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.
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, `/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, con due eccezioni descritte nella [Nota di unione di array](#settings-precedence)
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`:
```json theme={null}
{
"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 condivisibili 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](/it/sub-agents).
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`:
```json theme={null}
{
"enabledPlugins": {
"formatter@acme-tools": true,
"deployer@acme-tools": true,
"analyzer@security-plugins": false
},
"extraKnownMarketplaces": {
"acme-tools": {
"source": {
"source": "github",
"repo": "acme-corp/claude-plugins"
}
}
}
}
```
`enabledPlugins`
Controlla quali plugin sono abilitati. Formato: `"plugin-name@marketplace-name": true/false`. Un plugin senza voce in nessun ambito ricade al suo valore [`defaultEnabled`](/it/plugins-reference#default-enablement).
**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
Le impostazioni di progetto hanno la precedenza sulle impostazioni utente, quindi impostare un plugin su `false` in `~/.claude/settings.json` non disabilita un plugin che le impostazioni `.claude/settings.json` del progetto abilitano. Per rinunciare a un plugin abilitato dal progetto sulla tua macchina, impostalo su `false` in `.claude/settings.local.json` invece.
I plugin forzatamente abilitati dalle impostazioni gestite non possono essere disabilitati in questo modo, poiché le impostazioni gestite ignorano le impostazioni locali.
L'abilitazione di un plugin da una fonte esterna come un repository GitHub o un pacchetto npm nelle impostazioni `.claude/settings.json` di un progetto non lo installa per altre persone. A partire da Claude Code v2.1.195, ogni percorso che carica i plugin chiede a ogni utente di [installare e fidarsi del plugin](/it/discover-plugins#configure-team-marketplaces) prima che venga eseguito.
**Esempio**:
```json theme={null}
{
"enabledPlugins": {
"code-formatter@team-tools": true,
"deployment-tools@team-tools": true,
"experimental-features@personal": false
}
}
```
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`**:
1. I membri del team vengono invitati a installare il marketplace quando fidano della cartella
2. I membri del team vengono quindi invitati a installare i plugin da quel marketplace
3. Gli utenti possono saltare i marketplace o i plugin indesiderati (archiviati nelle impostazioni utente)
4. L'installazione rispetta i confini di fiducia e richiede il consenso esplicito
**Esempio**:
```json theme={null}
{
"extraKnownMarketplaces": {
"acme-tools": {
"source": {
"source": "github",
"repo": "acme-corp/claude-plugins"
}
},
"security-plugins": {
"source": {
"source": "git",
"url": "https://git.example.com/security/plugins.git"
}
}
}
}
```
**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](/it/plugin-marketplaces#private-repositories) 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](/it/discover-plugins#configure-auto-updates).
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`.
```json theme={null}
{
"extraKnownMarketplaces": {
"team-tools": {
"source": {
"source": "settings",
"name": "team-tools",
"plugins": [
{
"name": "code-formatter",
"source": {
"source": "github",
"repo": "acme-corp/code-formatter"
}
}
]
}
}
}
}
```
`strictKnownMarketplaces`
**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](/it/settings#settings-files) 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 e filesystem, quindi 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, quindi gli utenti possono aggiungere qualsiasi marketplace
* Array vuoto `[]`: blocco completo, quindi 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.
1. **Repository GitHub**:
```json theme={null}
{ "source": "github", "repo": "acme-corp/approved-plugins" }
{ "source": "github", "repo": "acme-corp/security-tools", "ref": "v2.0" }
{ "source": "github", "repo": "acme-corp/plugins", "ref": "main", "path": "marketplace" }
```
Campi: `repo` (obbligatorio), `ref` (facoltativo: ramo o tag), `path` (facoltativo: sottodirectory)
2. **Repository Git**:
```json theme={null}
{ "source": "git", "url": "https://gitlab.example.com/tools/plugins.git" }
{ "source": "git", "url": "https://bitbucket.org/acme-corp/plugins.git", "ref": "production" }
{ "source": "git", "url": "ssh://git@git.example.com/plugins.git", "ref": "v3.1", "path": "approved" }
```
Campi: `url` (obbligatorio), `ref` (facoltativo: ramo o tag), `path` (facoltativo: sottodirectory)
3. **Marketplace basati su URL**:
```json theme={null}
{ "source": "url", "url": "https://plugins.example.com/marketplace.json" }
{ "source": "url", "url": "https://cdn.example.com/marketplace.json", "headers": { "Authorization": "Bearer ${TOKEN}" } }
```
Campi: `url` (obbligatorio), `headers` (facoltativo: intestazioni HTTP per l'accesso autenticato)
I marketplace basati su URL scaricano solo il file `marketplace.json`. Non scaricano i file dei plugin dal server. I plugin nei marketplace basati su URL devono utilizzare fonti esterne (URL GitHub, npm o git) piuttosto che percorsi relativi. Per i plugin con percorsi relativi, utilizza un marketplace basato su Git. Vedi [Troubleshooting](/it/plugin-marketplaces#plugins-with-relative-paths-fail-in-url-based-marketplaces) per i dettagli.
4. **Pacchetti NPM**:
```json theme={null}
{ "source": "npm", "package": "@acme-corp/claude-plugins" }
{ "source": "npm", "package": "@acme-corp/approved-marketplace" }
```
Campi: `package` (obbligatorio, supporta pacchetti con scope)
5. **Percorsi di file**:
```json theme={null}
{ "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)
6. **Percorsi di directory**:
```json theme={null}
{ "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`)
7. **Corrispondenza del modello host**:
```json theme={null}
{ "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
8. **Corrispondenza del modello di percorso**:
```json theme={null}
{ "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:
```json theme={null}
{
"strictKnownMarketplaces": [
{
"source": "github",
"repo": "acme-corp/approved-plugins"
},
{
"source": "github",
"repo": "acme-corp/security-tools",
"ref": "v2.0"
},
{
"source": "url",
"url": "https://plugins.example.com/marketplace.json"
},
{
"source": "npm",
"package": "@acme-corp/compliance-plugins"
}
]
}
```
Esempio: disabilita tutte le aggiunte del marketplace:
```json theme={null}
{
"strictKnownMarketplaces": []
}
```
Esempio: consenti tutti i marketplace da un server git interno:
```json theme={null}
{
"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:
```json theme={null}
// 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:
```json theme={null}
{
"strictKnownMarketplaces": [
{ "source": "github", "repo": "acme-corp/plugins" }
]
}
```
`extraKnownMarketplaces` richiede marketplace denominati:
```json theme={null}
{
"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`:
```json theme={null}
{
"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](/it/plugin-marketplaces#managed-marketplace-restrictions) 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.
`strictPluginOnlyCustomization` richiede Claude Code v2.1.82 o successivo. Le versioni precedenti ignorano la chiave e continuano a caricare le personalizzazioni utente e di progetto, quindi il blocco non viene applicato fino a quando i client non si aggiornano.
Il valore è `true` per bloccare tutte e quattro le superfici, oppure un array che nomina le superfici da bloccare:
```json theme={null}
{
"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`](/it/managed-mcp) |
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](/it/plugins).
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`](#available-settings) sotto la chiave `env` per applicarla a ogni sessione o distribuirla al vostro team.
Consultare il [riferimento delle variabili di ambiente](/it/env-vars) per l'elenco completo.
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](/it/tools-reference) per l'elenco completo e i dettagli del comportamento dello strumento Bash.
Vedi anche
* [Permissions](/it/permissions): sistema di permessi, sintassi delle regole, modelli specifici dello strumento e politiche gestite
* [Authentication](/it/authentication): configura l'accesso degli utenti a Claude Code
* [Debug your configuration](/it/debug-your-config): diagnostica il motivo per cui un'impostazione, un hook o un server MCP non sta avendo effetto
* [Troubleshoot installation and login](/it/troubleshoot-install): installazione, autenticazione e problemi di piattaforma