> ## 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.

# Tutte le impostazioni

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

[Torna all'indice](#all-settings)

Questa pagina di riferimento elenca ogni chiave che Claude Code legge da un file di impostazioni, più il [breve gruppo di chiavi](#global-config-settings) che mantiene in `~/.claude.json` invece. Per scegliere un file, o controllare la precedenza, inizia con [File di impostazioni e precedenza](https://code.claude.com/docs/it/settings.md).

## Indice delle impostazioni

Ogni chiave sottostante è collegata alla sua voce. L'ambito elenca i [file](https://code.claude.com/docs/it/settings.md#settings-files-and-who-they-affect) in cui può trovarsi: `User` è `~/.claude/settings.json`, `Project` è `.claude/settings.json`, `Local` è `.claude/settings.local.json` e `Managed` è [quello che la tua organizzazione distribuisce](https://code.claude.com/docs/it/managed-settings.md). `Any file` significa tutti e quattro, e `Global config` significa [`~/.claude.json`](#global-config-settings).

| Key | Description | Topic | Scope |
| :- | :- | :- | :- |
| [`advisorModel`](#advisormodel) | Scegli quale modello risponde quando Claude interroga lo [strumento advisor](https://code.claude.com/docs/it/advisor.md) | Modello e risposte | Any file |
| [`agent`](#agent) | Avvia ogni sessione come un [subagent](https://code.claude.com/docs/it/sub-agents.md) con nome, con il suo prompt, i suoi strumenti e il suo modello | Agenti, sessioni e worktree | Any file |
| [`agentPushNotifEnabled`](#agentpushnotifenabled) | Consenti a Claude di inviare una [notifica push al tuo telefono](https://code.claude.com/docs/it/remote-control.md#mobile-push-notifications) quando lo ritiene opportuno | Remoto, desktop e notifiche | Any file |
| [`allowAllClaudeAiMcps`](#allowallclaudeaimcps) | Carica i [connettori claude.ai](https://code.claude.com/docs/it/mcp.md) che Claude Code recupera autonomamente insieme a un [`managed-mcp.json`](https://code.claude.com/docs/it/managed-mcp#exclusive-control-with-managed-mcp-json) distribuito | MCP | Managed |
| [`allowClaudeInChromeWithManagedMcp`](#allowclaudeinchromewithmanagedmcp) | Consenti al server integrato [Claude in Chrome](https://code.claude.com/docs/it/chrome.md) di funzionare insieme a un [`managed-mcp.json`](https://code.claude.com/docs/it/managed-mcp#exclusive-control-with-managed-mcp-json) distribuito | MCP | Managed |
| [`allowedChannelPlugins`](#allowedchannelplugins) | Sostituisci l'allowlist predefinita dei [plugin di canale](https://code.claude.com/docs/it/channels.md#restrict-which-channel-plugins-can-run) che possono inviare messaggi | Plugin e skill | Managed |
| [`allowedHttpHookUrls`](#allowedhttphookurls) | Limita gli URL che gli [hook HTTP](https://code.claude.com/docs/it/hooks.md) possono raggiungere | Hook e automazione | Any file |
| [`allowedMcpServers`](#allowedmcpservers) | Definisci l'allowlist dei [server MCP](https://code.claude.com/docs/it/mcp.md) che gli utenti possono aggiungere | MCP | Any file |
| [`allowedProviders`](#allowedproviders) | Limita quali [provider API](https://code.claude.com/docs/it/third-party-integrations.md) una macchina può utilizzare | Autenticazione e provider | Managed |
| [`allowManagedHooksOnly`](#allowmanagedhooksonly) | Esegui solo gli [hook](https://code.claude.com/docs/it/hooks.md) che la tua organizzazione distribuisce | Hook e automazione | Managed |
| [`allowManagedMcpServersOnly`](#allowmanagedmcpserversonly) | Rendi l'allowlist [MCP](https://code.claude.com/docs/it/mcp.md) gestita l'unica che si applica | MCP | Managed |
| [`allowManagedPermissionRulesOnly`](#allowmanagedpermissionrulesonly) | Rendi le [impostazioni gestite](https://code.claude.com/docs/it/managed-settings.md) l'unica fonte delle [regole di permesso](https://code.claude.com/docs/it/permissions.md#managed-settings) | Impostazioni dei permessi | Managed |
| [`alwaysThinkingEnabled`](#alwaysthinkingenabled) | Disattiva il [ragionamento esteso](https://code.claude.com/docs/it/model-config.md#extended-thinking) per ogni sessione | Modello e risposte | Any file |
| [`apiKeyHelper`](#apikeyhelper) | Genera le [credenziali API](https://code.claude.com/docs/it/authentication.md#credential-management) con un tuo comando | Autenticazione e provider | Any file |
| [`askUserQuestionTimeout`](#askuserquestiontimeout) | Consenti a una domanda senza risposta di [continuare automaticamente](https://code.claude.com/docs/it/tools-reference.md#question-auto-continue-timeout) dopo un periodo di inattività | Interfaccia e terminale | User or managed |
| [`appendPlugins`](#appendplugins) | Esegui i [mod](https://code.claude.com/docs/it/plugins/mods/admin.md) della tua organizzazione dopo ogni mod installato da un utente | Plugin e skill | User or managed |
| [`attribution`](#attribution) | Personalizza l'attribuzione che Claude Code aggiunge ai commit e alle pull request | Git e attribuzione | Any file |
| [`attribution.commit`](#attribution-commit) | Cambia o nascondi il trailer che Claude Code aggiunge ai commit | Git e attribuzione | Any file |
| [`attribution.pr`](#attribution-pr) | Cambia o nascondi la riga di attribuzione nelle descrizioni delle pull request | Git e attribuzione | Any file |
| [`attribution.sessionUrl`](#attribution-sessionurl) | Ometti il link alla sessione claude.ai dai commit [cloud](https://code.claude.com/docs/it/claude-code-on-the-web.md) e [Remote Control](https://code.claude.com/docs/it/remote-control.md) | Git e attribuzione | Any file |
| [`autoCompactEnabled`](#autocompactenabled) | Disattiva o attiva la [compattazione automatica](https://code.claude.com/docs/it/context-window.md) | Memoria e contesto | Any file |
| [`autoCompactWindow`](#autocompactwindow) | Imposta quanto deve riempirsi il contesto prima che Claude Code esegua la [compattazione](https://code.claude.com/docs/it/context-window.md) | Memoria e contesto | Any file |
| [`autoConnectIde`](#autoconnectide) | Connettiti automaticamente a un IDE [VS Code](https://code.claude.com/docs/it/vs-code.md) o [JetBrains](https://code.claude.com/docs/it/jetbrains.md#from-external-terminals) in esecuzione da un terminale esterno | Impostazioni di configurazione globale | Global config |
| [`autoContinueAtUsageLimit`](#autocontinueatusagelimit) | Attendi nella sessione aperta e [continua l'attività automaticamente](https://code.claude.com/docs/it/interactive-mode.md#wait-for-a-usage-limit-to-reset) dopo il ripristino di un limite di utilizzo di claude.ai | Interfaccia e terminale | User or managed |
| [`autoInstallIdeExtension`](#autoinstallideextension) | Disattiva l'installazione automatica dell'[estensione IDE](https://code.claude.com/docs/it/vs-code.md#install-the-extension) da un terminale VS Code | Impostazioni di configurazione globale | Global config |
| [`autoMemoryDirectory`](#automemorydirectory) | Archivia la [memoria automatica](https://code.claude.com/docs/it/memory.md#auto-memory) in una directory a tua scelta | Memoria e contesto | Any file |
| [`autoMemoryEnabled`](#automemoryenabled) | Disattiva o attiva la [memoria automatica](https://code.claude.com/docs/it/memory.md#auto-memory) | Memoria e contesto | Any file |
| [`autoMode`](#automode) | Aggiungi le tue regole allow e deny al classificatore della [modalità auto](https://code.claude.com/docs/it/permission-modes.md#eliminate-prompts-with-auto-mode) | Impostazioni dei permessi | User or managed |
| [`autoMode.classifyAllShell`](#automode-classifyallshell) | Invia ogni comando shell al [classificatore della modalità auto](https://code.claude.com/docs/it/permission-modes.md#what-the-classifier-blocks-by-default), anche quelli che corrispondono a una regola allow ristretta | Impostazioni dei permessi | User or managed |
| [`autoScrollEnabled`](#autoscrollenabled) | [Segui il nuovo output](https://code.claude.com/docs/it/fullscreen.md#auto-follow) fino in fondo nel rendering a schermo intero | Interfaccia e terminale | Any file |
| [`autoUpdatesChannel`](#autoupdateschannel) | Segui il [canale di rilascio](https://code.claude.com/docs/it/setup.md#configure-release-channel) stable invece di latest | Aggiornamenti e versioning | Any file |
| [`availableModels`](#availablemodels) | [Limita i modelli](https://code.claude.com/docs/it/model-config.md#restrict-model-selection) che le persone possono scegliere | Modello e risposte | Any file |
| [`availableModelsMatch`](#availablemodelsmatch) | Fai in modo che ogni voce ID modello di `availableModels` [consenta solo la versione che indica](https://code.claude.com/docs/it/model-config.md#block-specific-models-or-versions) | Modello e risposte | Managed |
| [`awaySummaryEnabled`](#awaysummaryenabled) | Disattiva il [riepilogo della sessione](https://code.claude.com/docs/it/interactive-mode.md#session-recap) mostrato quando torni al terminale | Remoto, desktop e notifiche | Any file |
| [`awsAuthRefresh`](#awsauthrefresh) | Aggiorna le [credenziali Bedrock](https://code.claude.com/docs/it/amazon-bedrock.md#advanced-credential-configuration) scadute in `.aws` con un tuo comando | Autenticazione e provider | Any file |
| [`awsCredentialExport`](#awscredentialexport) | Fornisci le [credenziali Bedrock](https://code.claude.com/docs/it/amazon-bedrock.md#advanced-credential-configuration) come JSON da un tuo comando | Autenticazione e provider | Any file |
| [`axScreenReader`](#axscreenreader) | Genera un [output adatto agli screen reader](https://code.claude.com/docs/it/accessibility.md) | Interfaccia e terminale | User or managed |
| [`bashEditDiffEnabled`](#basheditdiffenabled) | Registra i [file modificati durante l'esecuzione di un comando Bash](https://code.claude.com/docs/it/hooks.md#bash) in ogni modalità di permesso | Interfaccia e terminale | User or managed |
| [`bashOutputMaxChars`](#bashoutputmaxchars) | Imposta quanta parte dell'[output](https://code.claude.com/docs/it/tools-reference.md#output-limits) di un comando riuscito Claude riceve inline | Memoria e contesto | Any file |
| [`blockedMarketplaces`](#blockedmarketplaces) | Blocca le fonti dei [marketplace di plugin](https://code.claude.com/docs/it/plugins/overview.md) per la tua organizzazione | Plugin e skill | Managed |
| [`browserExternalPageTools`](#browserexternalpagetools) | Tieni gli strumenti di Claude lontani dalle pagine esterne nel riquadro Browser di [desktop](https://code.claude.com/docs/it/desktop.md) | Strumenti | Managed |
| [`channelsEnabled`](#channelsenabled) | Consenti i [canali](https://code.claude.com/docs/it/channels.md#enable-channels-for-your-organization) per la tua organizzazione | Plugin e skill | Managed |
| [`claudeInChromeDefaultEnabled`](#claudeinchromedefaultenabled) | Attiva l'[integrazione con Chrome](https://code.claude.com/docs/it/chrome.md) all'avvio di una sessione, nella CLI interattiva e nell'estensione VS Code | Impostazioni di configurazione globale | Global config |
| [`claudeMd`](#claudemd) | Inserisci istruzioni [CLAUDE.md](https://code.claude.com/docs/it/memory.md#deploy-organization-wide-claude-md) valide per tutta l'organizzazione dalle impostazioni gestite | Memoria e contesto | Managed |
| [`claudeMdExcludes`](#claudemdexcludes) | Salta file [CLAUDE.md](https://code.claude.com/docs/it/memory.md#exclude-specific-claude-md-files) specifici quando viene caricata la memoria | Memoria e contesto | Any file |
| [`cleanupPeriodDays`](#cleanupperioddays) | Scegli per quanti giorni Claude Code conserva le [trascrizioni](https://code.claude.com/docs/it/data-usage.md#data-retention) prima di eliminarle | Privacy e telemetria | Any file |
| [`companyAnnouncements`](#companyannouncements) | Mostra gli annunci della tua organizzazione all'avvio | Interfaccia e terminale | Any file |
| [`copyFullResponse`](#copyfullresponse) | Fai in modo che [`/copy`](https://code.claude.com/docs/it/commands) copi la risposta completa senza mostrare il selettore | Impostazioni di configurazione globale | Global config |
| [`copyOnSelect`](#copyonselect) | Disattiva la copia automatica del testo che selezioni con il mouse nel [rendering a schermo intero](https://code.claude.com/docs/it/fullscreen.md#use-the-mouse) e nella vista agenti | Impostazioni di configurazione globale | Global config |
| [`crossSessionInbound`](#crosssessioninbound) | Scegli se Claude Code consegna i [messaggi dalle tue altre sessioni](https://code.claude.com/docs/it/cross-session-messaging.md#control-inbound-messages), mostra un avviso senza consegnarli o li rifiuta | Agenti, sessioni e worktree | Any file |
| [`defaultShell`](#defaultshell) | Scegli se Bash o PowerShell esegue i comandi shell che digiti con il [prefisso `!`](https://code.claude.com/docs/it/interactive-mode#shell-mode-with-prefix) | Interfaccia e terminale | Any file |
| [`defaultToAgentsView`](#defaulttoagentsview) | Apri la [vista agenti](https://code.claude.com/docs/it/agent-view.md) invece di una nuova conversazione quando esegui `claude` senza argomenti | Impostazioni di configurazione globale | Global config |
| [`deniedMcpServers`](#deniedmcpservers) | Blocca [server MCP](https://code.claude.com/docs/it/mcp.md) specifici per URL, comando o nome | MCP | Any file |
| [`deniedModels`](#deniedmodels) | [Blocca modelli specifici](https://code.claude.com/docs/it/model-config.md#block-specific-models-or-versions), anche quelli consentiti da `availableModels` | Modello e risposte | Managed |
| [`desktopSessionCleanupPeriodDays`](#desktopsessioncleanupperioddays) | Imposta un limite di età in giorni per le [trascrizioni di Claude Desktop e Cowork](https://code.claude.com/docs/it/claude-directory.md#cleaned-up-automatically) | Privacy e telemetria | User or managed |
| [`dialogExpiry`](#dialogexpiry) | Imposta per quanto tempo Claude Code attende che [Remote Control](https://code.claude.com/docs/it/remote-control.md) o un host SDK risponda a una finestra di dialogo inoltrata prima di annullarla | Interfaccia e terminale | User or managed |
| [`diffTool`](#difftool) | Scegli se le modifiche ai file proposte da Claude si aprono nel visualizzatore diff di [VS Code](https://code.claude.com/docs/it/vs-code.md) o [JetBrains](https://code.claude.com/docs/it/jetbrains.md#features) o restano nel terminale | Impostazioni di configurazione globale | Global config |
| [`disableAgentView`](#disableagentview) | Disattiva gli agenti in background e la [vista agenti](https://code.claude.com/docs/it/agent-view.md) | Agenti, sessioni e worktree | Any file |
| [`disableAllHooks`](#disableallhooks) | Disattiva in una volta sola gli [hook](https://code.claude.com/docs/it/hooks.md), una [riga di stato](https://code.claude.com/docs/it/statusline.md) personalizzata e un comando personalizzato di [suggerimento file `@`](https://code.claude.com/docs/it/interactive-mode#quick-commands) | Hook e automazione | Any file |
| [`disableArtifact`](#disableartifact) | Deprecato; usa `enableArtifact` per disattivare lo [strumento Artifact](https://code.claude.com/docs/it/artifacts.md) | Remoto, desktop e notifiche | Any file |
| [`disableAutoMode`](#disableautomode) | Rimuovi la [modalità auto](https://code.claude.com/docs/it/permission-modes.md#eliminate-prompts-with-auto-mode) dal ciclo delle modalità di permesso | Impostazioni dei permessi | Any file |
| [`disableBrowserExternalNavigation`](#disablebrowserexternalnavigation) | Limita il riquadro Browser di [desktop](https://code.claude.com/docs/it/desktop.md) a localhost per le persone e per Claude | Strumenti | Managed |
| [`disableBundledSkills`](#disablebundledskills) | Disattiva le [skill](https://code.claude.com/docs/it/skills.md#bundled-skills) e i [workflow](https://code.claude.com/docs/it/workflows.md) inclusi in Claude Code | Plugin e skill | Any file |
| [`disableClaudeAiConnectors`](#disableclaudeaiconnectors) | Disattiva i [connettori claude.ai](https://code.claude.com/docs/it/mcp.md#disable-claude-ai-connectors) in modo che Claude Code non li recuperi | MCP | Any file |
| [`disableCommandPluginSources`](#disablecommandpluginsources) | Blocca i [plugin](https://code.claude.com/docs/it/plugins/overview.md) che si installano eseguendo un comando dichiarato dal marketplace | Plugin e skill | Managed |
| [`disableDeepLinkRegistration`](#disabledeeplinkregistration) | Impedisci a Claude Code di registrare il [gestore `claude-cli://`](https://code.claude.com/docs/it/deep-links) | Remoto, desktop e notifiche | Any file |
| [`disableDesktopLocalSessions`](#disabledesktoplocalsessions) | Disattiva le [sessioni Code di Desktop](https://code.claude.com/docs/it/desktop.md#local-sessions-on-managed-devices) eseguite sul dispositivo, lasciando SSH verso altri host e il cloud | Remoto, desktop e notifiche | Managed |
| [`disabledMcpjsonServers`](#disabledmcpjsonservers) | Rifiuta server specifici dal [`.mcp.json`](https://code.claude.com/docs/it/mcp#project-scope) di un progetto | MCP | Any file |
| [`disableMobileSimulatorTools`](#disablemobilesimulatortools) | Blocca gli strumenti di Claude nel riquadro iOS Simulator di [desktop](https://code.claude.com/docs/it/desktop.md) | Strumenti | Managed |
| [`disableRemoteControl`](#disableremotecontrol) | Disattiva [Remote Control](https://code.claude.com/docs/it/remote-control.md) ovunque possa essere avviato | Remoto, desktop e notifiche | Any file |
| [`disableSideloadFlags`](#disablesideloadflags) | Rifiuta i flag CLI che caricano tramite sideload [plugin](https://code.claude.com/docs/it/plugins/overview.md), [subagent](https://code.claude.com/docs/it/sub-agents.md) e [server MCP](https://code.claude.com/docs/it/mcp.md) | Impostazioni aziendali e gestite | Managed |
| [`disableSkillShellExecution`](#disableskillshellexecution) | Impedisci alle [skill](https://code.claude.com/docs/it/skills.md) e ai comandi personalizzati di eseguire shell inline | Plugin e skill | Any file |
| [`disableWorkflows`](#disableworkflows) | Disattiva i [workflow dinamici](https://code.claude.com/docs/it/workflows.md) per tutti; usa `enableWorkflows` per te stesso | Hook e automazione | Any file |
| [`editorMode`](#editormode) | Usa le [combinazioni di tasti vim](https://code.claude.com/docs/it/interactive-mode.md#vim-editor-mode) nel prompt di input | Interfaccia e terminale | Any file |
| [`effortLevel`](#effortlevel) | Imposta un [livello di sforzo](https://code.claude.com/docs/it/model-config.md#adjust-effort-level) predefinito per i modelli che non hanno un proprio livello salvato | Modello e risposte | Any file |
| [`emojiCompletionEnabled`](#emojicompletionenabled) | Disattiva i [suggerimenti e la sostituzione delle emoji `:shortcode:`](https://code.claude.com/docs/it/interactive-mode#emoji-shortcodes) nell'input del prompt | Interfaccia e terminale | Any file |
| [`enableAllProjectMcpServers`](#enableallprojectmcpservers) | Approva ogni server nei file [`.mcp.json`](https://code.claude.com/docs/it/mcp#project-server-approvals-and-workspace-trust) di progetto senza richiesta di conferma | MCP | Any file |
| [`enableArtifact`](#enableartifact) | Disattiva lo [strumento Artifact](https://code.claude.com/docs/it/artifacts.md) con un `false` in qualsiasi file; nessun file può riattivarlo | Remoto, desktop e notifiche | Any file |
| [`enabledMcpjsonServers`](#enabledmcpjsonservers) | Approva server specifici dal [`.mcp.json`](https://code.claude.com/docs/it/mcp#project-server-approvals-and-workspace-trust) di un progetto | MCP | Any file |
| [`enabledPlugins`](#enabledplugins) | Attiva o disattiva singoli [plugin](https://code.claude.com/docs/it/plugins/overview.md) per ambito | Plugin e skill | Any file |
| [`enableWorkflows`](#enableworkflows) | Attiva o disattiva i [workflow dinamici](https://code.claude.com/docs/it/workflows.md) rispetto al valore predefinito del tuo piano | Hook e automazione | Any file |
| [`enforceAvailableModels`](#enforceavailablemodels) | Mantieni la [scelta Default di `/model`](https://code.claude.com/docs/it/model-config#enforce-the-allowlist-for-the-default-model) all'interno della tua allowlist `availableModels` | Modello e risposte | Any file |
| [`env`](#env) | Imposta [variabili d'ambiente](https://code.claude.com/docs/it/env-vars.md#in-settings-files) per ogni sessione e i suoi sottoprocessi | Memoria e contesto | Any file |
| [`externalEditorContext`](#externaleditorcontext) | Mostra l'ultima risposta di Claude come commenti quando premi [Ctrl+G](https://code.claude.com/docs/it/interactive-mode.md#general-controls) per modificare | Impostazioni di configurazione globale | Global config |
| [`extraKnownMarketplaces`](#extraknownmarketplaces) | Registra [marketplace](https://code.claude.com/docs/it/plugins/overview.md) per un repository o un'organizzazione | Plugin e skill | Any file |
| [`fallbackModel`](#fallbackmodel) | Indica [modelli di riserva](https://code.claude.com/docs/it/model-config.md#fallback-model-chains) da usare quando quello principale è sovraccarico | Modello e risposte | Any file |
| [`fastMode`](#fastmode) | Attiva la [modalità veloce](https://code.claude.com/docs/it/fast-mode.md) per le sessioni in cui è disponibile | Modello e risposte | Any file |
| [`fastModePerSessionOptIn`](#fastmodepersessionoptin) | Richiedi alle persone di attivare la [modalità veloce](https://code.claude.com/docs/it/fast-mode.md) in ogni sessione | Modello e risposte | Any file |
| [`feedbackDrafts`](#feedbackdrafts) | Controlla se Claude mette in coda [bozze di feedback](https://code.claude.com/docs/it/tools-reference.md#sendfeedback-tool-behavior) da farti rivedere | Privacy e telemetria | User or managed |
| [`feedbackSurveyRate`](#feedbacksurveyrate) | Cambia la frequenza con cui compare il [sondaggio sulla qualità della sessione](https://code.claude.com/docs/it/data-usage.md#session-quality-surveys) | Privacy e telemetria | Any file |
| [`fileCheckpointingEnabled`](#filecheckpointingenabled) | Disattiva o attiva gli snapshot dei file che [`/rewind`](https://code.claude.com/docs/it/checkpointing) ripristina | Memoria e contesto | Any file |
| [`fileSuggestion`](#filesuggestion) | Fornisci l'[autocompletamento dei file `@`](https://code.claude.com/docs/it/interactive-mode#quick-commands) da un tuo comando | Interfaccia e terminale | Any file |
| [`footerLinksRegexes`](#footerlinksregexes) | Trasforma gli ID di issue o di revisione nell'output in [link cliccabili](https://code.claude.com/docs/it/statusline.md#clickable-links) sotto la casella di input | Interfaccia e terminale | User or managed |
| [`forceLoginGatewayUrl`](#forcelogingatewayurl) | Imposta l'[URL del gateway](https://code.claude.com/docs/it/claude-apps-gateway#set-the-gateway-url) a cui si connette la schermata di accesso | Autenticazione e provider | User or managed |
| [`forceLoginMethod`](#forceloginmethod) | [Limita l'accesso](https://code.claude.com/docs/it/authentication.md#restrict-login-to-your-organization) a claude.ai, Claude Console o un [gateway cloud](https://code.claude.com/docs/it/claude-apps-gateway) | Autenticazione e provider | Any file |
| [`forceLoginOrgUUID`](#forceloginorguuid) | [Vincola gli accessi a claude.ai alla tua organizzazione](https://code.claude.com/docs/it/authentication.md#restrict-login-to-your-organization); solo una fonte gestita lo applica | Autenticazione e provider | Any file |
| [`forceRemoteSettingsRefresh`](#forceremotesettingsrefresh) | Blocca l'avvio finché le [impostazioni gestite dal server](https://code.claude.com/docs/it/server-managed-settings.md) non vengono recuperate di nuovo | Impostazioni aziendali e gestite | Managed |
| [`gatewayInternalNetworks`](#gatewayinternalnetworks) | Consenti a `/login` di raggiungere un [gateway cloud](https://code.claude.com/docs/it/claude-apps-gateway#allow-a-gateway-on-public-address-space-you-own) su uno spazio IPv4 pubblico che la tua organizzazione usa internamente | Autenticazione e provider | Managed |
| [`gcpAuthRefresh`](#gcpauthrefresh) | Aggiorna le [credenziali Google Cloud](https://code.claude.com/docs/it/google-vertex-ai.md#advanced-credential-configuration) con un tuo comando | Autenticazione e provider | Any file |
| [`hooks`](#hooks) | Esegui i tuoi comandi come [hook](https://code.claude.com/docs/it/hooks.md) in determinati punti del ciclo di vita di Claude Code | Hook e automazione | Any file |
| [`httpHookAllowedEnvVars`](#httphookallowedenvvars) | Limita quali variabili d'ambiente gli [hook HTTP](https://code.claude.com/docs/it/hooks.md) possono inserire nelle intestazioni | Hook e automazione | Any file |
| [`idleCompaction`](#idlecompaction) | Impedisci a Claude Code di compattare una conversazione lunga da cui ti sei allontanato | Memoria e contesto | Any file |
| [`includeCoAuthoredBy`](#includecoauthoredby) | Deprecato; usa `attribution` per nascondere o cambiare l'attribuzione di commit e PR | Git e attribuzione | Any file |
| [`includeGitInstructions`](#includegitinstructions) | Rimuovi le istruzioni integrate su commit e PR dal contesto di Claude | Git e attribuzione | Any file |
| [`inputNeededNotifEnabled`](#inputneedednotifenabled) | Ricevi una [notifica push](https://code.claude.com/docs/it/remote-control.md#mobile-push-notifications) quando Claude ti sta aspettando | Remoto, desktop e notifiche | Any file |
| [`isolatePeerMachines`](#isolatepeermachines) | Fai in modo che ti venga chiesta conferma prima che Claude [invii messaggi a una delle tue sessioni su un'altra macchina](https://code.claude.com/docs/it/cross-session-messaging.md#require-approval-for-cross-machine-messages) | Agenti, sessioni e worktree | Any file |
| [`keybindingFlavor`](#keybindingflavor) | Deprecato e senza effetto; le scorciatoie di modifica delle parole [seguono sempre le convenzioni readline](https://code.claude.com/docs/it/interactive-mode.md#make-ctrl-w-delete-back-to-whitespace) | Interfaccia e terminale | Any file |
| [`language`](#language) | Fai rispondere Claude in una lingua diversa dall'inglese | Modello e risposte | Any file |
| [`leftArrowOpensAgents`](#leftarrowopensagents) | Disattiva la scorciatoia `←` che [manda la sessione in background e apre la vista agenti](https://code.claude.com/docs/it/agent-view.md#switch-sessions-without-leaving-the-terminal) | Impostazioni di configurazione globale | Global config |
| [`managedMcpServers`](#managedmcpservers) | Fornisci [server MCP](https://code.claude.com/docs/it/managed-mcp.md#provide-servers-through-managed-settings) remoti a ogni utente insieme a quelli che aggiunge | MCP | Managed |
| [`managedSourcesBehavior`](#managedsourcesbehavior) | Combina ogni [fonte gestita](https://code.claude.com/docs/it/managed-settings.md#how-claude-code-combines-managed-sources) che distribuisci invece di usare solo quella con la priorità più alta | Impostazioni aziendali e gestite | Managed |
| [`maxEffortLevel`](#maxeffortlevel) | Limita il [livello di sforzo](https://code.claude.com/docs/it/model-config.md#adjust-effort-level) per tutti i modelli o per singolo modello, su ogni provider | Modello e risposte | Any file |
| [`maxProseWidth`](#maxprosewidth) | Limita la larghezza della prosa nelle risposte di Claude in un terminale ampio | Interfaccia e terminale | Any file |
| [`minimumVersion`](#minimumversion) | Impedisci agli [aggiornamenti automatici](https://code.claude.com/docs/it/setup.md#pin-a-minimum-version) di installare versioni inferiori a una data versione | Aggiornamenti e versioning | Any file |
| [`model`](#model) | Cambia il [modello](https://code.claude.com/docs/it/model-config.md#set-a-default-model-for-new-sessions) con cui si avvia Claude Code | Modello e risposte | Any file |
| [`modelOverrides`](#modeloverrides) | [Mappa gli ID dei modelli](https://code.claude.com/docs/it/model-config.md#override-model-ids-per-version) agli ID del tuo provider, come gli ARN di Bedrock | Modello e risposte | Any file |
| [`modelPicker`](#modelpicker) | Scegli quali modelli elenca il [selettore `/model`](https://code.claude.com/docs/it/model-config#available-models), nel tuo ordine e con le tue etichette | Modello e risposte | User or managed |
| [`modelPricing`](#modelpricing) | Riporta la spesa alle tariffe contrattuali della tua organizzazione invece che al prezzo di listino | Modello e risposte | Managed |
| [`modelSettings`](#modelsettings) | Mantieni un [livello di sforzo](https://code.claude.com/docs/it/model-config.md#adjust-effort-level) o una [finestra di compattazione automatica](https://code.claude.com/docs/it/model-config.md#set-the-auto-compact-window) salvati per ogni modello, o limita lo sforzo di un modello | Modello e risposte | Any file |
| [`otelHeadersHelper`](#otelheadershelper) | Genera intestazioni [OpenTelemetry](https://code.claude.com/docs/it/monitoring-usage.md#dynamic-headers) a rotazione con un tuo comando | Autenticazione e provider | Any file |
| [`outputStyle`](#outputstyle) | Cambia il ruolo, il tono e il formato di output di Claude con uno [stile di output](https://code.claude.com/docs/it/output-styles.md) | Modello e risposte | Any file |
| [`parentSettingsBehavior`](#parentsettingsbehavior) | Applica o ignora le restrizioni che un [host SDK o IDE](https://code.claude.com/docs/it/managed-settings.md#let-an-embedding-host-add-policy) passa quando distribuisci [impostazioni gestite](https://code.claude.com/docs/it/managed-settings.md) | Impostazioni aziendali e gestite | Managed |
| [`permissionExplainerEnabled`](#permissionexplainerenabled) | Rimosso nella v2.1.257, insieme alla spiegazione dei comandi con `Ctrl+E` nelle richieste di permesso della shell | Impostazioni di configurazione globale | Global config |
| [`permissions`](#permissions) | Imposta le regole allow, ask e deny e la [modalità di permesso](https://code.claude.com/docs/it/permission-modes.md) iniziale | Impostazioni dei permessi | Any file |
| [`permissions.additionalDirectories`](#permissions-additionaldirectories) | Concedi a Claude l'accesso ai file nelle [directory esterne a quella corrente](https://code.claude.com/docs/it/permissions.md#working-directories) | Impostazioni dei permessi | Any file |
| [`permissions.allow`](#permissions-allow) | Approva gli [usi degli strumenti](https://code.claude.com/docs/it/permissions.md#permission-rule-syntax) elencati senza richiesta di conferma | Impostazioni dei permessi | Any file |
| [`permissions.ask`](#permissions-ask) | Chiedi sempre conferma prima degli [usi degli strumenti](https://code.claude.com/docs/it/permissions.md#permission-rule-syntax) elencati | Impostazioni dei permessi | Any file |
| [`permissions.blockReadsOutsideWorkingDirectories`](#permissions-blockreadsoutsideworkingdirectories) | Fai in modo che gli strumenti per i file rifiutino le letture al di fuori delle [directory di lavoro](https://code.claude.com/docs/it/permissions.md#working-directories) in ogni modalità di permesso | Impostazioni dei permessi | Any file |
| [`permissions.defaultMode`](#permissions-defaultmode) | Imposta la [modalità di permesso](https://code.claude.com/docs/it/permission-modes.md#which-mode-a-session-starts-in) con cui iniziano le nuove sessioni | Impostazioni dei permessi | Any file |
| [`permissions.deny`](#permissions-deny) | Blocca gli [usi degli strumenti](https://code.claude.com/docs/it/permissions.md#permission-rule-syntax) elencati, incluse le letture di file che contengono segreti | Impostazioni dei permessi | Any file |
| [`permissions.disableBypassPermissionsMode`](#permissions-disablebypasspermissionsmode) | Impedisci a chiunque di entrare nella [modalità bypassPermissions](https://code.claude.com/docs/it/permission-modes.md#skip-all-checks-with-bypasspermissions-mode) | Impostazioni dei permessi | Any file |
| [`plansDirectory`](#plansdirectory) | Scegli dove il [plan mode](https://code.claude.com/docs/it/permission-modes.md#analyze-before-you-edit-with-plan-mode) scrive i file dei piani | Memoria e contesto | Any file |
| [`pluginConfigs`](#pluginconfigs) | Archivia le risposte che hai dato alla finestra di dialogo di configurazione di un [plugin](https://code.claude.com/docs/it/plugins/overview.md) | Plugin e skill | User or managed |
| [`pluginSuggestionMarketplaces`](#pluginsuggestionmarketplaces) | Scegli quali [marketplace](https://code.claude.com/docs/it/plugins/org.md#restrict-what-users-can-install) possono mostrare suggerimenti di installazione dei plugin in `/plugin` | Plugin e skill | Managed |
| [`pluginTrustMessage`](#plugintrustmessage) | Aggiungi un tuo testo all'avviso di attendibilità dei [plugin](https://code.claude.com/docs/it/plugins/overview.md) | Plugin e skill | Managed |
| [`policyHelper`](#policyhelper) | Esegui un eseguibile che calcola le [impostazioni gestite](https://code.claude.com/docs/it/managed-settings.md#compute-the-policy-with-a-helper-program) all'avvio | Impostazioni aziendali e gestite | Managed |
| [`policyHelper.path`](#policyhelper-path) | Indica l'[eseguibile helper](https://code.claude.com/docs/it/managed-settings.md#compute-the-policy-with-a-helper-program) che Claude Code esegue | Impostazioni aziendali e gestite | Managed |
| [`policyHelper.refreshIntervalMs`](#policyhelper-refreshintervalms) | Riesegui l'[helper](https://code.claude.com/docs/it/managed-settings.md#compute-the-policy-with-a-helper-program) in background a intervalli regolari | Impostazioni aziendali e gestite | Managed |
| [`policyHelper.timeoutMs`](#policyhelper-timeoutms) | Imposta per quanto tempo Claude Code attende l'[helper](https://code.claude.com/docs/it/managed-settings.md#compute-the-policy-with-a-helper-program) | Impostazioni aziendali e gestite | Managed |
| [`preferredNotifChannel`](#preferrednotifchannel) | Scegli un [segnale acustico del terminale o una notifica desktop](https://code.claude.com/docs/it/terminal-config.md#get-a-terminal-bell-or-notification) per il completamento delle attività | Remoto, desktop e notifiche | Any file |
| [`prefersReducedMotion`](#prefersreducedmotion) | [Riduci o disattiva](https://code.claude.com/docs/it/accessibility.md#accessibility-settings) le animazioni di spinner, shimmer e flash | Interfaccia e terminale | Any file |
| [`prependPlugins`](#prependplugins) | Esegui i [mod](https://code.claude.com/docs/it/plugins/mods/admin.md) della tua organizzazione prima di ogni mod installato da un utente | Plugin e skill | User or managed |
| [`processWrapper`](#processwrapper) | Esegui i processi in background di Claude Code tramite un [launcher aziendale](https://code.claude.com/docs/it/corporate-launcher.md) su macOS e Linux | Agenti, sessioni e worktree | User or managed |
| [`promptCacheTtl`](#promptcachettl) | Scegli la [durata della cache del prompt](https://code.claude.com/docs/it/prompt-caching.md#cache-lifetime) per la conversazione principale | Modello e risposte | Any file |
| [`promptSuggestionEnabled`](#promptsuggestionenabled) | Nascondi i [suggerimenti di prompt](https://code.claude.com/docs/it/interactive-mode.md#prompt-suggestions) in grigio nella casella di input | Interfaccia e terminale | Any file |
| [`prStatusFooterEnabled`](#prstatusfooterenabled) | Disattiva il badge dello [stato della revisione PR](https://code.claude.com/docs/it/interactive-mode.md#pr-review-status) nel piè di pagina del prompt e il controllo della pull request che lo alimenta | Impostazioni di configurazione globale | Global config |
| [`prUrlTemplate`](#prurltemplate) | Fai puntare i link alle PR a uno strumento interno di code review invece che a github.com | Git e attribuzione | Any file |
| [`remote.defaultEnvironmentId`](#remote-defaultenvironmentid) | Scegli l'[ambiente cloud](https://code.claude.com/docs/it/cloud-environments.md) predefinito per `claude --cloud`; un ID `ccpool_` self-hosted viene letto solo dalle impostazioni utente e gestite e da `--settings` | Remoto, desktop e notifiche | Any file |
| [`remoteControlAtStartup`](#remotecontrolatstartup) | Connetti [Remote Control](https://code.claude.com/docs/it/remote-control.md#enable-remote-control-for-all-sessions) automaticamente all'avvio di una sessione | Remoto, desktop e notifiche | Any file |
| [`requiredMaximumVersion`](#requiredmaximumversion) | [Rifiuta l'avvio](https://code.claude.com/docs/it/setup.md#pin-a-minimum-version) su una versione più recente di quella consentita dalla tua organizzazione | Aggiornamenti e versioning | Managed |
| [`requiredMinimumVersion`](#requiredminimumversion) | [Rifiuta l'avvio](https://code.claude.com/docs/it/setup.md#pin-a-minimum-version) su una versione più vecchia di quella richiesta dalla tua organizzazione | Aggiornamenti e versioning | Managed |
| [`respectGitignore`](#respectgitignore) | Escludi i file ignorati da git dal [selettore di file `@`](https://code.claude.com/docs/it/interactive-mode#quick-commands) | Interfaccia e terminale | Any file |
| [`respondToBashCommands`](#respondtobashcommands) | Impedisci a Claude di rispondere dopo l'esecuzione di un [comando shell `!`](https://code.claude.com/docs/it/interactive-mode#shell-mode-with-prefix) | Interfaccia e terminale | Any file |
| [`sandbox`](#sandbox) | [Isola i comandi Bash](https://code.claude.com/docs/it/sandboxing.md) dal tuo filesystem e dalla rete su macOS, Linux e WSL2 | Impostazioni sandbox | Any file |
| [`sandbox.allowAppleEvents`](#sandbox-allowappleevents) | Consenti ai comandi in [sandbox](https://code.claude.com/docs/it/sandboxing.md) di inviare Apple Events su macOS | Impostazioni sandbox | User or managed |
| [`sandbox.allowNestedUserNamespaces`](#sandbox-allownestedusernamespaces) | Consenti ai comandi in [sandbox](https://code.claude.com/docs/it/sandboxing.md#chromium-or-rootless-podman-fails-inside-the-sandbox-on-linux) di creare user namespace su Linux e WSL2 | Impostazioni sandbox | User or managed |
| [`sandbox.allowUnsandboxedCommands`](#sandbox-allowunsandboxedcommands) | Consenti a Claude di riprovare un comando bloccato al di fuori della [sandbox](https://code.claude.com/docs/it/sandboxing.md#the-unsandboxed-retry-escape-hatch), oppure vietalo | Impostazioni sandbox | Any file |
| [`sandbox.autoAllowBashIfSandboxed`](#sandbox-autoallowbashifsandboxed) | Esegui i comandi in [sandbox](https://code.claude.com/docs/it/sandboxing.md#auto-allow-mode) senza richiesta di permesso | Impostazioni sandbox | Any file |
| [`sandbox.bwrapPath`](#sandbox-bwrappath) | Fai puntare la [sandbox](https://code.claude.com/docs/it/sandboxing.md) a un binario bubblewrap al di fuori di `PATH` | Impostazioni sandbox | Managed |
| [`sandbox.credentials`](#sandbox-credentials) | Nascondi o maschera file e variabili di credenziali all'interno della [sandbox](https://code.claude.com/docs/it/sandboxing.md#protect-credentials) | Impostazioni sandbox | Any file |
| [`sandbox.credentials.allowPlaintextInject`](#sandbox-credentials-allowplaintextinject) | Consenti alle [credenziali mascherate](https://code.claude.com/docs/it/sandboxing.md#mask-credentials) di raggiungere servizi HTTP in chiaro su reti di test attendibili | Impostazioni sandbox | User or managed |
| [`sandbox.credentials.awsPairs`](#sandbox-credentials-awspairs) | Collega variabili di chiavi AWS con nomi personalizzati in un'unica credenziale per la [nuova firma](https://code.claude.com/docs/it/sandboxing.md#re-sign-aws-requests) | Impostazioni sandbox | User or managed |
| [`sandbox.credentials.envVars`](#sandbox-credentials-envvars) | Rimuovi o maschera una variabile d'ambiente all'interno della [sandbox](https://code.claude.com/docs/it/sandboxing.md#mask-environment-variables) | Impostazioni sandbox | Any file |
| [`sandbox.credentials.files`](#sandbox-credentials-files) | Blocca o maschera le letture di un file di credenziali all'interno della [sandbox](https://code.claude.com/docs/it/sandboxing.md#mask-credential-files) | Impostazioni sandbox | Any file |
| [`sandbox.credentials.sigv4`](#sandbox-credentials-sigv4) | Scegli se le richieste in streaming, prefirmate o [richieste AWS SigV4A](https://code.claude.com/docs/it/sandboxing.md#re-sign-aws-requests) falliscono o passano inalterate | Impostazioni sandbox | User or managed |
| [`sandbox.enabled`](#sandbox-enabled) | Attiva il [sandboxing di Bash](https://code.claude.com/docs/it/sandboxing.md#get-started) su macOS, Linux e WSL2 | Impostazioni sandbox | Any file |
| [`sandbox.enableWeakerNestedSandbox`](#sandbox-enableweakernestedsandbox) | Esegui la [sandbox](https://code.claude.com/docs/it/sandboxing.md) Linux all'interno di un container senza privilegi | Impostazioni sandbox | Any file |
| [`sandbox.enableWeakerNetworkIsolation`](#sandbox-enableweakernetworkisolation) | Consenti a `gh`, `gcloud` e `terraform` di verificare TLS dietro un proxy MITM all'interno della [sandbox](https://code.claude.com/docs/it/sandboxing.md#go-based-clis-fail-tls-verification-on-macos) su macOS | Impostazioni sandbox | Any file |
| [`sandbox.excludedCommands`](#sandbox-excludedcommands) | Indica i comandi che Claude Code può eseguire al di fuori della [sandbox](https://code.claude.com/docs/it/sandboxing.md) | Impostazioni sandbox | Any file |
| [`sandbox.failIfUnavailable`](#sandbox-failifunavailable) | Rifiuta l'avvio quando la [sandbox](https://code.claude.com/docs/it/sandboxing.md) non può avviarsi, invece di procedere senza sandbox | Impostazioni sandbox | Any file |
| [`sandbox.filesystem`](#sandbox-filesystem) | Controlla quali percorsi i comandi in [sandbox](https://code.claude.com/docs/it/sandboxing.md#filesystem-isolation) possono leggere e scrivere | Impostazioni sandbox | Any file |
| [`sandbox.filesystem.allowManagedReadPathsOnly`](#sandbox-filesystem-allowmanagedreadpathsonly) | Impedisci agli sviluppatori di riaprire i [percorsi di lettura bloccati dalla tua organizzazione](https://code.claude.com/docs/it/sandboxing.md#keep-developers-from-widening-the-policy) | Impostazioni sandbox | Managed |
| [`sandbox.filesystem.allowRead`](#sandbox-filesystem-allowread) | Riapri la lettura all'interno di un'area bloccata da [`denyRead`](#sandbox-filesystem-denyread) | Impostazioni sandbox | Any file |
| [`sandbox.filesystem.allowWrite`](#sandbox-filesystem-allowwrite) | Aggiungi percorsi in cui i comandi in [sandbox](https://code.claude.com/docs/it/sandboxing.md) possono scrivere | Impostazioni sandbox | Any file |
| [`sandbox.filesystem.denyRead`](#sandbox-filesystem-denyread) | Impedisci ai comandi in [sandbox](https://code.claude.com/docs/it/sandboxing.md) di leggere percorsi specifici | Impostazioni sandbox | Any file |
| [`sandbox.filesystem.denyWrite`](#sandbox-filesystem-denywrite) | Impedisci ai comandi in [sandbox](https://code.claude.com/docs/it/sandboxing.md) di scrivere in percorsi specifici | Impostazioni sandbox | Any file |
| [`sandbox.filesystem.disabled`](#sandbox-filesystem-disabled) | [Disattiva l'isolamento del filesystem](https://code.claude.com/docs/it/sandboxing.md#disable-filesystem-isolation) mantenendo l'isolamento di rete | Impostazioni sandbox | User or managed |
| [`sandbox.ignoreViolations`](#sandbox-ignoreviolations) | Silenzia le segnalazioni di violazione per i percorsi che un comando sonda in modo previsto | Impostazioni sandbox | Any file |
| [`sandbox.network`](#sandbox-network) | Controlla quali host, porte e socket possono raggiungere i comandi in [sandbox](https://code.claude.com/docs/it/sandboxing.md#network-isolation) | Impostazioni sandbox | Any file |
| [`sandbox.network.allowAllUnixSockets`](#sandbox-network-allowallunixsockets) | Consenti ai comandi in [sandbox](https://code.claude.com/docs/it/sandboxing.md) di connettersi a qualsiasi socket Unix | Impostazioni sandbox | Any file |
| [`sandbox.network.allowedDomains`](#sandbox-network-alloweddomains) | Preautorizza i domini in modo che i comandi in [sandbox](https://code.claude.com/docs/it/sandboxing.md) non chiedano conferma per essi | Impostazioni sandbox | Any file |
| [`sandbox.network.allowLocalBinding`](#sandbox-network-allowlocalbinding) | Consenti ai comandi in [sandbox](https://code.claude.com/docs/it/sandboxing.md) di mettersi in ascolto su porte di rete e di connettersi a localhost su macOS | Impostazioni sandbox | Any file |
| [`sandbox.network.allowMachLookup`](#sandbox-network-allowmachlookup) | Consenti agli strumenti macOS in [sandbox](https://code.claude.com/docs/it/sandboxing.md), come iOS Simulator o Playwright, di raggiungere i loro servizi XPC | Impostazioni sandbox | Any file |
| [`sandbox.network.allowManagedDomainsOnly`](#sandbox-network-allowmanageddomainsonly) | Vincola l'allowlist di rete alle [impostazioni gestite](https://code.claude.com/docs/it/sandboxing.md#keep-developers-from-widening-the-policy) | Impostazioni sandbox | Managed |
| [`sandbox.network.allowUnixSockets`](#sandbox-network-allowunixsockets) | Elenca i percorsi dei socket Unix che i comandi in [sandbox](https://code.claude.com/docs/it/sandboxing.md) possono usare su macOS | Impostazioni sandbox | Any file |
| [`sandbox.network.deniedDomains`](#sandbox-network-denieddomains) | Blocca domini per i comandi in [sandbox](https://code.claude.com/docs/it/sandboxing.md), anche all'interno di un wildcard consentito | Impostazioni sandbox | Any file |
| [`sandbox.network.httpProxyPort`](#sandbox-network-httpproxyport) | Instrada il traffico HTTP della [sandbox](https://code.claude.com/docs/it/sandboxing.md#custom-proxy-configuration) attraverso il tuo proxy | Impostazioni sandbox | Any file |
| [`sandbox.network.socksProxyPort`](#sandbox-network-socksproxyport) | Instrada il traffico SOCKS della [sandbox](https://code.claude.com/docs/it/sandboxing.md#custom-proxy-configuration) attraverso il tuo proxy | Impostazioni sandbox | Any file |
| [`sandbox.network.strictAllowlist`](#sandbox-network-strictallowlist) | Nega gli host al di fuori dell'[allowlist](https://code.claude.com/docs/it/sandboxing.md#network-isolation) invece di chiedere conferma | Impostazioni sandbox | User or managed |
| [`sandbox.network.tlsTerminate`](#sandbox-network-tlsterminate) | Fai terminare TLS al proxy della [sandbox](https://code.claude.com/docs/it/sandboxing.md#network-isolation) in modo che possa leggere le richieste HTTPS | Impostazioni sandbox | User or managed |
| [`sandbox.ripgrep`](#sandbox-ripgrep) | Usa un tuo binario ripgrep all'interno della [sandbox](https://code.claude.com/docs/it/sandboxing.md) | Impostazioni sandbox | User or managed |
| [`sandbox.socatPath`](#sandbox-socatpath) | Fai puntare il proxy della [sandbox](https://code.claude.com/docs/it/sandboxing.md) a un binario `socat` al di fuori di `PATH` | Impostazioni sandbox | Managed |
| [`showClearContextOnPlanAccept`](#showclearcontextonplanaccept) | Mostra un'opzione "cancella contesto" nella [schermata di accettazione del piano](https://code.claude.com/docs/it/permission-modes.md#review-and-approve-a-plan) | Interfaccia e terminale | Any file |
| [`showThinkingSummaries`](#showthinkingsummaries) | Visualizza i riepiloghi del [ragionamento](https://code.claude.com/docs/it/model-config.md#extended-thinking) di Claude invece di un segnaposto compresso | Modello e risposte | Any file |
| [`showTurnDuration`](#showturnduration) | Nascondi la durata "Cooked for" dopo ogni risposta | Interfaccia e terminale | Any file |
| [`skillListingBudgetFraction`](#skilllistingbudgetfraction) | Riserva più o meno contesto per l'[elenco delle skill](https://code.claude.com/docs/it/skills.md#skill-descriptions-are-cut-short) | Memoria e contesto | Any file |
| [`skillListingMaxDescChars`](#skilllistingmaxdescchars) | Limita la lunghezza della descrizione di ogni skill nell'[elenco delle skill](https://code.claude.com/docs/it/skills.md#skill-descriptions-are-cut-short) | Memoria e contesto | Any file |
| [`skillOverrides`](#skilloverrides) | [Nascondi o comprimi una skill](https://code.claude.com/docs/it/skills.md#override-skill-visibility-from-settings) senza modificare il suo SKILL.md | Plugin e skill | Any file |
| [`skipAutoPermissionPrompt`](#skipautopermissionprompt) | Salta l'avviso una tantum che Claude Code mostra quando entri per la prima volta nella [modalità auto](https://code.claude.com/docs/it/permission-modes.md#eliminate-prompts-with-auto-mode) di tua iniziativa anziché tramite l'impostazione predefinita integrata | Impostazioni dei permessi | User or managed |
| [`skipDangerousModePermissionPrompt`](#skipdangerousmodepermissionprompt) | Salta la finestra di dialogo di conferma prima della [modalità bypassPermissions](https://code.claude.com/docs/it/permission-modes.md#skip-all-checks-with-bypasspermissions-mode) | Impostazioni dei permessi | User, local, or managed |
| [`skipWebFetchPreflight`](#skipwebfetchpreflight) | Salta il [controllo del nome host di WebFetch](https://code.claude.com/docs/it/tools-reference.md#webfetch-tool-behavior) quando Anthropic non è raggiungibile | Privacy e telemetria | Any file |
| [`spellcheck`](#spellcheck) | Sottolinea le parole scritte in modo errato nell'input del prompt con un [correttore ortografico](https://code.claude.com/docs/it/interactive-mode.md#check-spelling-as-you-type) che installi | Interfaccia e terminale | User or managed |
| [`spinnerTipsEnabled`](#spinnertipsenabled) | Nascondi i suggerimenti nello spinner mentre Claude lavora | Interfaccia e terminale | Any file |
| [`spinnerTipsOverride`](#spinnertipsoverride) | Aggiungi i tuoi suggerimenti alla rotazione dello spinner o sostituisci quelli integrati | Interfaccia e terminale | Any file |
| [`spinnerVerbs`](#spinnerverbs) | Aggiungi o sostituisci i verbi mostrati durante l'esecuzione di un turno | Interfaccia e terminale | Any file |
| [`sshConfigs`](#sshconfigs) | Aggiungi [connessioni SSH](https://code.claude.com/docs/it/desktop.md#pre-configure-ssh-connections-for-your-team) al menu a discesa degli ambienti di Desktop | Remoto, desktop e notifiche | User or managed |
| [`sshHostAllowlist`](#sshhostallowlist) | Limita gli host che le [sessioni SSH di Desktop](https://code.claude.com/docs/it/desktop.md#restrict-which-ssh-hosts-users-can-connect-to) possono raggiungere | Remoto, desktop e notifiche | Managed |
| [`sshHostCommands`](#sshhostcommands) | Aggiungi [connessioni SSH il cui host proviene da un comando](https://code.claude.com/docs/it/desktop.md#create-an-ssh-connection-from-a-command) al menu a discesa degli ambienti di Desktop | Remoto, desktop e notifiche | User or managed |
| [`statusLine`](#statusline) | Esegui un tuo comando per generare una [riga di stato](https://code.claude.com/docs/it/statusline.md) sotto il prompt | Interfaccia e terminale | Any file |
| [`strictKnownMarketplaces`](#strictknownmarketplaces) | Definisci l'allowlist delle fonti [marketplace](https://code.claude.com/docs/it/plugins/overview.md) che gli utenti possono aggiungere e da cui possono installare | Plugin e skill | Managed |
| [`strictPluginOnlyCustomization`](#strictpluginonlycustomization) | Blocca [skill](https://code.claude.com/docs/it/skills.md), [agenti](https://code.claude.com/docs/it/sub-agents.md), [hook](https://code.claude.com/docs/it/hooks.md) e [server MCP](https://code.claude.com/docs/it/mcp.md) provenienti da fonti utente e di progetto | Plugin e skill | Managed |
| [`strictPluginOnlyCustomization.agents`](#strictpluginonlycustomization-agents) | Limita gli [agenti](https://code.claude.com/docs/it/sub-agents.md) alle fonti plugin e gestite | Plugin e skill | Managed |
| [`strictPluginOnlyCustomization.hooks`](#strictpluginonlycustomization-hooks) | Limita gli [hook](https://code.claude.com/docs/it/hooks.md) alle fonti plugin e gestite | Plugin e skill | Managed |
| [`strictPluginOnlyCustomization.mcp`](#strictpluginonlycustomization-mcp) | Limita i [server MCP](https://code.claude.com/docs/it/mcp.md) alle fonti plugin e gestite | Plugin e skill | Managed |
| [`strictPluginOnlyCustomization.skills`](#strictpluginonlycustomization-skills) | Limita le [skill](https://code.claude.com/docs/it/skills.md) alle fonti plugin e gestite | Plugin e skill | Managed |
| [`subagentPromptCacheTtl`](#subagentpromptcachettl) | Scegli la [durata della cache del prompt](https://code.claude.com/docs/it/prompt-caching.md#cache-lifetime) per i subagent e altre richieste al di fuori della conversazione principale | Modello e risposte | Any file |
| [`subagentStatusLine`](#subagentstatusline) | Riscrivi le righe nella visualizzazione delle attività dei [subagent](https://code.claude.com/docs/it/sub-agents.md) con un tuo comando | Interfaccia e terminale | Any file |
| [`switchModelsOnFlag`](#switchmodelsonflag) | Cambia modello automaticamente o metti in pausa quando un [classificatore di sicurezza](https://code.claude.com/docs/it/model-config.md#ask-before-switching) segnala una richiesta | Modello e risposte | Any file |
| [`syncClaudeAiPlugins`](#syncclaudeaiplugins) | Interrompi il caricamento dei [plugin abilitati sul tuo account claude.ai](https://code.claude.com/docs/it/plugins/loading.md#synced-plugins) e il download di quelli nuovi | Plugin e skill | User, local, or managed |
| [`syncClaudeAiSkills`](#syncclaudeaiskills) | Interrompi il caricamento delle [skill abilitate sul tuo account claude.ai](https://code.claude.com/docs/it/skills.md#how-synced-skills-behave) e il download di quelle nuove | Plugin e skill | User, local, or managed |
| [`syntaxHighlightingDisabled`](#syntaxhighlightingdisabled) | Disattiva l'evidenziazione della sintassi nei diff e nei blocchi di codice | Interfaccia e terminale | Any file |
| [`taskOutputMaxChars`](#taskoutputmaxchars) | Rimosso nella v2.1.277, insieme allo strumento `TaskOutput` di cui definiva le dimensioni | Memoria e contesto | Any file |
| [`teammateDefaultModel`](#teammatedefaultmodel) | Rimosso nella v2.1.234; consulta [Specificare i compagni di team e i modelli](https://code.claude.com/docs/it/agent-teams.md#specify-teammates-and-models) per sapere come Claude Code sceglie il modello di un compagno di team | Impostazioni di configurazione globale | Global config |
| [`teammateMode`](#teammatemode) | Scegli come vengono [visualizzati i compagni di un team di agenti](https://code.claude.com/docs/it/agent-teams.md#choose-a-display-mode) | Agenti, sessioni e worktree | Any file |
| [`terminalProgressBarEnabled`](#terminalprogressbarenabled) | Nascondi la barra di avanzamento del terminale nei terminali che la supportano | Interfaccia e terminale | Any file |
| [`terminalTitleFromRename`](#terminaltitlefromrename) | Impedisci a [`/rename`](https://code.claude.com/docs/it/sessions#name-your-sessions) e `--name` di cambiare il titolo della scheda del terminale | Interfaccia e terminale | Any file |
| [`theme`](#theme) | Scegli il [tema di colori](https://code.claude.com/docs/it/terminal-config.md#match-the-color-theme) dell'interfaccia, integrato o personalizzato | Interfaccia e terminale | Any file |
| [`timeFormat`](#timeformat) | Mostra gli orari nell'interfaccia nel formato a 12 o 24 ore, in UTC o con un pattern strftime | Interfaccia e terminale | Any file |
| [`timeZone`](#timezone) | Mostra gli orari nell'interfaccia in un fuso orario diverso da quello del tuo sistema | Interfaccia e terminale | Any file |
| [`tui`](#tui) | Scegli il renderer del terminale [a schermo intero](https://code.claude.com/docs/it/fullscreen.md) o classico | Interfaccia e terminale | Any file |
| [`ultracode`](#ultracode) | Fai pianificare a Claude un [workflow](https://code.claude.com/docs/it/workflows.md#let-claude-decide-with-ultracode) per ogni attività sostanziale senza che tu debba chiederlo | Modello e risposte | Any file |
| [`useAutoModeDuringPlan`](#useautomodeduringplan) | Consenti al classificatore della [modalità auto](https://code.claude.com/docs/it/permission-modes.md#eliminate-prompts-with-auto-mode) di esaminare i comandi shell nel [plan mode](https://code.claude.com/docs/it/permission-modes.md#analyze-before-you-edit-with-plan-mode); imposta `false` per ricevere invece richieste di conferma | Impostazioni dei permessi | User, local, or managed |
| [`verbose`](#verbose) | Mostra l'[output completo degli strumenti](https://code.claude.com/docs/it/cli-reference.md#cli-flags) invece dei riepiloghi troncati; `viewMode` ha la precedenza quando sono impostati entrambi | Interfaccia e terminale | Any file |
| [`viewMode`](#viewmode) | Avvia ogni sessione nella [vista predefinita, dettagliata o focus](https://code.claude.com/docs/it/cli-reference.md#cli-flags) | Interfaccia e terminale | Any file |
| [`vimInsertModeRemaps`](#viminsertmoderemaps) | Mappa una [sequenza in modalità INSERT](https://code.claude.com/docs/it/interactive-mode.md#remap-insert-mode-key-sequences) di due tasti come `jj` su Escape | Interfaccia e terminale | User or managed |
| [`voice`](#voice) | Attiva la [dettatura vocale](https://code.claude.com/docs/it/voice-dictation.md) e scegli la modalità hold o tap | Interfaccia e terminale | Any file |
| [`voiceEnabled`](#voiceenabled) | Attiva la [dettatura vocale](https://code.claude.com/docs/it/voice-dictation.md) con il vecchio formato a tasto singolo | Interfaccia e terminale | Any file |
| [`wheelScrollAccelerationEnabled`](#wheelscrollaccelerationenabled) | Disattiva l'[accelerazione della rotella del mouse](https://code.claude.com/docs/it/fullscreen.md#mouse-wheel-scrolling) nel rendering a schermo intero | Interfaccia e terminale | Any file |
| [`workflowKeywordTriggerEnabled`](#workflowkeywordtriggerenabled) | Consenti alla parola `ultracode` in un prompt di avviare un [workflow](https://code.claude.com/docs/it/workflows.md); imposta `false` per digitarla senza avviarne uno | Hook e automazione | Any file |
| [`workflowSizeGuideline`](#workflowsizeguideline) | Imposta il numero di agenti a cui Claude punta nei [workflow dinamici](https://code.claude.com/docs/it/workflows.md) | Hook e automazione | Any file |
| [`worktree`](#worktree) | Configura il modo in cui Claude Code crea i [worktree](https://code.claude.com/docs/it/worktrees.md) git | Agenti, sessioni e worktree | Any file |
| [`worktree.baseRef`](#worktree-baseref) | Crea i nuovi [worktree](https://code.claude.com/docs/it/worktrees.md) a partire dal branch predefinito remoto o dal tuo HEAD locale | Agenti, sessioni e worktree | Any file |
| [`worktree.bgIsolation`](#worktree-bgisolation) | Consenti alle sessioni in background di modificare la copia di lavoro senza un [worktree](https://code.claude.com/docs/it/worktrees.md) | Agenti, sessioni e worktree | Any file |
| [`worktree.location`](#worktree-location) | Scegli dove le [sessioni SSH di Desktop](https://code.claude.com/docs/it/desktop.md#ssh-sessions) creano i loro worktree su una macchina remota | Agenti, sessioni e worktree | User |
| [`worktree.sparsePaths`](#worktree-sparsepaths) | Esegui il checkout solo delle directory che ti servono in ogni [worktree](https://code.claude.com/docs/it/worktrees.md) | Agenti, sessioni e worktree | Any file |
| [`worktree.symlinkDirectories`](#worktree-symlinkdirectories) | Crea collegamenti simbolici alle directory di grandi dimensioni in ogni [worktree](https://code.claude.com/docs/it/worktrees.md) invece di duplicarle | Agenti, sessioni e worktree | Any file |
| [`wslInheritsWindowsSettings`](#wslinheritswindowssettings) | Fai leggere a WSL le [impostazioni gestite](https://code.claude.com/docs/it/managed-settings.md) dalla catena dei criteri di Windows | Impostazioni aziendali e gestite | Managed |

## Modello e risposte

Scegli quali modelli Claude Code utilizza e come risponde. Per come queste impostazioni interagiscono con il comando `/model` e le variabili di ambiente, vedi [Configurazione del modello](https://code.claude.com/docs/it/model-config.md).

### `advisorModel`

Scegli quale modello risponde quando Claude chiama lo [strumento advisor](https://code.claude.com/docs/it/advisor.md) lato server. Lascialo non impostato per disattivare l'advisor. L'advisor deve essere almeno altrettanto capace del tuo modello principale. Vedi [Scegli un modello advisor](https://code.claude.com/docs/it/advisor.md#choose-an-advisor-model) per gli accoppiamenti accettati e cosa succede quando ne scegli uno non accettato.

Di solito non modifichi questa chiave manualmente. Esegui `/advisor` per aprire un selettore che mostra la scelta attuale, i modelli che possono fornire consulenza e **Nessun advisor**. Claude Code salva la tua scelta in questa chiave in `~/.claude/settings.json`. Se scegli da un client [Remote Control](https://code.claude.com/docs/it/remote-control.md) o in una sessione collegata a un worker remoto, la scelta si applica solo a quella sessione e non modifica questa chiave.

Se il tuo account richiede il [consenso usage-credits](https://code.claude.com/docs/it/advisor.md#fable-advisor-and-usage-credits), accettalo prima eseguendo `/model fable`. Fino a quando non lo fai, scegliere Fable in `/advisor` non salva nulla e Claude Code ti dice di eseguire `/model fable` prima.

* **Scope**: [`Any file`](#scopes)
* **Type**: string, uno degli alias `"fable"`, `"opus"`, o `"sonnet"`, che si risolvono nella versione predefinita corrente di Claude Code di quella famiglia di modelli, o un ID modello completo come `"claude-opus-5-5"`
* **Default**: non impostato, quindi l'advisor è disattivato
* **Per-session overrides**: `--advisor` ha la precedenza su questa chiave per una sessione. [`CLAUDE_CODE_DISABLE_ADVISOR_TOOL`](https://code.claude.com/docs/it/env-vars) disattiva l'advisor, e questa chiave non può riattivarlo

```json settings.json theme={null}
{
  "advisorModel": "opus"
}
```

La chiave non ha effetto su provider dove l'advisor [non è disponibile](https://code.claude.com/docs/it/advisor.md#requirements), come Amazon Bedrock e Claude Platform su AWS. `"fable"` richiede [accesso a Fable](https://code.claude.com/docs/it/advisor.md#choose-an-advisor-model).

### `alwaysThinkingEnabled`

Disattiva il [pensiero esteso](https://code.claude.com/docs/it/model-config.md#extended-thinking) per ogni sessione impostando questo a `false`. Il pensiero è attivo per impostazione predefinita, quindi `true` non cambia nulla. La maggior parte delle persone imposta questo tramite `/config` piuttosto che modificando il file.

Sui modelli che ragionano sempre, come Opus 5.5, Sonnet 5.5, Haiku 5.5 e i modelli Fable, `false` non ha effetto. Sui [provider di terze parti](https://code.claude.com/docs/it/third-party-integrations.md) Claude Code omette il parametro `thinking` invece di disattivare il ragionamento, quindi i modelli a ragionamento adattivo potrebbero comunque ragionare. Con il ragionamento disattivato sull'API Anthropic, Claude Code invia effort `high` invece di un livello superiore ai modelli che sa [non accettano quella combinazione](https://code.claude.com/docs/it/errors.md#effort-isnt-available-with-thinking-turned-off), come Opus 5.

* **Scope**: [`Any file`](#scopes)
* **Type**: Boolean
  * `true`: nessun effetto; il pensiero è già attivo
  * `false`: Claude Code disattiva il pensiero esteso per ogni sessione
* **Default**: non impostato, quindi il pensiero è attivo per i modelli che lo supportano
* **Per-session overrides**: [`MAX_THINKING_TOKENS`](https://code.claude.com/docs/it/env-vars) ha la precedenza su questa chiave per una sessione: `0` disattiva il pensiero, sotto gli stessi limiti di modello e provider di `false`, e un valore positivo attiva il pensiero anche quando questa chiave è `false`. Su modelli di ragionamento adattivo il numero stesso viene ignorato

```json settings.json theme={null}
{
  "alwaysThinkingEnabled": false
}
```

### `availableModels`

Limita quali modelli le persone possono selezionare per la sessione principale, [subagenti](https://code.claude.com/docs/it/sub-agents.md), [skills](https://code.claude.com/docs/it/skills.md), e l'[advisor](https://code.claude.com/docs/it/advisor.md). Un elenco gestito vincola `/model`, `--model`, e la chiave `model` nei file propri dello sviluppatore; un modello al di fuori di esso non può essere selezionato. Con la corrispondenza di prefisso predefinita, questo non tocca l'opzione Default da sola; abbinala con [`enforceAvailableModels`](#enforceavailablemodels) per quello.

* **Scope**: [`Any file`](#scopes). Distribuiscilo nelle impostazioni gestite per applicarlo a un'organizzazione.
* **Type**: array di alias di modelli o ID
* **Default**: non impostato, quindi ogni modello è disponibile

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

```json settings.json theme={null}
{
  "availableModels": ["sonnet", "haiku"]
}
```

Una voce ID modello come `"claude-opus-5"` consente anche versioni successive che la estendono, come Opus 5.5. Per bloccare una di quelle versioni, usa [`deniedModels`](#deniedmodels). Per fare in modo che ogni voce ID modello consenta solo la versione che nomina, usa [`availableModelsMatch`](#availablemodelsmatch). Vedi [Limita la selezione del modello](https://code.claude.com/docs/it/model-config.md#restrict-model-selection). Per gli ID dei provider di terze parti, vedi [Fissa i modelli per i deploy di terze parti](https://code.claude.com/docs/it/model-config.md#pin-models-for-third-party-deployments).

### `availableModelsMatch`

Scegli come le voci [`availableModels`](#availablemodels) corrispondono agli ID modello. Per impostazione predefinita una voce ID modello consente anche versioni successive che la estendono, quindi `"claude-opus-5"` consente Opus 5.5. Con `"exact"`, ogni voce ID modello consente solo la versione che nomina, quindi una versione più recente di quel modello rimane bloccata finché non la elenchi. Richiede Claude Code v2.1.283 o successivo.

* **Scope**: [`Managed`](#scopes). Claude Code ignora la chiave nelle impostazioni utente, progetto e locale e in `--settings`, con un avviso
* **Type**: string, uno di:
  * `"prefix"`: una voce ID modello consente la sua versione e qualsiasi ID modello che la estende con un altro segmento
  * `"exact"`: una voce ID modello consente solo la versione che nomina, quindi `"claude-opus-5"` consente Opus 5 ma non `claude-opus-5-5`. Una voce come `"claude-opus-4-5"` consente anche il relativo ID modello Anthropic datato `claude-opus-4-5-20251101`. Un alias di famiglia come `"opus"` consente comunque l'intera famiglia, e le voci `best`, `opusplan`, e `default` vengono ignorate
* **Default**: `"prefix"`

Questo esempio consente Opus 5 e Sonnet 5 e nessuna versione successiva di entrambi:

```json managed-settings.json theme={null}
{
  "availableModels": ["claude-opus-5", "claude-sonnet-5"],
  "availableModelsMatch": "exact"
}
```

Con `"exact"`, l'opzione Default è anche limitata ai modelli elencati ogni volta che l'elenco nomina almeno un modello o una famiglia. Vedi [Blocca modelli o versioni specifiche](https://code.claude.com/docs/it/model-config.md#block-specific-models-or-versions).

### `deniedModels`

Blocca modelli specifici, con o senza un elenco [`availableModels`](#availablemodels) e anche quando quell'elenco li consente. Claude Code nasconde un modello bloccato dal selettore `/model`, e il modello non può essere selezionato ovunque `availableModels` sia applicato. Una sessione sull'opzione Default non esegue nemmeno un modello bloccato, come [Blocca modelli o versioni specifiche](https://code.claude.com/docs/it/model-config.md#block-specific-models-or-versions) descrive. Richiede Claude Code v2.1.283 o successivo.

* **Scope**: [`Managed`](#scopes). Claude Code ignora la chiave nelle impostazioni utente, progetto e locale e in `--settings`, con un avviso
* **Type**: array di alias di modelli o ID
  * Un alias di famiglia come `"opus"` blocca ogni modello in quella famiglia
  * Un ID modello come `"claude-opus-5-5"` blocca quella versione in ogni ortografia, inclusi gli ID datati e specifici del provider
  * Un ID modello senza versione minore, come `"claude-opus-5"`, blocca anche versioni minori successive come Opus 5.5. Scrivi `"claude-opus-5-0"` per bloccare solo Opus 5
  * Le voci `best`, `opusplan`, e `default` vengono ignorate
* **Default**: non impostato, quindi nessun modello è bloccato

Questo esempio consente modelli Opus e Sonnet e blocca Opus 5.5:

```json managed-settings.json theme={null}
{
  "availableModels": ["opus", "sonnet"],
  "deniedModels": ["claude-opus-5-5"]
}
```

Vedi [Blocca modelli o versioni specifiche](https://code.claude.com/docs/it/model-config.md#block-specific-models-or-versions).

### `effortLevel`

Imposta un [livello di effort](https://code.claude.com/docs/it/model-config.md#adjust-effort-level) predefinito per i modelli per i quali non hai salvato un livello. I livelli inferiori sono più veloci e più economici su compiti semplici, e i livelli superiori ragionano più profondamente su problemi complessi.

Quando esegui `/effort low`, `medium`, `high`, o `xhigh` in una sessione interattiva sulla tua macchina, Claude Code salva il livello per il modello attivo sotto [`modelSettings`](#modelsettings) piuttosto che scrivere questa chiave. Prima della v2.1.251, `/effort` scriveva questa chiave.

All'interno dello stesso file di impostazioni, Claude Code utilizza il livello salvato di un modello piuttosto che questa chiave. [`modelSettings`](#modelsettings) indica la precedenza tra file.

In una sessione collegata a un worker remoto, in un'esecuzione `-p`, e in Agent SDK, `/effort` si applica solo a quella sessione. [Regola il livello di effort](https://code.claude.com/docs/it/model-config.md#adjust-effort-level) elenca le scelte interattive che si applicano anche solo a quella sessione. Il messaggio che `/effort` stampa dice quale è accaduto.

* **Scope**: [`Any file`](#scopes)
* **Type**: string, uno di:
  * `"low"`: il ragionamento minimo, per compiti brevi, limitati e sensibili alla latenza che non sono sensibili all'intelligenza
  * `"medium"`: riduce l'utilizzo di token per il lavoro sensibile ai costi che può scambiare un po' di intelligenza
  * `"high"`: bilancia l'utilizzo di token e l'intelligenza
  * `"xhigh"`: ragionamento più profondo con spesa di token più elevata
* **Default**: non impostato
* **Per-session overrides**: `--effort` ha la precedenza su questa chiave per una sessione, e [`CLAUDE_CODE_EFFORT_LEVEL`](https://code.claude.com/docs/it/env-vars) ha la precedenza su entrambi

```json settings.json theme={null}
{
  "effortLevel": "xhigh"
}
```

Nel tuo file di impostazioni utente, `~/.claude/settings.json`, questa chiave è la forma più vecchia che `/effort` scriveva prima di salvare i livelli per modello, e continua ad applicarsi dove si applicava prima, su Opus 5, Fable 5.1, e modelli precedenti. Opus 5.5 e i modelli rilasciati dopo di esso lo ignorano e iniziano al loro default fino a quando non salvi un livello per loro, che `/effort` scrive sotto [`modelSettings`](#modelsettings). Nelle impostazioni di progetto, locale e gestite, e con `--settings`, questa chiave si applica a ogni modello.

### `enforceAvailableModels`

Il selettore `/model` ha un'opzione **Default**, e [`default` model setting](https://code.claude.com/docs/it/model-config#default-model-setting) descrive il modello a cui si risolve. Un elenco [`availableModels`](#availablemodels) limita i modelli che puoi nominare, ma con la [corrispondenza di prefisso](#availablemodelsmatch) predefinita non rimappa il default del tuo tipo di account, quindi **Default** può comunque risolversi a un modello al di fuori dell'elenco. Questa chiave chiude quella lacuna. Richiede Claude Code v2.1.175 o successivo.

Quando la tua organizzazione distribuisce qualsiasi impostazione gestita, Claude Code legge questa chiave solo dalla fonte gestita e la ignora negli altri tuoi file.

Per come questa chiave si applica ai controlli del modello all'avvio, vedi [Amazon Bedrock](https://code.claude.com/docs/it/amazon-bedrock.md#when-your-organization-enforces-a-model-allowlist) e [Agent Platform di Google Cloud](https://code.claude.com/docs/it/google-vertex-ai.md#when-your-organization-enforces-a-model-allowlist).

* **Scope**: [`Any file`](#scopes)
* **Type**: Boolean
  * `true`: quando **Default** si risolverebbe a un modello al di fuori di `availableModels`, Claude Code lo risolve al primo modello disponibile nell'elenco
  * `false`: questa chiave non cambia come **Default** si risolve
* **Default**: `false`

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

```json settings.json theme={null}
{
  "availableModels": ["sonnet", "haiku"],
  "enforceAvailableModels": true
}
```

Questa chiave non ha effetto quando `availableModels` non è impostato o è vuoto. Vedi [Applica l'elenco consentito al modello Default](https://code.claude.com/docs/it/model-config.md#enforce-the-allowlist-for-the-default-model). Richiede Claude Code v2.1.175 o successivo.

### `fallbackModel`

Nomina modelli di backup per Claude Code da provare, in ordine, quando il tuo modello principale è sovraccarico o non disponibile. Claude Code passa al prossimo modello disponibile nella catena per il resto del turno e mostra un avviso. Senza una catena, Claude Code riprova lo stesso modello e poi mostra l'errore del server, e tu riprovi o cambi modelli tu stesso.

Un cambio significa un turno con una [cache prompt](https://code.claude.com/docs/it/prompt-caching.md#switching-models) fredda sul modello di fallback; il tuo prossimo messaggio riprova il modello principale per primo di nuovo.

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

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

```json settings.json theme={null}
{
  "fallbackModel": ["claude-sonnet-5", "claude-haiku-4-5"]
}
```

A differenza della maggior parte delle impostazioni di array, questa chiave non si unisce tra file di impostazioni: il file con la precedenza più alta che la definisce fornisce l'intera catena. Se il tuo file di progetto imposta `["claude-sonnet-5"]` e il tuo file utente imposta `["claude-haiku-4-5"]`, la catena è `["claude-sonnet-5"]` solo. Claude Code mantiene al massimo tre modelli consentiti distinti dall'elenco e ignora il resto. Vedi [Catene di modelli di fallback](https://code.claude.com/docs/it/model-config.md#fallback-model-chains).

### `fastMode`

Attiva la [modalità veloce](https://code.claude.com/docs/it/fast-mode.md) per sessioni dove è disponibile, per il lavoro interattivo come l'iterazione rapida o il debug dal vivo dove vuoi velocità a un costo più elevato per token. Di solito non modifichi questa chiave manualmente: eseguire `/fast` scrive `fastMode: true` in `~/.claude/settings.json`, e eseguirlo di nuovo per disattivare la modalità veloce rimuove la chiave. La modalità veloce funziona solo su Opus 5.5, Opus 5, e Opus 4.8: attivarla da un altro modello ti passa a Opus, e passare a un modello non supportato la disattiva. Vedi [Cambia modelli mentre la modalità veloce è attiva](https://code.claude.com/docs/it/fast-mode.md#switch-models-while-fast-mode-is-on).

* **Scope**: [`Any file`](#scopes)
* **Type**: Boolean
  * `true`: Claude Code attiva la modalità veloce per sessioni dove è disponibile
  * `false`: la modalità veloce rimane disattivata
* **Default**: non impostato, quindi la modalità veloce è disattivata
* **Per-session overrides**: [`CLAUDE_CODE_DISABLE_FAST_MODE`](https://code.claude.com/docs/it/env-vars) disattiva la modalità veloce per una sessione, e questa chiave non può riattivarlo

```json settings.json theme={null}
{
  "fastMode": true
}
```

### `fastModePerSessionOptIn`

Normalmente, eseguire `/fast` salva [`fastMode`](#fastmode) nelle impostazioni utente di una persona, quindi la modalità veloce è attiva all'inizio di ogni sessione successiva. Imposta questa chiave a `true` per fermare quello: un `fastMode: true` salvato non attiva più la modalità veloce all'inizio della sessione, e ogni persona deve eseguire `/fast` in ogni sessione in cui la vuole. Claude Code lascia la chiave `fastMode` nel loro file, quindi disattivare questa chiave ripristina il comportamento vecchio.

I proprietari su piani Team o Enterprise possono distribuirla a livello di organizzazione tramite [impostazioni gestite dal server](https://code.claude.com/docs/it/server-managed-settings.md). Quando le impostazioni gestite impostano la chiave, `/fast on` viene rifiutato al di fuori delle sessioni di terminale interattive e segnala che la tua organizzazione ha disabilitato la modalità veloce. Questo copre la [modalità non interattiva](https://code.claude.com/docs/it/headless.md), l'[estensione VS Code](https://code.claude.com/docs/it/vs-code.md), e le [sessioni cloud](https://code.claude.com/docs/it/claude-code-on-the-web.md).

* **Scope**: [`Any file`](#scopes)
* **Type**: Boolean
  * `true`: un `fastMode: true` salvato non attiva più la modalità veloce all'inizio della sessione, quindi ogni persona esegue `/fast` in ogni sessione in cui la vuole; un `fastMode: true` passato con `--settings` conta comunque per quella sessione a meno che le impostazioni gestite non impostino questa chiave
  * `false`: un `fastMode: true` salvato attiva la modalità veloce all'inizio di ogni sessione successiva
* **Default**: `false`

```json settings.json theme={null}
{
  "fastModePerSessionOptIn": true
}
```

Vedi [Richiedi opt-in per sessione](https://code.claude.com/docs/it/fast-mode.md#require-per-session-opt-in).

### `language`

Fai rispondere Claude in una lingua diversa dall'inglese per impostazione predefinita. Non c'è un elenco fisso per le risposte: Claude Code passa il valore verbatim a Claude come istruzione per rispondere sempre in quella lingua, quindi qualsiasi nome di lingua che Claude può leggere funziona. Claude Code non controlla il valore, quindi un nome scritto male raggiunge Claude come scritto piuttosto che produrre un errore. Lo stesso valore imposta la lingua per la [dettatura vocale](https://code.claude.com/docs/it/voice-dictation.md#change-the-dictation-language), che ha un elenco fisso di [lingue di dettatura supportate](https://code.claude.com/docs/it/voice-dictation.md#change-the-dictation-language), e per i titoli di sessione generati automaticamente.

* **Scope**: [`Any file`](#scopes)
* **Type**: string, qualsiasi nome di lingua, come `"japanese"`, `"spanish"`, o `"french"`; Claude Code non lo convalida
* **Default**: non impostato; i titoli di sessione corrispondono quindi alla lingua della tua conversazione

```json settings.json theme={null}
{
  "language": "japanese"
}
```

### `maxEffortLevel`

Limita il [livello di effort](https://code.claude.com/docs/it/model-config.md#adjust-effort-level) che una sessione può utilizzare, lasciando disponibili i livelli inferiori. Qualsiasi livello superiore funziona al limite invece, incluso uno da `/effort`, il selettore `/model`, `--effort`, [`CLAUDE_CODE_EFFORT_LEVEL`](https://code.claude.com/docs/it/env-vars), il frontmatter `effort` di una skill o subagente, o il default del modello stesso. Claude Code applica il limite stesso prima di ogni richiesta, quindi vale su ogni provider, inclusi Amazon Bedrock, Agent Platform di Google Cloud, e Microsoft Foundry. Richiede Claude Code v2.1.267 o successivo.

* **Scope**: [`Any file`](#scopes). Distribuiscilo nelle impostazioni gestite per applicarlo a un'organizzazione. Quando più scope impostano un limite, si applica il più basso, quindi un limite impostato in uno scope non può essere aumentato da un altro
* **Type**: string, uno di `"low"`, `"medium"`, `"high"`, `"xhigh"`, o `"max"`. Un valore `"max"` non imposta alcun limite
* **Default**: non impostato, quindi non si applica alcun limite
* **Per-model caps**: aggiungi `maxEffortLevel` alla voce [`modelSettings`](#modelsettings) di un modello. Quella voce sostituisce questa chiave solo per il modello all'interno della fonte di impostazioni che imposta entrambi, come le tue impostazioni utente o una [fonte gestita](https://code.claude.com/docs/it/managed-settings.md#how-claude-code-combines-managed-sources). Imposta `"max"` lì per esentare il modello dal limite di quella fonte; Claude Code applica comunque i limiti da altre fonti

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

```json settings.json theme={null}
{
  "maxEffortLevel": "medium",
  "modelSettings": {
    "claude-sonnet-4-6": {
      "maxEffortLevel": "max"
    }
  }
}
```

Quando la tua organizzazione imposta anche un [limite di effort](https://code.claude.com/docs/it/model-config.md#organization-effort-limits) per un modello, si applica il limite inferiore dei due.

### `model`

Imposta il modello che ogni nuova sessione utilizza, quindi non devi sceglierne uno con `/model` ogni volta. Impostarlo qui non ti impedisce di cambiare a metà sessione. Se il tuo amministratore ha impostato un [modello predefinito dell'organizzazione](https://code.claude.com/docs/it/model-config.md#organization-default-model) per ignorare la selezione dell'utente, ottieni quel modello anche quando imposti questa chiave nelle impostazioni utente, progetto o locale.

* **Scope**: [`Any file`](#scopes)
* **Type**: string, un alias di modello o ID modello completo
* **Default**: non impostato, quindi Claude Code utilizza il modello predefinito del tuo account
* **Per-session overrides**: `--model` ha la precedenza su [`ANTHROPIC_MODEL`](https://code.claude.com/docs/it/env-vars), e entrambi hanno la precedenza su questa chiave per una sessione, incluso su un `model` gestito; un elenco [`availableModels`](#availablemodels) si applica comunque alla scelta

```json settings.json theme={null}
{
  "model": "claude-sonnet-5"
}
```

Un valore qui supera [`ANTHROPIC_DEFAULT_MODEL`](https://code.claude.com/docs/it/model-config#set-a-default-model-for-new-sessions), che Claude Code utilizza solo quando nient'altro seleziona un modello.

### `modelOverrides`

Mappa gli ID modello Anthropic agli ID modello specifici del provider, come i profili di inferenza ARN di Amazon Bedrock. Ogni voce del selettore di modelli utilizza quindi il suo valore mappato quando chiama l'API del provider. Gli amministratori lo utilizzano su [Amazon Bedrock, Agent Platform di Google Cloud, e Microsoft Foundry](https://code.claude.com/docs/it/model-config.md#override-model-ids-per-version) per instradare ogni versione di modello a un profilo di inferenza specifico, nome di versione, o distribuzione per governance, allocazione dei costi, o instradamento regionale.

* **Scope**: [`Any file`](#scopes)
* **Type**: object che mappa ID modello a ID modello del provider
* **Default**: non impostato

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

```json settings.json theme={null}
{
  "modelOverrides": {
    "claude-opus-4-6": "arn:aws:bedrock:us-east-1:123456789012:inference-profile/example"
  }
}
```

Vedi [Ignora gli ID modello per versione](https://code.claude.com/docs/it/model-config.md#override-model-ids-per-version).

### `modelPicker`

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

* **Scope**: [`User or managed`](#scopes). Claude Code legge la chiave dalle impostazioni gestite, `--settings`, e impostazioni utente, e la ignora nelle impostazioni di progetto e locale quindi un repository che cloni non può rietichettare il selettore. Il più alto di quei tre che imposta la chiave fornisce l'intera lineup, e Claude Code non combina mai lineup da due fonti.
* **Type**: object con un array `options` di righe e un Boolean `replaceBuiltInOptions` opzionale
* **Default**: non impostato, quindi il selettore mostra la lineup integrata

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

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

#### Campi per `modelPicker`

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

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

Una voce in `options` può anche portare un `behavesAs` string opzionale accanto al suo `model`, che richiede v2.1.257 o successivo. Impostalo all'ID di un modello che la tua versione di Claude Code già conosce, come `claude-opus-4-8`, su una voce il cui `model` è più recente della tua versione. Claude Code applica quindi le capacità di quel modello conosciuto e i default di effort alla voce invece di trattare il suo modello come sconosciuto. L'etichetta della voce e l'ID modello che Claude Code invia nelle richieste non cambiano.

Con `replaceBuiltInOptions` attivo, Claude Code nasconde ogni altra riga: la lineup integrata, le righe che aggiunge per le voci [`availableModels`](#availablemodels), i modelli che la [scoperta del gateway](https://code.claude.com/docs/it/llm-gateway-protocol.md#model-discovery) ha trovato, e [`ANTHROPIC_CUSTOM_MODEL_OPTION`](https://code.claude.com/docs/it/model-config#add-a-custom-model-option). Con esso disattivato, Claude Code salta un modello elencato che la lineup integrata già copre. Un'etichetta cambia quello che il selettore mostra, non quale modello Claude Code esegue.

Un elenco [`availableModels`](#availablemodels) si applica comunque a queste righe. Prima di aggiungere un modello elencato all'elenco consentito, leggi [Comportamento di unione](https://code.claude.com/docs/it/model-config.md#merge-behavior): un ID modello specifico restringe la voce wildcard della sua famiglia. Claude Code controlla anche ogni riga rispetto alla sessione prima di mostrare il selettore:

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

Claude Code elimina una riga che non può analizzare e mantiene il resto. Vedi [Ripara un file di impostazioni rotto](https://code.claude.com/docs/it/settings.md#fix-a-broken-settings-file).

### `modelPricing`

Segnala la spesa alle tariffe che la tua organizzazione paga invece del prezzo di listino. Impostalo quando la tua organizzazione ha tariffe contrattuali, quindi le cifre in dollari che gli sviluppatori vedono corrispondono alla tua fattura. Claude Code applica le tariffe in `/usage`, la [riga di stato](https://code.claude.com/docs/it/statusline.md), l'`total_cost_usd` di Agent SDK, il limite [`--max-budget-usd`](https://code.claude.com/docs/it/cli-reference), e la metrica di costo [OpenTelemetry](https://code.claude.com/docs/it/monitoring-usage.md) e gli eventi. Fornisci le tariffe: Claude Code non le legge dal tuo contratto o dalla Claude Console. Richiede Claude Code v2.1.242 o successivo.

* **Scope**: [`Managed`](#scopes). Distribuisci la chiave tramite impostazioni gestite dal server, una politica MDM, un file `managed-settings.json`, o un [helper di politica](https://code.claude.com/docs/it/managed-settings.md#compute-the-policy-with-a-helper-program). Claude Code la ignora nelle impostazioni utente, progetto e locale, in `--settings`, e su Windows nel [registro HKCU](https://code.claude.com/docs/it/managed-settings.md#where-each-mechanism-stores-the-policy) scrivibile dall'utente. Con impostazioni gestite dal server, ogni sessione segnala i costi al prezzo di listino fino a quando il [fetch di impostazioni](https://code.claude.com/docs/it/server-managed-settings.md#fetch-and-caching-behavior) di quella sessione ha confermato l'impostazione. Un'applicazione host che incorpora Claude Code e imposta [`CLAUDE_CODE_PROVIDER_MANAGED_BY_HOST`](https://code.claude.com/docs/it/env-vars) può fornire una tabella propria tramite l'opzione SDK [`managedSettings`](https://code.claude.com/docs/it/agent-sdk/typescript#options), che Claude Code utilizza solo quando nessuna fonte gestita imposta la chiave e solo in Claude Code v2.1.246 o successivo.
* **Type**: object con un `multiplier` opzionale e una mappa `overrides` opzionale
* **Default**: non impostato, quindi Claude Code segnala il prezzo di listino a meno che un'applicazione host non fornisca una tabella

Imposta `multiplier` da solo per uno sconto o markup fisso, `overrides` da solo per tariffe per modello, o entrambi.

Questo esempio imposta tariffe contrattuali per Sonnet 4.6 e poi riduce ogni cifra, la riga Sonnet inclusa, del 15%:

```json managed-settings.json theme={null}
{
  "modelPricing": {
    "multiplier": 0.85,
    "overrides": {
      "claude-sonnet-4-6": {
        "input": 2.4,
        "output": 12,
        "cacheRead": 0.24,
        "cacheWrite": 3
      }
    }
  }
}
```

Imposta `multiplier` sopra 1, fino a 10, per aumentare ogni cifra. Un markup richiede Claude Code v2.1.271 o successivo. Le versioni precedenti ignorano un `multiplier` sopra 1 con un avviso e mantengono il resto dell'impostazione.

Per i passaggi, incluso come confermare che le tariffe sono in vigore, vedi [Segnala la spesa alle tue tariffe contrattuali](https://code.claude.com/docs/it/costs.md#report-spend-at-your-contracted-rates).

#### Campi per `modelPricing`

| Field | Type | What it does |
| :- | :- | :- |
| `multiplier` | number maggiore di 0 e al massimo 10 | Scala ogni costo che Claude Code calcola, indipendentemente dal fatto che una riga `overrides` la copra. Sotto 1 è uno sconto, sopra 1 un markup |
| `overrides` | mappa di ID modello a un oggetto di tariffa con `input`, `output`, `cacheRead`, e `cacheWrite`, ognuno da 0 a 10000 | Le tariffe USD-per-milione-token per quel modello, tutti e quattro richiesti. `cacheWrite` copre sia le scritture di cache di cinque minuti che di un'ora. Vedi [Quali modelli si applica una riga modelPricing](#which-models-a-modelpricing-row-applies-to) |

Claude Code utilizza le tariffe di una riga esattamente come le hai scritte, senza aggiungere il markup di modalità veloce o la [tariffa di inferenza solo negli USA](https://platform.claude.com/docs/en/about-claude/pricing). Se imposti anche `multiplier`, Claude Code lo applica in cima alle tariffe della riga. Claude Code elimina una riga con una tariffa che non può analizzare, o un `multiplier` che non può analizzare, e mantiene il resto; vedi [Ripara un file di impostazioni rotto](https://code.claude.com/docs/it/settings.md#fix-a-broken-settings-file).

#### Quali modelli si applica una riga `modelPricing`

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

* **L'ID di un modello integrato**: una chiave che Claude Code stesso utilizza per un modello integrato, indipendentemente dal fatto che quella chiave sia l'ID del modello stesso, come `claude-sonnet-4-6`, o il suo ID Bedrock, Agent Platform, o Foundry. Claude Code applica la riga a ogni ID snapshot datato e ID specifico del provider di quel modello.
* **Qualsiasi altra chiave**: una chiave che non è l'ID di un modello integrato, come un alias di modello gateway. Claude Code applica la riga a quell'ID solo. Quando un ID modello corrisponde a una delle tue chiavi esattamente e cade anche sotto una riga con chiave dall'ID di un modello integrato, Claude Code utilizza la corrispondenza esatta.
* **Un profilo di inferenza dell'applicazione Bedrock**: una volta che Claude Code ha risolto il profilo al modello a cui instrada, tramite la tua mappa [`modelOverrides`](#modeloverrides) o la ricerca [`bedrock:GetInferenceProfile`](https://code.claude.com/docs/it/amazon-bedrock#iam-configuration), Claude Code applica la riga di quel modello al profilo.

### `modelSettings`

Salva un [livello di effort](https://code.claude.com/docs/it/model-config.md#adjust-effort-level) per ogni modello che utilizzi. Richiede Claude Code v2.1.251 o successivo.

In una sessione interattiva sulla tua macchina, quando salvi `low`, `medium`, `high`, o `xhigh` come tuo default con `/effort` o il cursore di effort del selettore `/model`, Claude Code scrive quel livello qui sotto il modello che stai utilizzando, quindi raramente modifichi questa chiave tu stesso. Quando scegli uno di quei livelli nel [selettore di modelli dell'estensione VS Code](https://code.claude.com/docs/it/vs-code.md#use-the-prompt-box), Claude Code lo salva qui allo stesso modo. La voce [`effortLevel`](#effortlevel) elenca le sessioni dove `/effort` si applica solo a quella sessione.

Modifica la chiave manualmente per cambiare o rimuovere un livello che hai salvato.

Un `effortLevel` di un modello qui ha la precedenza sul [`effortLevel`](#effortlevel) di livello superiore nello stesso file di impostazioni. Tra file, Claude Code risolve ogni modello separatamente: il [file di impostazioni](https://code.claude.com/docs/it/settings.md#settings-precedence) con la precedenza più alta che imposta un `effortLevel` per quel modello o un `effortLevel` di livello superiore che [si applica a quel modello](#effortlevel) decide, quindi un `effortLevel` nelle impostazioni gestite supera un livello che hai salvato nelle impostazioni utente. [Regola il livello di effort](https://code.claude.com/docs/it/model-config.md#adjust-effort-level) elenca cos'altro può ignorare un livello salvato, come `--effort` al lancio.

Per limitare l'effort di un modello piuttosto che impostare il suo livello, aggiungi un campo [`maxEffortLevel`](#maxeffortlevel) alla voce di quel modello. Il campo richiede Claude Code v2.1.267 o successivo.

* **Scope**: [`Any file`](#scopes)
* **Type**: object che mappa un nome di modello a un object con uno qualsiasi di questi campi:
  * `effortLevel`: uno di `"low"`, `"medium"`, `"high"`, o `"xhigh"`
  * [`maxEffortLevel`](#maxeffortlevel): il livello di sforzo più alto a cui il modello può funzionare
  * `autoCompactWindow`: un numero di token da `100000` a `1000000`, o `"auto"` per la finestra ottimizzata per il modello. [`/autocompact`](https://code.claude.com/docs/it/model-config#set-the-auto-compact-window) salva qui. Per quel modello, il valore ha la precedenza su un [`autoCompactWindow`](#autocompactwindow) di livello superiore nello stesso file di impostazioni. Richiede Claude Code v2.1.288 o successivo
* **Default**: non impostato

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

Questo esempio mantiene Opus 5.5 a `high` mentre altri modelli utilizzano i loro livelli salvati o default:

```json settings.json theme={null}
{
  "modelSettings": {
    "claude-opus-5-5": {
      "effortLevel": "high"
    }
  }
}
```

Esegui `/effort auto` per cancellare il tuo livello salvato per il modello che stai utilizzando. Claude Code lascia le altre voci e qualsiasi `effortLevel` di livello superiore in posizione.

### `outputStyle`

Seleziona uno [stile di output](https://code.claude.com/docs/it/output-styles.md) per nome. Uno stile di output è un insieme salvato di istruzioni che cambia il ruolo, il tono e il formato di output di Claude, come gli stili Explanatory e Learning integrati o uno che hai scritto tu stesso.

Se cambi questa chiave durante una sessione, Claude utilizza il nuovo stile a partire dal tuo prossimo messaggio. Per quale costo ha in prompt caching, vedi [Cambio dello stile di output](https://code.claude.com/docs/it/prompt-caching.md#changing-output-style). Prima della v2.1.251, la modifica si applicava solo dopo aver eseguito `/clear` o avviato una nuova sessione.

* **Scope**: [`Any file`](#scopes)
* **Type**: string, il nome di uno [stile di output integrato](https://code.claude.com/docs/it/output-styles.md#built-in-output-styles) o [personalizzato](https://code.claude.com/docs/it/output-styles.md#create-a-custom-output-style)
* **Default**: non impostato, quindi Claude Code utilizza lo stile predefinito

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

```json settings.json theme={null}
{
  "outputStyle": "Explanatory"
}
```

### `promptCacheTtl`

Scegli quanto tempo la [cache prompt](https://code.claude.com/docs/it/prompt-caching.md) mantiene la conversazione principale. Questa chiave si applica ai tuoi turni interattivi, `-p`, e Agent SDK, insieme agli helper che Claude Code esegue inline con loro. La durata di un'ora mantiene la cache calda attraverso pause più lunghe, e l'API [fattura ogni scrittura di cache a una tariffa più elevata](https://platform.claude.com/docs/en/build-with-claude/prompt-caching#pricing) rispetto alla durata di cinque minuti. Richiede Claude Code v2.1.242 o successivo.

* **Scope**: [`Any file`](#scopes)
* **Type**: string, uno di:
  * `"5m"`: la cache si mantiene per cinque minuti
  * `"1h"`: la cache si mantiene per un'ora
* **Default**: non impostato, quindi ogni richiesta di conversazione principale ottiene la [sua durata predefinita](https://code.claude.com/docs/it/prompt-caching.md#which-ttl-each-request-gets)
* **Per-session overrides**: [`FORCE_PROMPT_CACHING_5M`](https://code.claude.com/docs/it/env-vars) ha la precedenza su tutto il resto, poi [`CLAUDE_CODE_PROMPT_CACHE_TTL`](https://code.claude.com/docs/it/env-vars), poi questa chiave, e per ultimo [`ENABLE_PROMPT_CACHING_1H`](https://code.claude.com/docs/it/env-vars)

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

```json settings.json theme={null}
{
  "promptCacheTtl": "1h",
  "subagentPromptCacheTtl": "5m"
}
```

Per quale costo ha ogni durata, vedi [Durata della cache](https://code.claude.com/docs/it/prompt-caching.md#cache-lifetime).

### `showThinkingSummaries`

Visualizza i riepiloghi del [ragionamento esteso](https://code.claude.com/docs/it/model-config.md#extended-thinking) di Claude nelle sessioni interattive. Impostalo se vuoi i riepiloghi completi quando espandi il ragionamento con `Ctrl+O`. Quando non è impostato o è `false`, l'API Anthropic oscura i blocchi di ragionamento e Claude Code mostra uno stub compresso.

* **Scope**: [`Any file`](#scopes)
* **Type**: Boolean
  * `true`: vedi riassunti di pensiero completi quando espandi il pensiero con `Ctrl+O`
  * `false`: l'API Anthropic redige i blocchi di pensiero e Claude Code mostra uno stub compresso
* **Default**: `false`

```json settings.json theme={null}
{
  "showThinkingSummaries": true
}
```

La redazione cambia solo quello che vedi, non quello che il modello genera. Per ridurre la spesa di pensiero, [abbassa il budget o disattiva il pensiero](https://code.claude.com/docs/it/model-config.md#extended-thinking) invece.

### `subagentPromptCacheTtl`

Scegli quanto tempo la [cache prompt](https://code.claude.com/docs/it/prompt-caching.md) mantiene le richieste che Claude Code fa al di fuori della conversazione principale. Questa chiave si applica ai [subagenti](https://code.claude.com/docs/it/sub-agents.md), [workflow](https://code.claude.com/docs/it/workflows.md), e alle richieste di background e helper proprie di Claude Code, come la compattazione e i titoli di sessione. La durata di un'ora mantiene la cache calda attraverso pause più lunghe, e l'API [fattura ogni scrittura di cache a una tariffa più elevata](https://platform.claude.com/docs/en/build-with-claude/prompt-caching#pricing) rispetto alla durata di cinque minuti. Richiede Claude Code v2.1.242 o successivo.

* **Scope**: [`Any file`](#scopes)
* **Type**: string, uno di:
  * `"5m"`: la cache si mantiene per cinque minuti
  * `"1h"`: la cache si mantiene per un'ora
* **Default**: non impostato, quindi ognuna di queste richieste ottiene la [sua durata predefinita](https://code.claude.com/docs/it/prompt-caching.md#which-ttl-each-request-gets)
* **Per-session overrides**: [`FORCE_PROMPT_CACHING_5M`](https://code.claude.com/docs/it/env-vars) ha la precedenza su tutto il resto, poi [`CLAUDE_CODE_SUBAGENT_PROMPT_CACHE_TTL`](https://code.claude.com/docs/it/env-vars), poi questa chiave, poi [`ENABLE_PROMPT_CACHING_1H`](https://code.claude.com/docs/it/env-vars), che chiede la durata di un'ora su ogni richiesta. Per dove il valore frontmatter proprio di un subagente si classifica, vedi [Scegli il TTL tu stesso](https://code.claude.com/docs/it/prompt-caching.md#choose-the-ttl-yourself)

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

```json settings.json theme={null}
{
  "subagentPromptCacheTtl": "1h"
}
```

Questa chiave copre le richieste che [`promptCacheTtl`](#promptcachettl) non copre, quindi imposta entrambi per scegliere una durata per ogni richiesta che Claude Code fa. Per come la cache di un subagente differisce da quella della conversazione principale, vedi [Subagenti e la cache](https://code.claude.com/docs/it/prompt-caching.md#subagents-and-the-cache).

### `switchModelsOnFlag`

Scegli cosa succede quando un [classificatore di sicurezza contrassegna una richiesta](https://code.claude.com/docs/it/model-config.md#automatic-model-fallback): passa al modello di fallback e continua, o pausa così puoi scegliere tra passare e modificare il prompt.

* **Scope**: [`Any file`](#scopes). Appare in `/config` come **Switch models when a message is flagged**, con le opzioni **Switch automatically** e **Ask each time**.
* **Type**: Boolean
  * `true`: Claude Code passa al modello di fallback e continua
  * `false`: in una sessione interattiva Claude Code pausa così puoi scegliere tra passare e modificare il prompt; dove nessuna finestra di dialogo può mostrare, come un'esecuzione `-p`, la richiesta contrassegnata termina come errore
* **Default**: non impostato. Claude Code cambia modello automaticamente, anche se in una sessione interattiva potrebbe [chiedere prima](https://code.claude.com/docs/it/model-config.md#ask-before-switching)

```json settings.json theme={null}
{
  "switchModelsOnFlag": false
}
```

Vedi [Chiedi prima di passare](https://code.claude.com/docs/it/model-config.md#ask-before-switching).

### `ultracode`

Avvia sessioni con [ultracode](https://code.claude.com/docs/it/workflows.md#let-claude-decide-with-ultracode) attivo. Con esso attivo, Claude pianifica un workflow per ogni compito sostanziale invece di aspettare che tu lo chieda. Claude pianifica workflow solo quando i [workflow dinamici](https://code.claude.com/docs/it/workflows.md) sono abilitati per te e il tuo modello supporta `xhigh` effort. La chiave non cambia il livello di effort della sessione: ultracode funziona a qualsiasi livello la sessione utilizza. Claude Code legge questa chiave ma non la scrive mai: `/effort ultracode` attiva ultracode solo per la sessione corrente.

* **Scope**: [`Any file`](#scopes)
* **Type**: Boolean
  * `true`: le sessioni iniziano con ultracode attivo quando i workflow dinamici sono abilitati per te e il tuo modello supporta `xhigh`
  * `false`: le sessioni iniziano con ultracode disattivato
* **Default**: non impostato, quindi ultracode è disattivato
* **Per-session overrides**: `/effort ultracode` attiva ultracode per una sessione senza questa chiave, e `/effort ultracode off` lo disattiva per una sessione quando questa chiave è `true`. Il flag `--effort ultracode` lo attiva anche per una sessione, a `xhigh` effort

```json settings.json theme={null}
{
  "ultracode": true
}
```

Il livello di effort della sessione viene da [`effortLevel`](#effortlevel), [`modelSettings`](#modelsettings), e le altre [fonti di effort](https://code.claude.com/docs/it/model-config.md#adjust-effort-level), e un [limite di effort](https://code.claude.com/docs/it/model-config.md#organization-effort-limits) come [`maxEffortLevel`](#maxeffortlevel) abbassa quel livello senza disattivare ultracode. Questo e il modulo `/effort ultracode off` richiedono Claude Code v2.1.284 o successivo. Prima della v2.1.284, `ultracode: true` eseguiva la sessione a `xhigh` effort, e un limite di effort inferiore a `xhigh` manteneva ultracode disattivato. Una richiesta di controllo `apply_flag_settings` di Agent SDK accetta anche la chiave.

## Impostazioni dei permessi

Decidi cosa Claude può fare senza chiedere, in quale modalità di permesso inizia una sessione e cosa consente il classificatore della modalità auto. Per la sintassi delle regole e il modello dei permessi, consulta [Configurare i permessi](https://code.claude.com/docs/it/permissions.md).

### `allowManagedPermissionRulesOnly`

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

Quando si applicano [le impostazioni padre da un host di incorporamento](https://code.claude.com/docs/it/managed-settings.md#let-an-embedding-host-add-policy), Claude Code le tratta come parte del livello gestito. Scarta le loro regole `allow` e `additionalDirectories` e mantiene le loro regole `deny` e `ask`, eccetto le regole `Read` e `Edit` il cui modello inizia con `!`. Un host non può escludere percorsi dalle regole gestite con una regola `!`, indipendentemente dal fatto che tu imposti questa chiave.

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

Per cosa può escludere un modello `!` in una regola `--disallowedTools` o di sessione, consulta [Regole Read e Edit](https://code.claude.com/docs/it/permissions.md#read-and-edit).

Quando imposti questa chiave, Claude Code v2.1.282 o successivo ignora anche il frontmatter [`allowed-tools`](https://code.claude.com/docs/it/skills#pre-approve-tools-for-a-skill) nelle skill e nei file `.claude/commands/` provenienti da queste fonti:

* La directory `.claude/` di un repository
* Le tue directory `~/.claude/skills/` e `~/.claude/commands/`, incluse le [skill sincronizzate da claude.ai](https://code.claude.com/docs/it/skills.md#where-synced-skills-load)
* Una directory `--add-dir`
* I [plugin dichiarati con un manifest `.claude-plugin`](https://code.claude.com/docs/it/plugins/loading#plugins-shared-through-a-repository) all'interno di `~/.claude/skills/` o di `.claude/skills/` del progetto
* I plugin caricati per una sola sessione, i cui id terminano con [`@inline`](https://code.claude.com/docs/it/plugins/loading#find-where-a-plugin-came-from), quando valgono tutte queste condizioni:
  * La sessione è una [sessione Code](https://code.claude.com/docs/it/desktop.md#environment-configuration) o una [sessione Cowork](https://code.claude.com/docs/it/managed-settings.md#where-and-when-a-policy-applies), diversa da una sessione cloud, per cui è l'app Claude Desktop stessa ad avviare Claude Code
  * Le tue impostazioni gestite impostano la chiave, non solo le [impostazioni padre](https://code.claude.com/docs/it/managed-settings.md#let-an-embedding-host-add-policy) di un host di incorporamento
  * La sessione esegue Claude Code v2.1.305 o successivo

Le skill provenienti dalle impostazioni gestite e le skill incluse mantengono il loro `allowed-tools`. Anche i plugin `@inline` al di fuori di quelle sessioni Desktop mantengono il loro, eccetto uno denominato [`anthropic-skills`](https://code.claude.com/docs/it/skills#names-reserved-for-synced-skills). Il `disallowed-tools` di una skill si applica comunque. Per cosa vede uno sviluppatore quando Claude Code ignora il campo, consulta [Quando si applicano solo le regole di permesso gestite](https://code.claude.com/docs/it/skills.md#when-only-managed-permission-rules-apply).

* **Ambito**: [`Managed`](#scopes)
* **Tipo**: Booleano
  * `true`: le impostazioni gestite diventano l'unica fonte di impostazioni delle regole di permesso
  * `false`: Claude Code applica le regole di permesso dai file utente, progetto, locale e `--settings` oltre a quelle gestite
* **Predefinito**: non impostato, quindi Claude Code applica le regole di permesso dalle impostazioni utente, progetto e locale e da `--settings`, oltre a quelle gestite

```json managed-settings.json theme={null}
{
  "allowManagedPermissionRulesOnly": true
}
```

Questa chiave non blocca l'allowlist dei server MCP; per farlo, imposta [`allowManagedMcpServersOnly`](#allowmanagedmcpserversonly). Consulta [Impostazioni solo gestite](https://code.claude.com/docs/it/managed-settings.md#managed-only-settings).

### `autoMode`

Aggiungi le tue regole a ciò che il classificatore della [modalità auto](https://code.claude.com/docs/it/permission-modes.md#eliminate-prompts-with-auto-mode) blocca e consente. Usalo per dire al classificatore quali repository, bucket e domini la tua organizzazione ritiene affidabili, in modo che smetta di bloccare le operazioni interne di routine. Il classificatore viene fornito con [regole di consenso e di negazione integrate](https://code.claude.com/docs/it/auto-mode-config.md#inspect-the-defaults-and-your-effective-config). Includi la stringa letterale `"$defaults"` in un array per mantenere quelle regole integrate in quella posizione e aggiungere le tue intorno; omettila per sostituirle con le tue.

* **Ambito**: [`User or managed`](#scopes)
* **Tipo**: oggetto con array `environment`, `allow`, `soft_deny` e `hard_deny` di regole in prosa, più il Booleano [`classifyAllShell`](#automode-classifyallshell)
* **Predefinito**: non impostato, quindi il classificatore utilizza solo le sue [regole integrate](https://code.claude.com/docs/it/auto-mode-config.md#inspect-the-defaults-and-your-effective-config)

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

```json settings.json theme={null}
{
  "autoMode": {
    "soft_deny": ["$defaults", "Never run terraform apply"]
  }
}
```

Quando più di uno di questi file imposta lo stesso array, Claude Code concatena le voci. Per il formato della regola e come viene applicato ogni array, consulta [Configurare la modalità auto](https://code.claude.com/docs/it/auto-mode-config.md).

### `autoMode.classifyAllShell`

Invia ogni comando Bash e PowerShell attraverso il classificatore della modalità auto mentre la modalità auto è attiva. Per impostazione predefinita, la modalità auto sospende solo le regole di consenso che potrebbero eseguire codice arbitrario: regole a livello di strumento e wildcard come `Bash(*)` e prefissi di interprete o shell-wrapper come `Bash(python *)`. Un comando che corrisponde a qualsiasi altra regola di consenso, come `Bash(npm test)`, salta il classificatore a meno che non porti con sé [domini consentiti per comando](https://code.claude.com/docs/it/sandboxing.md#per-command-allowed-domains-in-auto-mode). Quando lo salta, un argomento distruttivo che il prefisso della regola non aveva previsto può passare inosservato. L'impostazione di questa chiave sospende ogni regola di consenso della shell per la sessione, in modo che il classificatore veda ogni comando. Richiede Claude Code v2.1.193 o successivo.

* **Ambito**: [`User or managed`](#scopes). Viene letta ovunque venga letto [`autoMode`](#automode).
* **Tipo**: Booleano
  * `true`: mentre la modalità auto è attiva, Claude Code invia ogni comando Bash e PowerShell attraverso il classificatore e sospende le tue regole di consenso della shell; al di fuori della modalità auto le regole si applicano ancora
  * `false`: la modalità auto sospende solo le regole di consenso che potrebbero eseguire codice arbitrario, come `Bash(*)` e `Bash(python *)`; un comando che corrisponde a qualsiasi altra regola di consenso salta il classificatore a meno che non porti con sé [domini consentiti per comando](https://code.claude.com/docs/it/sandboxing.md#per-command-allowed-domains-in-auto-mode), e ogni altro comando shell passa attraverso di esso
* **Predefinito**: `false`

```json settings.json theme={null}
{
  "autoMode": {
    "classifyAllShell": true
  }
}
```

Consulta [Instradare tutti i comandi shell attraverso il classificatore](https://code.claude.com/docs/it/auto-mode-config.md#route-all-shell-commands-through-the-classifier).

### `disableAutoMode`

Rimuovi la [modalità auto](https://code.claude.com/docs/it/permission-modes.md#eliminate-prompts-with-auto-mode) dal ciclo `Shift+Tab`. Qualsiasi sessione che altrimenti [inizierebbe in modalità auto](https://code.claude.com/docs/it/permission-modes.md#which-mode-a-session-starts-in), sia da `--permission-mode auto`, da un file di impostazioni o dal predefinito integrato, inizia invece in `default`. Gli amministratori la impostano nelle impostazioni gestite per impedire agli sviluppatori della loro organizzazione di utilizzare la modalità auto.

* **Ambito**: [`Any file`](#scopes). Più utile nelle [impostazioni gestite](https://code.claude.com/docs/it/managed-settings.md), dove gli utenti non possono sovrascriverla. Accettata anche sotto `permissions` come `permissions.disableAutoMode`.
* **Tipo**: la stringa `"disable"`
* **Predefinito**: non impostato

```json settings.json theme={null}
{
  "disableAutoMode": "disable"
}
```

### `permissions`

Controlla quali strumenti Claude può utilizzare senza chiedere, per quali chiede sempre conferma e quali sono bloccati, e imposta la [modalità di permesso](https://code.claude.com/docs/it/permission-modes.md) in cui inizia una sessione. Ogni chiave `permissions.*` di seguito si annida sotto questo oggetto.

* **Ambito**: [`Any file`](#scopes)
* **Tipo**: oggetto con `allow`, `ask`, `deny`, `additionalDirectories`, `blockReadsOutsideWorkingDirectories`, `defaultMode`, `disableBypassPermissionsMode` e `disableAutoMode`
* **Predefinito**: non impostato

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

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

I tre array di regole condividono una sintassi; consulta [Sintassi delle regole di permesso](#permission-rule-syntax) sotto `permissions.allow`. Per come si combinano le regole di permesso da file diversi, consulta [come viene eseguito il merge delle regole di permesso tra gli ambiti](https://code.claude.com/docs/it/permissions.md#settings-precedence); per come si combinano in generale le chiavi delle impostazioni, consulta [Precedenza delle impostazioni](https://code.claude.com/docs/it/settings.md#settings-precedence) nella guida alle impostazioni.

### `useAutoModeDuringPlan`

Scegli se Claude Code utilizza il classificatore della modalità auto per esaminare i comandi shell in plan mode. Con il valore predefinito `true`, il classificatore esamina ogni comando durante la pianificazione quando la modalità auto è disponibile e non vedi alcuna richiesta di conferma, eccetto per le [rimozioni di percorsi critici](https://code.claude.com/docs/it/permission-modes.md#critical-paths). Imposta `false` per ottenere una richiesta di permesso per ogni comando al di fuori dell'insieme integrato di sola lettura. Appare in `/config` come **Use auto mode during plan**.

* **Ambito**: [`User, local, or managed`](#scopes). Un repository non può disattivarla per te.
* **Tipo**: Booleano
  * `true`: equivale a non impostato; quando la modalità auto è disponibile, il classificatore esamina ogni comando shell durante la pianificazione invece di chiederti conferma, eccetto le [rimozioni di percorsi critici](https://code.claude.com/docs/it/permission-modes.md#critical-paths). Un `false` in uno qualsiasi di questi file la disattiva comunque
  * `false`: ricevi una richiesta di permesso per ogni comando al di fuori dell'insieme integrato di sola lettura
* **Predefinito**: `true`

```json settings.json theme={null}
{
  "useAutoModeDuringPlan": false
}
```

### `permissions.allow`

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

* **Ambito**: [`Any file`](#scopes)
* **Tipo**: array di stringhe di regole di permesso
* **Predefinito**: non impostato
* **Override per sessione**: `--allowedTools` aggiunge regole di consenso per una sessione, e una regola di negazione da qualsiasi file di impostazioni blocca comunque uno strumento che nomina

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

```json settings.json theme={null}
{
  "permissions": {
    "allow": ["Bash(git diff *)", "Read(~/.zshrc)"]
  }
}
```

Claude Code applica le regole `allow` dal `.claude/settings.json` di un progetto solo dopo che accetti la [finestra di dialogo di fiducia del workspace](https://code.claude.com/docs/it/permissions.md#project-allow-rules-and-workspace-trust) per quella cartella.

#### Sintassi delle regole di permesso

Le regole di permesso seguono il formato `Tool` o `Tool(specifier)`. Claude Code valuta prima le regole `deny`, poi `ask`, poi `allow`, e la prima corrispondenza decide indipendentemente da quanto sia specifica ogni regola; consulta l'[ordine di valutazione delle regole di permesso](https://code.claude.com/docs/it/permissions.md#manage-permissions).

Ogni riga mostra una forma di regola e a cosa corrisponde.

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

Per la sintassi completa delle regole, incluso il comportamento dei wildcard, i modelli specifici dello strumento per le regole Read, Edit, WebFetch, MCP e Agent e i limiti di sicurezza dei modelli Bash, consulta [Sintassi delle regole di permesso](https://code.claude.com/docs/it/permissions.md#permission-rule-syntax).

### `permissions.ask`

Elenca gli usi degli strumenti per cui ti viene chiesta conferma anche in una modalità di permesso che altrimenti li approverebbe, come `acceptEdits` o `bypassPermissions`. In modalità `dontAsk` Claude Code nega un uso dello strumento corrispondente invece di chiedere.

* **Ambito**: [`Any file`](#scopes)
* **Tipo**: array di stringhe di regole di permesso
* **Predefinito**: non impostato

```json settings.json theme={null}
{
  "permissions": {
    "ask": ["Bash(git push *)"]
  }
}
```

### `permissions.deny`

Elenca gli usi degli strumenti che Claude Code blocca. Usalo per file che contengono chiavi API, segreti o valori di ambiente: Claude Code esclude i file corrispondenti dalla scoperta dei file e dai risultati della ricerca, ne nega le letture e blocca gli [strumenti Edit e Write](https://code.claude.com/docs/it/permissions.md#read-and-edit) sui percorsi corrispondenti.

Le regole di negazione Read e Edit si applicano agli strumenti di file integrati di Claude, ai comandi di file che Claude Code riconosce in Bash, come `cat`, `head`, `tail`, `sed` e `tee`, e ai target dei [reindirizzamenti](https://code.claude.com/docs/it/permissions.md#redirections) Bash come `> file` e `< file`; non si applicano a un comando che legge file senza nominarli, come `grep -r pattern .`, o a sottoprocessi arbitrari, quindi per l'applicazione a livello di sistema operativo [abilita la sandbox](https://code.claude.com/docs/it/sandboxing.md).

* **Ambito**: [`Any file`](#scopes)
* **Tipo**: array di stringhe di regole di permesso
* **Predefinito**: non impostato
* **Override per sessione**: `--disallowedTools` aggiunge regole di negazione per una sessione insieme a questa chiave

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

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

I nomi degli strumenti accettano modelli glob, quindi `"*"` nega ogni strumento e `"mcp__*"` nega ogni strumento MCP. Claude Code ignora una regola di negazione per lo strumento [`EndConversation`](https://code.claude.com/docs/it/tools-reference#endconversation-tool-behavior) finché qualsiasi altro strumento è ancora disponibile per Claude. Una regola di negazione `Bash` corrisponde al comando così come Claude lo scrive, quindi `Bash(curl *)` non ferma `/usr/bin/curl` o `sh -c 'curl …'`; consulta [a cosa non corrisponde una regola Bash](https://code.claude.com/docs/it/permissions.md#bash-rule-limits). Questa chiave sostituisce la configurazione deprecata `ignorePatterns`.

### `permissions.additionalDirectories`

Dai a Claude l'accesso ai file nelle directory al di fuori di quella in cui hai iniziato, come [directory di lavoro](https://code.claude.com/docs/it/permissions.md#working-directories) aggiuntive. La maggior parte della configurazione `.claude/` [non viene rilevata](https://code.claude.com/docs/it/permissions.md#additional-directories-grant-file-access-not-configuration) da queste directory.

* **Ambito**: [`Any file`](#scopes), con [limiti sull'accesso in scrittura della sandbox](https://code.claude.com/docs/it/sandboxing.md#repository-settings-under-an-admin-required-sandbox) concesso dalle voci di progetto e locali
* **Tipo**: array di percorsi di directory
* **Predefinito**: non impostato
* **Override per sessione**: `--add-dir` e `/add-dir` aggiungono directory per una sessione insieme a questa chiave

```json settings.json theme={null}
{
  "permissions": {
    "additionalDirectories": ["../docs/"]
  }
}
```

Come le regole `allow`, le voci nel `.claude/settings.json` di un progetto hanno effetto solo dopo che accetti la [finestra di dialogo di fiducia del workspace](https://code.claude.com/docs/it/permissions.md#project-allow-rules-and-workspace-trust) per quella cartella.

### `permissions.blockReadsOutsideWorkingDirectories`

Fai sì che gli strumenti di file di Claude rifiutino le letture al di fuori delle tue [directory di lavoro](https://code.claude.com/docs/it/permissions.md#working-directories) in ogni modalità di permesso, inclusa `bypassPermissions`. Claude Code nega le chiamate `Read`, `Grep`, `Glob` e `LSP` su quei percorsi e dice a Claude di chiederti di aggiungere la directory con `/add-dir`. I file di cui Claude Code stesso ha bisogno rimangono leggibili, come le tue skill, i plugin, le regole, gli agenti, i comandi e il file di memoria `CLAUDE.md` sotto `~/.claude/`. Richiede Claude Code v2.1.257 o successivo.

Claude Code non rifiuta i comandi shell allo stesso modo:

* [Azioni che nessuna modalità approva automaticamente](https://code.claude.com/docs/it/permission-modes.md#actions-no-mode-auto-approves) spiega quando un comando shell che legge un tale percorso ti chiede conferma
* [Comandi in sandbox sotto il blocco](#sandboxed-commands-under-the-block) spiega cosa può leggere un comando in sandbox

Un comando Bash che il parser della shell non riesce a tracciare, come uno che cambia directory più di una volta o esegue una subshell, ti chiede conferma anche in modalità auto e in modalità `bypassPermissions`. La richiesta appare anche quando il comando non nomina alcun percorso al di fuori delle directory di lavoro. Questa richiesta non si applica quando il comando viene eseguito nella [sandbox](https://code.claude.com/docs/it/sandboxing.md) e la sandbox applica il blocco.

Claude Code scrive `true` qui anche quando scegli di bloccare tali letture nella [richiesta della modalità auto prima della prima lettura al di fuori delle directory di lavoro](https://code.claude.com/docs/it/permission-modes.md#first-read-outside-the-working-directories).

* **Ambito**: [`Any file`](#scopes). Un `true` in qualsiasi file si applica, quindi un repository può attivare il blocco per se stesso ma non può rimuovere il tuo.
* **Tipo**: Booleano
  * `true`: gli strumenti di file di Claude rifiutano le letture al di fuori delle directory di lavoro
  * `false`: equivale a non impostato; il blocco si applica comunque se un altro file imposta `true`
* **Predefinito**: non impostato, quindi le letture al di fuori delle directory di lavoro seguono la tua [modalità di permesso](https://code.claude.com/docs/it/permission-modes.md)

```json settings.json theme={null}
{
  "permissions": {
    "blockReadsOutsideWorkingDirectories": true
  }
}
```

Le directory che aggiungi con `--add-dir`, `/add-dir` o `additionalDirectories` nelle tue impostazioni utente o gestite contano come directory di lavoro per il blocco. Le directory aggiunte solo nelle impostazioni del repository non contano: quelle in `.claude/settings.json` e quelle in `.claude/settings.local.json`, a meno che git non segnali quel file come non tracciato. In una directory che non è un repository git, o quando git traccia il file, Claude Code tratta `.claude/settings.local.json` come impostazioni del repository, quindi metti invece le directory che vuoi mantenere leggibili nelle tue impostazioni utente.

Quando [`autoMemoryDirectory`](#automemorydirectory) proviene dal `.claude/settings.json` del progetto, o da un `.claude/settings.local.json` [trattato come fornito dal repository](https://code.claude.com/docs/it/permissions.md#when-your-local-settings-file-needs-trust), Claude Code non carica alcuna [memoria automatica](https://code.claude.com/docs/it/memory.md#storage-location) da quella directory e non vi salva nulla.

Per rimuovere il blocco, elimina la chiave da ogni file di impostazioni che la imposta, quindi avvia una nuova sessione.

#### Comandi in sandbox sotto il blocco

Quando il [sandboxing](https://code.claude.com/docs/it/sandboxing.md) è attivo, il blocco copre anche i comandi in sandbox. Claude Code nega loro l'accesso in lettura alla tua directory home e alle altre radici che contengono file utente: `/Users`, `/home`, `/root`, `/Volumes`, `/mnt`, `/media`, `/run/media` e `/srv`. Quindi riapre le directory di lavoro, i [worktree](https://code.claude.com/docs/it/worktrees.md) che Claude Code crea nella sessione, la directory temporanea della sessione e le parti di `~/.claude` di cui i comandi hanno bisogno, come skill e plugin. Mentre il blocco è in vigore, le voci `allowRead` e `allowWrite` dalle impostazioni del repository non contano.

Quando la directory di lavoro della sessione è un [worktree git](https://code.claude.com/docs/it/worktrees.md) collegato, incluso uno in cui Claude Code è entrato a metà sessione, la directory `.git` comune del repository rimane leggibile e scrivibile per i comandi in sandbox, in modo che git continui a funzionare lì.

In questi casi il blocco non raggiunge i comandi in sandbox, mentre gli strumenti di file di Claude continuano ad applicarlo:

* L'isolamento del file system è disattivato tramite [`sandbox.filesystem.disabled`](#sandbox-filesystem-disabled)
* [`allowManagedReadPathsOnly`](#sandbox-filesystem-allowmanagedreadpathsonly) è impostato
* Il percorso della directory in cui hai avviato Claude Code contiene un carattere glob come `*`, `?` o `[`

Sotto il blocco, Claude Code riapre i tuoi file di configurazione git globali ai comandi in sandbox in modo che `git` mantenga la tua identità e le tue impostazioni:

* `~/.gitconfig`
* I file `config`, `ignore` e `attributes` sotto `$XDG_CONFIG_HOME/git`, che per impostazione predefinita è `~/.config/git`
* I file che la tua configurazione git globale nomina tramite `[include]`, `[includeIf]`, `core.excludesFile` o `core.attributesFile`

Claude Code valuta ogni file separatamente. Quando un file si trova dove un comando in sandbox può scrivere, direttamente o tramite un collegamento simbolico, Claude Code non riapre i file che esso nomina.

Su Linux e WSL2, un file di configurazione che è un collegamento simbolico può rimanere illeggibile nel proprio percorso, e `git` viene quindi eseguito senza di esso. `~/.git-credentials` e `$XDG_CONFIG_HOME/git/credentials` rimangono bloccati.

Se un file riaperto contiene un segreto, come un token `http.extraHeader`, aggiungi il suo percorso a [`sandbox.filesystem.denyRead`](#sandbox-filesystem-denyread). Una voce `denyRead` che copre un file ha sempre la precedenza su questa riapertura.

### `permissions.defaultMode`

Imposta la [modalità di permesso](https://code.claude.com/docs/it/permission-modes.md) in cui iniziano le nuove sessioni. Quando la lasci non impostata, le sessioni iniziano nel [predefinito integrato](https://code.claude.com/docs/it/permission-modes.md#which-mode-a-session-starts-in) per la tua superficie.

* **Ambito**: [`Any file`](#scopes). `auto` e `bypassPermissions` non hanno effetto dalle impostazioni di progetto o locali, quindi impostali invece in `~/.claude/settings.json`. Prima della v2.1.257, `bypassPermissions` aveva effetto da qualsiasi file. Per le conversazioni avviate dall'estensione VS Code, Claude Code legge solo i valori utente, gestiti e `--settings`.
* **Tipo**: stringa, uno di:
  * `"default"`: Claude Code esegue senza chiedere solo le letture
  * `"acceptEdits"`: Claude Code esegue senza chiedere anche modifiche ai file e comandi comuni del file system come `mkdir` e `mv`
  * `"plan"`: Claude Code legge e pianifica ma blocca le modifiche finché non approvi un piano
  * `"auto"`: Claude Code procede senza richieste di conferma di routine; prima che vengano eseguite azioni come comandi shell e richieste di rete, un classificatore in background verifica che siano in linea con la tua richiesta
  * `"dontAsk"`: Claude Code nega automaticamente ogni chiamata per cui altrimenti chiederebbe conferma, anche se un [mod](https://code.claude.com/docs/it/plugins/mods/overview.md) che hai installato può comunque approvare [alcune di queste chiamate](https://code.claude.com/docs/it/permissions.md#precedence-among-rules-hooks-and-mods). Le letture di file all'interno delle tue directory di lavoro, le altre azioni che non richiedono approvazione e gli strumenti pre-approvati vengono comunque eseguiti, eccetto le letture da [percorsi di rete](https://code.claude.com/docs/it/permissions.md#network-paths)
  * `"bypassPermissions"`: Claude Code esegue tutto senza chiedere
  * `"manual"`: un alias per `"default"`
* **Predefinito**: non impostato
* **Override per sessione**: `--permission-mode` e il suo equivalente `--dangerously-skip-permissions` per `bypassPermissions` hanno la precedenza su questa chiave per una sessione

```json settings.json theme={null}
{
  "permissions": {
    "defaultMode": "acceptEdits"
  }
}
```

Le regole di permesso si sovrappongono a ogni modalità: le regole `deny` bloccano in ogni modalità, inclusa `bypassPermissions`. Consulta [Modalità di permesso](https://code.claude.com/docs/it/permission-modes.md). Nelle sessioni cloud, Claude Code rispetta solo `acceptEdits`, `plan`, `default` e `auto` da questa chiave. Per le conversazioni avviate dall'estensione VS Code, consulta [quale impostazione legge l'estensione per la modalità di permesso iniziale](https://code.claude.com/docs/it/permission-modes.md#switch-permission-modes).

### `permissions.disableBypassPermissionsMode`

Impedisci a chiunque di entrare in modalità `bypassPermissions`. Claude Code rifiuta quindi il flag `--dangerously-skip-permissions` e ignora il `permissionMode: bypassPermissions` della [definizione di un agente](https://code.claude.com/docs/it/sub-agents.md#permission-modes), quindi il subagent viene eseguito con la modalità di permesso della sessione padre.

* **Ambito**: [`Any file`](#scopes). Tipicamente impostata nelle [impostazioni gestite](https://code.claude.com/docs/it/managed-settings.md) per applicare la policy dell'organizzazione.
* **Tipo**: la stringa `"disable"`
* **Predefinito**: non impostato
* **Override per sessione**: questa chiave ha la precedenza su `--dangerously-skip-permissions`, che Claude Code rifiuta finché la chiave è impostata

```json settings.json theme={null}
{
  "permissions": {
    "disableBypassPermissionsMode": "disable"
  }
}
```

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

### `skipAutoPermissionPrompt`

Salta l'avviso una tantum che descrive la [modalità auto](https://code.claude.com/docs/it/permission-modes.md#eliminate-prompts-with-auto-mode) che Claude Code mostra quando entri per la prima volta in modalità auto di tua iniziativa, ad esempio tramite le tue impostazioni o il selettore di modalità, anziché quando è il predefinito integrato ad avviare una sessione in quella modalità. Claude Code mostra quell'avviso una volta e poi registra che è stato mostrato, quindi questa chiave conta solo dove l'avviso non è ancora apparso.

* **Ambito**: [`User or managed`](#scopes). Un repository non può impostarla per te.
* **Tipo**: Booleano
  * `true`: Claude Code salta l'avviso
  * `false`: equivale a non impostato; l'avviso appare una volta a meno che un altro di questi file non imposti `true`
* **Predefinito**: non impostato, quindi l'avviso appare una volta

```json settings.json theme={null}
{
  "skipAutoPermissionPrompt": true
}
```

### `skipDangerousModePermissionPrompt`

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

* **Ambito**: [`User, local, or managed`](#scopes). Un repository non attendibile non può saltare la finestra di dialogo per te.
* **Tipo**: Booleano
  * `true`: Claude Code salta la finestra di dialogo di conferma prima che una sessione entri in modalità `bypassPermissions`
  * `false`: equivale a non impostato; la finestra di dialogo appare a meno che un altro di questi file non imposti `true`
* **Predefinito**: non impostato, quindi la finestra di dialogo appare

```json settings.json theme={null}
{
  "skipDangerousModePermissionPrompt": true
}
```

## Impostazioni sandbox

Isola i comandi che Claude esegue dal tuo filesystem, dalla tua rete e dalle tue credenziali. Per informazioni su come funziona il sandboxing e sui requisiti della piattaforma, vedi [Sandboxing](https://code.claude.com/docs/it/sandboxing.md).

### `sandbox`

Isola i comandi Bash che Claude esegue dal tuo filesystem e dalla rete con il [sandboxing](https://code.claude.com/docs/it/sandboxing.md). Attiva la sandbox con `enabled`, quindi restringi o amplia ciò che i comandi in sandbox possono toccare con i sotto-oggetti `filesystem`, `network` e `credentials`. La sandbox funziona su macOS, Linux e WSL2.

* **Scope**: [`Any file`](#scopes)
* **Tipo**: oggetto con `enabled`, `failIfUnavailable`, `autoAllowBashIfSandboxed`, `excludedCommands`, `allowUnsandboxedCommands`, `enableWeakerNestedSandbox`, `enableWeakerNetworkIsolation`, `allowAppleEvents`, `allowNestedUserNamespaces`, `bwrapPath`, `socatPath`, `ignoreViolations` e `ripgrep`, più gli oggetti `filesystem`, `network` e `credentials`
* **Default**: non impostato, quindi Claude Code esegue i comandi senza sandbox

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

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

Quando le impostazioni gestite impostano una chiave booleana come `enabled` o `failIfUnavailable`, quel valore sovrascrive qualsiasi cosa imposti uno sviluppatore. Claude Code esegue il merge delle chiavi array negli ambiti di impostazioni che la sessione carica, quindi uno sviluppatore può aggiungere voci; vedi [Keep developers from widening the policy](https://code.claude.com/docs/it/sandboxing.md#keep-developers-from-widening-the-policy) per i blocchi solo gestiti. Per richiedere la sandbox per un'organizzazione, vedi [Enforce sandboxing with managed settings](https://code.claude.com/docs/it/sandboxing.md#enforce-sandboxing-with-managed-settings).

### `sandbox.enabled`

Attiva il [sandboxing](https://code.claude.com/docs/it/sandboxing.md) per i comandi Bash. Quando scegli una modalità nel pannello `/sandbox`, Claude Code scrive questa chiave in `.claude/settings.local.json` per il progetto corrente; impostala in `~/.claude/settings.json` per mettere in sandbox ogni progetto.

* **Scope**: [`Any file`](#scopes), con [limiti sulle impostazioni di progetto e locali](https://code.claude.com/docs/it/sandboxing.md#repository-settings-under-an-admin-required-sandbox)
* **Type**: Boolean
  * `true`: Claude Code mette in sandbox i comandi Bash
  * `false`: i comandi Bash vengono eseguiti senza sandbox
* **Default**: `false`

```json settings.json theme={null}
{
  "sandbox": {
    "enabled": true
  }
}
```

Su Linux e WSL2 la sandbox ha bisogno di `bubblewrap` e `socat`; vedi [Set up Linux and WSL2](https://code.claude.com/docs/it/sandboxing.md#set-up-linux-and-wsl2). Quando la sandbox non può avviarsi, Claude Code esegue i comandi senza sandbox a meno che tu non imposti anche [`failIfUnavailable`](#sandbox-failifunavailable).

### `sandbox.failIfUnavailable`

Fai uscire Claude Code con un errore all'avvio quando `sandbox.enabled` è `true` ma la sandbox non può avviarsi, perché una dipendenza è mancante o la piattaforma non è supportata. Senza questa chiave, Claude Code esegue i comandi senza sandbox. Le distribuzioni gestite che richiedono il sandboxing come controllo di sicurezza possono usare questa impostazione.

Su una piattaforma che la sandbox non supporta, Claude Code non si avvia con questa chiave attiva. Vedi [Enforce sandboxing with managed settings](https://code.claude.com/docs/it/sandboxing.md#enforce-sandboxing-with-managed-settings).

* **Scope**: [`Any file`](#scopes), con [limiti sulle impostazioni di progetto e locali](https://code.claude.com/docs/it/sandboxing.md#repository-settings-under-an-admin-required-sandbox)
* **Tipo**: booleano
  * `true`: Claude Code termina con un errore all'avvio quando `sandbox.enabled` è `true` ma la sandbox non riesce ad avviarsi. Se la sandbox supera quel controllo e poi non riesce a inizializzarsi, la sessione continua e Claude Code [rifiuta ogni comando in sandbox](https://code.claude.com/docs/it/sandboxing.md#commands-refused-with-sandbox-is-required)
  * `false`: Claude Code esegue i comandi fuori dalla sandbox quando la sandbox non riesce ad avviarsi
* **Default**: `false`

Questo attiva la sandbox per le macchine gestite e imposta `failIfUnavailable` su `true`:

```json managed-settings.json theme={null}
{
  "sandbox": {
    "enabled": true,
    "failIfUnavailable": true
  }
}
```

Vedi [Enforce sandboxing with managed settings](https://code.claude.com/docs/it/sandboxing.md#enforce-sandboxing-with-managed-settings).

### `sandbox.autoAllowBashIfSandboxed`

Consente a Claude Code di eseguire i comandi Bash in sandbox senza una richiesta di permesso. I comandi che non possono essere eseguiti nella sandbox passano comunque per il normale flusso dei permessi, e le regole `deny` e le regole `ask` limitate al contenuto come `Bash(git push *)` continuano ad applicarsi; una regola ask `Bash` generica viene saltata per i comandi in sandbox. Impostala su `false` per far passare anche i comandi in sandbox per il normale flusso dei permessi, che la scheda **Mode** di `/sandbox` chiama modalità dei permessi normali.

* **Scope**: [`Any file`](#scopes)
* **Type**: Boolean
  * `true`: Claude Code esegue i comandi Bash in sandbox senza una richiesta di permesso, tranne nei casi descritti in [Auto-allow mode](https://code.claude.com/docs/it/sandboxing.md#auto-allow-mode); `CLAUDE_CODE_SUBPROCESS_ENV_SCRUB` disattiva l'auto-consentimento
  * `false`: i comandi in sandbox seguono il flusso di permessi regolare, quindi decidono le tue regole allow e la modalità di permesso. La scheda **Mode** di `/sandbox` chiama questa modalità di permessi regolari
* **Default**: `true`

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

```json settings.json theme={null}
{
  "sandbox": {
    "enabled": true,
    "autoAllowBashIfSandboxed": false
  }
}
```

Vedi [Auto-allow mode](https://code.claude.com/docs/it/sandboxing.md#auto-allow-mode) per ciò per cui la modalità auto-consentimento chiede ancora conferma e come si comporta in plan mode.

### `sandbox.excludedCommands`

Nomina i comandi che Claude Code esegue al di fuori della sandbox, come gli strumenti che non funzionano sotto di essa. Ogni voce utilizza la stessa sintassi del contenuto di una [regola di permesso](https://code.claude.com/docs/it/permissions.md#permission-rule-syntax) `Bash(...)`: un comando esatto, un prefisso come `docker *` o un pattern con wildcard. Un pattern senza wildcard è una corrispondenza esatta, quindi `docker` corrisponde solo a `docker` senza argomenti.

Le tue voci tolgono una chiamata Bash dalla sandbox solo quando coprono ogni comando in essa, e alcune forme di chiamata rimangono in sandbox anche allora. Una voce `docker *` da sola non toglie `npm ci && docker build .` dalla sandbox.

* **Scope**: [`Any file`](#scopes), con [limiti sulle impostazioni di progetto e locali](https://code.claude.com/docs/it/sandboxing.md#repository-settings-under-an-admin-required-sandbox)
* **Type**: array di pattern di comando
* **Default**: non impostato, quindi nessun comando è escluso

```json settings.json theme={null}
{
  "sandbox": {
    "excludedCommands": ["docker *"]
  }
}
```

Claude Code mantiene una chiamata Bash in sandbox quando ha una di queste forme, tra le altre:

* Un comando che inizia con `sudo`, `eval` o `xargs`
* Un `cd`, `pushd` o `popd`, ovunque appaia nella chiamata
* Una sostituzione di comando, una subshell o un blocco di controllo di flusso come `if` o `for`
* Un reindirizzamento, come `docker build . > build.log`, diverso da uno che duplica solo un descrittore di file, come `2>&1`
* Un nome di comando che proviene da una variabile
* Un `git clone`, `git init`, `git worktree add`, `git worktree move` o `git bundle create` con un argomento di percorso che è assoluto, inizia con `~` o contiene un segmento `..`

Ad esempio, `cd build && docker compose up` rimane in sandbox sotto una voce `docker *`, e aggiungere una voce `cd` non cambia questo. Sotto una voce `git *`, `git clone <url> vendor/lib` viene eseguito al di fuori della sandbox, ma `git clone <url> ~/tools` rimane in sandbox. Un clone scrive un intero albero di file, possibilmente eseguibili, ovunque punti il suo percorso di destinazione.

I comandi esclusi seguono comunque il flusso di permessi regolare. L'esclusione è una comodità, non un confine di sicurezza: quando uno strumento ha solo bisogno di scrivere in un punto specifico, [`filesystem.allowWrite`](#sandbox-filesystem-allowwrite) lo mantiene in sandbox.

Le voci degli ambiti di impostazioni che la sessione carica si combinano in un unico elenco, a meno che la sandbox non sia [richiesta dall'amministratore](https://code.claude.com/docs/it/sandboxing.md#repository-settings-under-an-admin-required-sandbox). In quel caso, Claude Code ignora le voci in `.claude/settings.json` e `.claude/settings.local.json`, quindi un repository clonato non può togliere comandi dalla sandbox. Le voci nelle impostazioni gestite, in `--settings` e nel tuo `~/.claude/settings.json` si applicano comunque, e nessun blocco solo gestito copre questo elenco.

### `sandbox.allowUnsandboxedCommands`

Consenti a Claude di riprovare un comando al di fuori della sandbox con il parametro `dangerouslyDisableSandbox` dopo che la sandbox lo blocca. Quando è `false`, Claude Code ignora quel parametro. Mentre la sandbox è in esecuzione, i comandi che Claude esegue sono quindi in sandbox a meno che non corrispondano a una voce di [`excludedCommands`](#sandbox-excludedcommands). La scheda **Overrides** di `/sandbox` mostra quello stato come **Strict sandbox mode**. Un `false` nelle impostazioni gestite attiva la modalità sandbox rigorosa per gli sviluppatori che queste coprono.

* **Scope**: [`Any file`](#scopes), con [un limite sulle impostazioni di progetto e locali](https://code.claude.com/docs/it/sandboxing.md#turn-off-the-retry-with-strict-sandbox-mode)
* **Type**: Boolean
  * `true`: Claude può riprovare un comando al di fuori della sandbox con il parametro `dangerouslyDisableSandbox` dopo che la sandbox lo blocca
  * `false`: Claude Code ignora quel parametro, quindi mentre la sandbox è in esecuzione, i comandi che Claude esegue sono in sandbox a meno che non corrispondano a una voce di `excludedCommands`
* **Default**: `true`

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

```json managed-settings.json theme={null}
{
  "sandbox": {
    "enabled": true,
    "allowUnsandboxedCommands": false
  }
}
```

Un `false` dalle impostazioni gestite o da `--settings` rende anche la sandbox [richiesta dall'amministratore](https://code.claude.com/docs/it/sandboxing.md#repository-settings-under-an-admin-required-sandbox). Un `false` nelle tue impostazioni utente prevale su un `true` di un progetto ma non rende la sandbox richiesta dall'amministratore. Prevalere sul valore di un progetto richiede Claude Code v2.1.285 o successivo.

Chi approva un nuovo tentativo senza sandbox dipende dalla tua modalità di permesso e dalle tue regole allow. Vedi [The unsandboxed retry escape hatch](https://code.claude.com/docs/it/sandboxing.md#the-unsandboxed-retry-escape-hatch).

Per vedere quando i comandi che digiti tu stesso al [prompt in modalità shell `!`](https://code.claude.com/docs/it/interactive-mode#shell-mode-with-prefix) vengono eseguiti in sandbox, vedi [strict sandbox mode](https://code.claude.com/docs/it/sandboxing.md#turn-off-the-retry-with-strict-sandbox-mode).

### `sandbox.filesystem`

Controlla quali percorsi i comandi in sandbox possono leggere e scrivere. Per impostazione predefinita possono scrivere nella directory di lavoro, nella directory temporanea per utente e nelle directory che aggiungi con `--add-dir`, `/add-dir` o `permissions.additionalDirectories`, e possono leggere il resto del filesystem, inclusi i file di credenziali. Amplia o restringi con i quattro elenchi di percorsi, o disattiva il livello del filesystem con `disabled`. Vedi [Filesystem isolation](https://code.claude.com/docs/it/sandboxing.md#filesystem-isolation) per i confini predefiniti.

* **Scope**: [`Any file`](#scopes)
* **Type**: object con array `allowWrite`, `denyWrite`, `denyRead` e `allowRead`, più i booleani `allowManagedReadPathsOnly` e `disabled`
* **Default**: non impostato, quindi si applicano i confini di lettura e scrittura predefiniti

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

```json settings.json theme={null}
{
  "sandbox": {
    "filesystem": {
      "allowWrite": ["/tmp/build", "~/.kube"],
      "denyRead": ["~/.aws/credentials"]
    }
  }
}
```

Claude Code applica questi elenchi al confine della sandbox del sistema operativo, quindi si applicano a ogni sottoprocesso che un comando in sandbox avvia, come `kubectl`, `terraform` o `npm`. Claude Code aggiunge le tue [regole di permesso](https://code.claude.com/docs/it/sandboxing.md#permission-rules) agli stessi elenchi: le regole `Edit` allow e deny a `allowWrite` e `denyWrite`, le regole `Read` deny a `denyRead` e le regole `WebFetch(domain:...)` allow e deny agli elenchi di domini [`network`](#sandbox-network).

A meno che non si applichi un blocco, Claude Code esegue il merge di questi elenchi nei file di impostazioni che la sessione carica. [`allowManagedReadPathsOnly`](#sandbox-filesystem-allowmanagedreadpathsonly) limita `allowRead` alle voci dalle impostazioni gestite, e [`allowManagedDomainsOnly`](#sandbox-network-allowmanageddomainsonly) fa lo stesso per i domini consentiti. I [blocchi del repository](https://code.claude.com/docs/it/sandboxing.md#repository-settings-under-an-admin-required-sandbox) escludono le voci dai file di impostazioni di un repository.

[Configure sandboxing](https://code.claude.com/docs/it/sandboxing.md#configure-sandboxing) copre le fonti che escludi con `--setting-sources`. Quando modifichi un elenco durante una sessione, Claude Code [applica la modifica alla sessione in esecuzione](https://code.claude.com/docs/it/settings.md#when-edits-take-effect).

#### Prefissi di percorso sandbox

I percorsi in `allowWrite`, `denyWrite`, `denyRead`, `allowRead` e [`credentials.files`](#sandbox-credentials-files) si risolvono in base al loro prefisso:

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

Il prefisso `//path` per i percorsi assoluti funziona anche. Se usi un singolo slash `/path` aspettandoti una risoluzione relativa al progetto, passa a `./path`. Questa sintassi differisce dalle [regole di permesso Read e Edit](https://code.claude.com/docs/it/permissions.md#read-and-edit), che usano `//path` per assoluto e `/path` per relativo al progetto: i percorsi del filesystem sandbox usano convenzioni standard, quindi `/tmp/build` è un percorso assoluto.

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

##### Dove funzionano i caratteri jolly nei percorsi della sandbox

I caratteri jolly `*`, `?` e `**` funzionano in tutti e quattro gli elenchi di percorsi di `sandbox.filesystem` su macOS, e in meno casi su Linux e WSL2:

| Elenco di `sandbox.filesystem` | Cosa funziona su Linux e WSL2 | Esempio che non funziona su Linux e WSL2 | Cosa scrivere invece |
| :- | :- | :- | :- |
| `denyRead`, `allowRead` | Un `/**` finale funziona, quindi `~/build/**` copre la stessa directory di `~/build`. Qualsiasi altro carattere jolly funziona solo dopo il nome della prima directory del [percorso completo](#sandbox-path-prefixes) della voce. | `/**/*.pem` in `denyRead` non copre nulla, quindi non blocca alcuna lettura | `/srv/**/*.pem`, con una voce per ogni directory di primo livello |
| `allowWrite`, `denyWrite` | Funziona solo un `/**` finale, quindi `~/build/**` copre la stessa directory di `~/build` | `./src/*` copre solo un file o una directory in `src` che si chiama proprio `*`, e nulla se non esiste | `./src`, che copre tutto ciò che si trova sotto `src`, oppure una voce per ogni percorso |

In `~/keys/*.pem`, il carattere jolly viene dopo il nome della prima directory, che è `home` per una directory home `/home/alice`:

```text theme={null}
~/keys/*.pem              the entry
/home/alice/keys/*.pem    its full path
 ^^^^                     the first directory name, home
```

Su Linux e WSL2, la scheda **Config** di `/sandbox` in una sessione avvisa in caso di regole di permesso `Edit` che contengono un carattere jolly diverso da un `/**` finale. Questi caratteri jolly non funzionano per i comandi nella sandbox. Aggiungi ogni percorso che la regola deve coprire, oppure la directory che li contiene, ad `allowWrite` per una regola di consenso o a `denyWrite` per una regola di divieto.

##### Nomi di directory con parentesi quadre, graffe o tonde

Per consentire o bloccare una directory il cui nome contiene parentesi quadre, scrivi il nome così com'è, ad esempio `./app/[slug]`. In quella voce, `[slug]` è il nome reale della directory, parentesi incluse:

```text theme={null}
app/
└── [slug]/
    └── page.tsx
```

Quella voce copre tutto ciò che si trova sotto la directory, quindi ometti un `/**` finale. Su macOS e su Linux e WSL2, la directory `app/[slug]` deve esistere quando il comando nella sandbox si avvia.

* **Parentesi quadre come `[slug]`**: in ogni elenco su macOS, e in `denyRead` e `allowRead` su Linux e WSL2, le parentesi in `./app/[slug]` sono anche un pattern. La voce corrisponde quindi anche a qualsiasi percorso sotto `app` il cui nome è un carattere tra quelli di `slug`, come `app/s` o `app/g`. Con quella voce in `allowRead`, o in `allowWrite` su macOS, i comandi nella sandbox possono raggiungere anche quei percorsi. Rinomina quelli che non dovrebbero raggiungere.
* **Parentesi quadre come `[user-id]` o `[post-id]`, in cui il carattere a sinistra del trattino viene dopo quello a destra nell'ordinamento**: `./app/[user-id]` copre solo la directory con esattamente quel nome, in ogni elenco su ogni piattaforma. Prima della v2.1.304, i comandi nella sandbox su Linux e WSL2 non riuscivano ad avviarsi finché `denyRead` o `allowRead` contenevano una voce di questo tipo.
* **Parentesi graffe e tonde**: sono caratteri ordinari, quindi `~/data/{keys,tokens}` copre una sola directory chiamata `{keys,tokens}`, non due alternative. Per coprire `~/data/keys` e `~/data/tokens`, aggiungile come voci separate.

### `sandbox.filesystem.allowWrite`

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

* **Scope**: [`Any file`](#scopes), con [limiti sulle impostazioni di progetto e locali](https://code.claude.com/docs/it/sandboxing.md#repository-settings-under-an-admin-required-sandbox)
* **Type**: array di stringhe di percorso, usando i [prefissi di percorso sandbox](#sandbox-path-prefixes)
* **Default**: non impostato, quindi i comandi in sandbox possono scrivere nella directory di lavoro, nella directory temporanea per utente, nelle directory che hai aggiunto con `--add-dir` o `/add-dir` e nelle directory in [`permissions.additionalDirectories`](#permissions-additionaldirectories)

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

```json settings.json theme={null}
{
  "sandbox": {
    "filesystem": {
      "allowWrite": ["/tmp/build", "~/.kube"]
    }
  }
}
```

Claude Code esegue il merge delle voci `allowWrite` e dei percorsi dalle tue regole di permesso allow `Edit(...)` negli ambiti di impostazioni che la sessione carica, escludendo quelli dalle impostazioni del repository mentre [`permissions.blockReadsOutsideWorkingDirectories`](#sandboxed-commands-under-the-block) è attivo. Anche i [blocchi del repository](https://code.claude.com/docs/it/sandboxing.md#repository-settings-under-an-admin-required-sandbox) possono escludere le voci di un repository. Una voce `allowWrite` non può sollevare un [percorso protetto](https://code.claude.com/docs/it/sandboxing.md#protected-paths).

### `sandbox.filesystem.denyWrite`

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

* **Scope**: [`Any file`](#scopes)
* **Type**: array di stringhe di percorso, usando i [prefissi di percorso sandbox](#sandbox-path-prefixes)
* **Default**: non impostato

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

```json settings.json theme={null}
{
  "sandbox": {
    "filesystem": {
      "denyWrite": ["/etc", "/usr/local/bin"]
    }
  }
}
```

Claude Code esegue il merge delle voci in ogni ambito di impostazioni che la sessione carica, e aggiunge i percorsi dalle tue regole di permesso deny `Edit(...)`.

### `sandbox.filesystem.denyRead`

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

* **Scope**: [`Any file`](#scopes)
* **Type**: array di stringhe di percorso, usando i [prefissi di percorso sandbox](#sandbox-path-prefixes)
* **Default**: non impostato, quindi i comandi in sandbox mantengono l'[accesso in lettura predefinito](https://code.claude.com/docs/it/sandboxing.md#filesystem-isolation), che include i file di credenziali come `~/.aws/credentials`

```json settings.json theme={null}
{
  "sandbox": {
    "filesystem": {
      "denyRead": ["~/.aws/credentials"]
    }
  }
}
```

Claude Code esegue il merge delle voci in ogni ambito di impostazioni che la sessione carica, e aggiunge i percorsi dalle tue regole di permesso deny `Read(...)`. Quando [`filesystem.disabled`](#sandbox-filesystem-disabled) è `true`, Claude Code non applica queste voci.

### `sandbox.filesystem.allowRead`

Riapri la lettura per percorsi specifici all'interno di una regione che [`denyRead`](#sandbox-filesystem-denyread) blocca, per costruire un accesso in lettura solo per l'area di lavoro. Una voce `denyRead` esatta o con wildcard rimane bloccata all'interno di un `allowRead` più ampio, come mostra la [tabella di sovrapposizione](https://code.claude.com/docs/it/sandboxing.md#configure-sandboxing). Quando una voce `denyRead` con wildcard come `~/**/.env` corrisponde a una directory, Claude Code blocca anche le letture dei suoi contenuti. Prima della v2.1.236 su macOS, Claude Code riapriva i percorsi a cui corrispondeva una voce `denyRead` con wildcard ovunque una voce `allowRead` più ampia li coprisse, e lasciava leggibili i contenuti di una directory corrispondente.

* **Scope**: [`Any file`](#scopes), con [limiti sulle impostazioni di progetto e locali](https://code.claude.com/docs/it/sandboxing.md#repository-settings-under-an-admin-required-sandbox)
* **Type**: array di stringhe di percorso, usando i [prefissi di percorso sandbox](#sandbox-path-prefixes)
* **Default**: non impostato

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

```json settings.json theme={null}
{
  "sandbox": {
    "filesystem": {
      "denyRead": ["~/"],
      "allowRead": ["."]
    }
  }
}
```

Claude Code risolve una voce `.` alla radice del progetto nelle impostazioni del progetto e a `~/.claude` nelle impostazioni dell'utente. Claude Code esegue il merge delle voci nei file di impostazioni che la sessione carica a meno che [`allowManagedReadPathsOnly`](#sandbox-filesystem-allowmanagedreadpathsonly) non sia impostato, ed esclude le voci dalle impostazioni del repository mentre [`permissions.blockReadsOutsideWorkingDirectories`](#sandboxed-commands-under-the-block) è attivo. Anche i [blocchi del repository](https://code.claude.com/docs/it/sandboxing.md#repository-settings-under-an-admin-required-sandbox) possono escludere le voci di un repository.

### `sandbox.filesystem.allowManagedReadPathsOnly`

Onora solo le voci [`allowRead`](#sandbox-filesystem-allowread) che provengono dalle impostazioni gestite, in modo che gli sviluppatori non possano riaprire l'accesso in lettura ai percorsi che la tua organizzazione ha bloccato. Claude Code esegue comunque il merge delle voci `denyRead` da ogni ambito di impostazioni che la sessione carica.

* **Scope**: [`Managed`](#scopes)
* **Type**: Boolean
  * `true`: Claude Code onora solo le voci `allowRead` dalle impostazioni gestite
  * `false`: le voci `allowRead` da altri file di impostazioni possono essere incluse tramite merge
* **Default**: `false`

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

```json managed-settings.json theme={null}
{
  "sandbox": {
    "filesystem": {
      "denyRead": ["~/"],
      "allowRead": ["~/work"],
      "allowManagedReadPathsOnly": true
    }
  }
}
```

Vedi [Keep developers from widening the policy](https://code.claude.com/docs/it/sandboxing.md#keep-developers-from-widening-the-policy).

### `sandbox.filesystem.disabled`

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

* **Scope**: [`User or managed`](#scopes). Quando le impostazioni gestite configurano in qualsiasi modo `sandbox.filesystem`, o elencano una voce `sandbox.credentials.files` con `"mode": "deny"`, solo le impostazioni gestite possono impostarla.
* **Type**: Boolean
  * `true`: Claude Code salta l'isolamento del filesystem e mantiene l'isolamento della rete
  * `false`: l'isolamento del filesystem rimane attivo
* **Default**: `false`, quindi l'isolamento del filesystem rimane attivo

Questo lascia il filesystem aperto e confina il traffico di rete in uscita a GitHub e npm:

```json settings.json theme={null}
{
  "sandbox": {
    "enabled": true,
    "filesystem": {
      "disabled": true
    },
    "network": {
      "allowedDomains": ["github.com", "*.npmjs.org"]
    }
  }
}
```

Con il livello disattivato, Claude Code non applica le voci `denyRead` o `credentials.files` `deny`, mentre le voci `credentials.envVars` e le voci `mask` applicate continuano a funzionare. [`autoAllowBashIfSandboxed`](#sandbox-autoallowbashifsandboxed) ha comunque `true` come valore predefinito, quindi impostalo su `false` per continuare a ricevere richieste di conferma. Vedi [Disable filesystem isolation](https://code.claude.com/docs/it/sandboxing.md#disable-filesystem-isolation) per l'elenco completo delle fonti che possono impostarla e cosa cambia quando l'isolamento è disattivato. Richiede Claude Code v2.1.216 o successivo.

### `sandbox.ignoreViolations`

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

* **Scope**: [`Any file`](#scopes), con [limiti sulle impostazioni di progetto e locali](https://code.claude.com/docs/it/sandboxing.md#repository-settings-under-an-admin-required-sandbox)
* **Type**: object che mappa una sottostringa di comando a un array di sottostringhe di violazione, solitamente percorsi
* **Default**: non impostato, quindi ogni violazione è segnalata

```json settings.json theme={null}
{
  "sandbox": {
    "ignoreViolations": {
      "*": ["/etc/hosts"]
    }
  }
}
```

### `sandbox.enableWeakerNestedSandbox`

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

* **Scope**: [`Any file`](#scopes), con [limiti sulle impostazioni di progetto e locali](https://code.claude.com/docs/it/sandboxing.md#repository-settings-under-an-admin-required-sandbox)
* **Type**: Boolean
  * `true`: la sandbox interna esegue il bind-mount del `/proc` esistente del contenitore invece di montarne uno nuovo
  * `false`: la sandbox monta un `/proc` nuovo, che non funziona in un contenitore Docker senza privilegi
* **Default**: `false`

```json settings.json theme={null}
{
  "sandbox": {
    "enabled": true,
    "enableWeakerNestedSandbox": true
  }
}
```

Solo Linux e WSL2. Vedi [Bubblewrap fails to start inside a container](https://code.claude.com/docs/it/sandboxing.md#bubblewrap-fails-to-start-inside-a-container).

### `sandbox.enableWeakerNetworkIsolation`

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

* **Scope**: [`Any file`](#scopes), con [limiti sulle impostazioni di progetto e locali](https://code.claude.com/docs/it/sandboxing.md#repository-settings-under-an-admin-required-sandbox)
* **Type**: Boolean
  * `true`: i comandi in sandbox su macOS possono raggiungere `com.apple.trustd.agent`
  * `false`: i comandi in sandbox su macOS non possono raggiungere il servizio di fiducia TLS del sistema
* **Default**: `false`

```json settings.json theme={null}
{
  "sandbox": {
    "enabled": true,
    "enableWeakerNetworkIsolation": true
  }
}
```

Se non usi un proxy MITM, elenca invece gli strumenti che falliscono in [`excludedCommands`](#sandbox-excludedcommands); vedi [Go-based CLIs fail TLS verification on macOS](https://code.claude.com/docs/it/sandboxing.md#go-based-clis-fail-tls-verification-on-macos).

### `sandbox.allowAppleEvents`

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

* **Scope**: [`User or managed`](#scopes)
* **Type**: Boolean
  * `true`: i comandi in sandbox su macOS possono inviare Apple Events
  * `false`: i comandi in sandbox su macOS non possono inviare Apple Events, quindi `open` e `osascript` falliscono con errore `-600`
* **Default**: `false`

```json settings.json theme={null}
{
  "sandbox": {
    "enabled": true,
    "allowAppleEvents": true
  }
}
```

Per mantenere l'isolamento ed eseguire comunque uno di questi strumenti, aggiungilo invece a [`excludedCommands`](#sandbox-excludedcommands). Vedi [Apple Events on macOS](https://code.claude.com/docs/it/sandboxing.md#security-limitations).

### `sandbox.allowNestedUserNamespaces`

Consente ai comandi in sandbox su Linux e WSL2 di creare user namespace, necessari alla sandbox propria di Chromium ed Electron, a un bubblewrap annidato e a `unshare`. Se imposti questa chiave su `true`, disattivi un confine di sicurezza: il codice di un comando in sandbox può finire per essere eseguito fuori dalla sandbox. Per Podman o Buildah rootless, usa invece [`excludedCommands`](#sandbox-excludedcommands), perché la sandbox li blocca anche in altri modi. Richiede Claude Code v2.1.305 o successiva.

* **Ambito**: [`User or managed`](#scopes). Un `true` vale se proviene da `~/.claude/settings.json`, da JSON passato con `--settings` o dalle [impostazioni gestite](https://code.claude.com/docs/it/managed-settings.md). Claude Code ignora un `true` nel `.claude/settings.json` o nel `.claude/settings.local.json` di un progetto. In una sessione con [`CLAUDE_CODE_SUBPROCESS_ENV_SCRUB`](https://code.claude.com/docs/it/env-vars#variables) impostata su `1`, Claude Code ignora un `true` da qualsiasi origine. Un `false` vale da qualsiasi file, secondo la [precedenza delle impostazioni](https://code.claude.com/docs/it/settings.md#settings-precedence).
* **Tipo**: booleano
  * `true`: i comandi in sandbox possono creare user namespace
  * `false`: questa chiave non consente nulla in più, e si applica il comportamento predefinito della sandbox
* **Predefinito**: `false`

```json settings.json theme={null}
{
  "sandbox": {
    "enabled": true,
    "allowNestedUserNamespaces": true
  }
}
```

Con questa chiave attiva, non fare affidamento su nessuna delle restrizioni della sandbox, inclusi i [percorsi protetti](https://code.claude.com/docs/it/sandboxing.md#protected-paths) e le voci di [`credentials.files`](#sandbox-credentials-files), per fermare un comando dannoso. In [modalità di consenso automatico](https://code.claude.com/docs/it/sandboxing.md#auto-allow-mode), quel comando può essere eseguito senza una richiesta di permesso. Se la tua organizzazione ha un team di sicurezza, consultalo prima di attivare la chiave.

Per trovare la soluzione per il tuo strumento, consulta [Chromium o Podman rootless non funziona nella sandbox su Linux](https://code.claude.com/docs/it/sandboxing.md#chromium-or-rootless-podman-fails-inside-the-sandbox-on-linux).

### `sandbox.ripgrep`

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

* **Scope**: [`User or managed`](#scopes)
* **Type**: object con `command`, il percorso al binario ripgrep, e l'opzionale `args`, un array di argomenti da anteporre
* **Default**: non impostato, quindi la sandbox usa lo stesso binario ripgrep di Claude Code. Questo è il binario in bundle a meno che tu non imposti [`USE_BUILTIN_RIPGREP`](https://code.claude.com/docs/it/env-vars) su `0`

```json settings.json theme={null}
{
  "sandbox": {
    "ripgrep": {
      "command": "/usr/local/bin/rg"
    }
  }
}
```

### `sandbox.bwrapPath`

Punta la sandbox a un binario bubblewrap installato al di fuori di `PATH`, come una copia fornita localmente su un host air-gapped. Claude Code usa il percorso sia per il controllo delle dipendenze all'avvio sia quando avvolge ogni comando in sandbox.

* **Scope**: [`Managed`](#scopes). Claude Code lo legge solo dalle impostazioni gestite in modo che un file utente, di progetto o locale non possa puntare la sandbox a un binario diverso.
* **Type**: string, un percorso assoluto; Claude Code scarta un percorso relativo e ricade sulla ricerca in `PATH`
* **Default**: non impostato, quindi Claude Code trova `bwrap` in `PATH`

```json managed-settings.json theme={null}
{
  "sandbox": {
    "enabled": true,
    "bwrapPath": "/opt/admin/bwrap"
  }
}
```

Solo Linux e WSL2.

### `sandbox.socatPath`

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

* **Scope**: [`Managed`](#scopes)
* **Type**: string, un percorso assoluto; Claude Code scarta un percorso relativo e ricade sulla ricerca in `PATH`
* **Default**: non impostato, quindi Claude Code trova `socat` in `PATH`

```json managed-settings.json theme={null}
{
  "sandbox": {
    "enabled": true,
    "socatPath": "/opt/admin/socat"
  }
}
```

Solo Linux e WSL2.

### `sandbox.credentials`

Dichiara i file di credenziali e le variabili d'ambiente da [proteggere dai comandi in sandbox](https://code.claude.com/docs/it/sandboxing.md#protect-credentials). Ogni voce nomina un file `path` o una variabile `name` e una `mode`: `deny` nasconde la credenziale all'interno della sandbox, e `mask` mostra ai comandi in sandbox un segnaposto mentre il [proxy della sandbox](https://code.claude.com/docs/it/sandboxing.md#mask-credentials) sostituisce il valore reale sulle richieste in uscita. Claude Code protegge solo le voci che elenchi; non c'è un elenco di negazione di credenziali incorporato.

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

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

```json settings.json theme={null}
{
  "sandbox": {
    "credentials": {
      "files": [{ "path": "~/.aws/credentials", "mode": "deny" }],
      "envVars": [{ "name": "GITHUB_TOKEN", "mode": "deny" }]
    }
  }
}
```

La protezione dei file `deny` fa parte del livello del filesystem, quindi non si applica quando [disabiliti l'isolamento del filesystem](https://code.claude.com/docs/it/sandboxing.md#disable-filesystem-isolation); la protezione delle variabili d'ambiente invece continua ad applicarsi.

#### Voci di credenziali non valide nelle impostazioni gestite

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

* Una voce in `files` o `envVars` che ha ancora un `path` o `name` valido e una `mode` di `mask` o `deny`, come una il cui pattern `extract` non ha un gruppo di cattura, viene degradata a `mode: "deny"` con un avviso, quindi la credenziale rimane bloccata, non mascherata, finché non correggi la voce. Una voce `files` degradata vincola [`filesystem.disabled`](https://code.claude.com/docs/it/sandboxing#disable-filesystem-isolation) come una voce `deny` esplicita, e l'avviso segnala che il suo blocco di lettura non è applicato se le impostazioni gestite disattivano l'isolamento del filesystem.
* Una voce con una `mode` sconosciuta o un `path` o `name` non valido viene rimossa.
* Ogni caso genera un avviso; che una voce sia degradata o rimossa, le voci valide rimanenti sono ancora applicate.

Si applica nella v2.1.191 e successive; prima della v2.1.221, ogni voce non valida veniva rimossa. Per le altre chiavi gestite con gestione per campo, vedi [Invalid entries in managed settings](https://code.claude.com/docs/it/managed-settings.md#invalid-entries-in-managed-settings).

### `sandbox.credentials.files`

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

* **Scope**: [`Any file`](#scopes). Claude Code scarta le voci `mask` da `.claude/settings.json` del progetto e da `.claude/settings.local.json` locale.
* **Type**: array di object, ognuno con `path` e una `mode` di `"deny"` o `"mask"`, più i [campi mask opzionali per i file](#mask-fields-for-files)
* **Default**: non impostato, quindi nessun file di credenziali è protetto

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

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

I percorsi usano gli stessi [prefissi](#sandbox-path-prefixes) delle impostazioni `sandbox.filesystem.*`, e Claude Code esegue il merge degli array da ogni ambito di impostazioni che la sessione carica. [Protect credentials](https://code.claude.com/docs/it/sandboxing.md#protect-credentials) copre cosa si applica ancora dalle fonti che escludi con `--setting-sources`. Le voci `mask` richiedono Claude Code v2.1.221 o successivo.

La sostituzione `mask` viene eseguita solo attraverso il proxy della sandbox, quindi imposta [`sandbox.network.tlsTerminate`](#sandbox-network-tlsterminate), o [`allowPlaintextInject`](#sandbox-credentials-allowplaintextinject) per le reti di test HTTP semplice. `mask` si applica a un singolo file, quindi elenca ogni file di credenziali individualmente. Claude Code accetta ma ignora i campi `mask` su una voce `deny`. [Mask credentials](https://code.claude.com/docs/it/sandboxing.md#mask-credentials) copre quali fonti di impostazioni sono onorate, e [Mask credential files](https://code.claude.com/docs/it/sandboxing.md#mask-credential-files) copre quando una voce ricade su `deny`.

#### Campi mask per i file

Una voce `mask` accetta questi campi opzionali. Senza `extract` o `decode`, Claude Code sostituisce l'intero contenuto del file con una sentinella. Su macOS con isolamento del filesystem attivo, Claude Code applica una voce `mask` come `deny` prima che `extract` o `decode` venga eseguito; vedi [Mask credential files](https://code.claude.com/docs/it/sandboxing.md#mask-credential-files).

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

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

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

### `sandbox.credentials.envVars`

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

* **Scope**: [`Any file`](#scopes). Claude Code scarta le voci `mask` da `.claude/settings.json` del progetto e da `.claude/settings.local.json` locale.
* **Type**: array di object, ognuno con `name` e una `mode` di `"deny"` o `"mask"`, più i [campi mask opzionali per le variabili d'ambiente](#mask-fields-for-environment-variables)
* **Default**: non impostato, quindi nessuna variabile d'ambiente è protetta

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

```json settings.json theme={null}
{
  "sandbox": {
    "credentials": {
      "envVars": [
        { "name": "NPM_TOKEN", "mode": "deny" },
        { "name": "GITHUB_TOKEN", "mode": "mask", "injectHosts": ["api.github.com"] }
      ]
    }
  }
}
```

Il `name` deve iniziare con una lettera o un underscore e contenere solo lettere, cifre e underscore. Claude Code esegue il merge degli array da ogni ambito di impostazioni che la sessione carica, e applica `deny` quando la stessa variabile appare con entrambe le modalità. [Protect credentials](https://code.claude.com/docs/it/sandboxing.md#protect-credentials) copre cosa si applica ancora dalle fonti che escludi con `--setting-sources`.

La sostituzione `mask` viene eseguita solo attraverso il proxy della sandbox, quindi imposta [`sandbox.network.tlsTerminate`](#sandbox-network-tlsterminate), o [`allowPlaintextInject`](#sandbox-credentials-allowplaintextinject) per le reti di test HTTP semplice; vedi [Mask credentials](https://code.claude.com/docs/it/sandboxing.md#mask-credentials). Claude Code accetta ma ignora i campi `mask` su una voce `deny`.

#### Campi mask per le variabili d'ambiente

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

| Campo | Tipo | Cosa fa |
| :- | :- | :- |
| `extract` | string, un'espressione regolare con almeno un gruppo di cattura | Maschera solo il testo catturato dal gruppo 1 di ogni corrispondenza, come la password all'interno di una stringa di connessione `DATABASE_URL`, quindi il resto del valore rimane analizzabile. Richiede v2.1.224 o successivo |
| `onExtractNoMatch` | `"warn"`, `"deny"` o `"error"`; predefinito `"warn"`. Su una voce con `decode`, è accettato solo `"warn"` | Cosa succede quando `extract` non corrisponde a nulla. `warn` lascia passare la variabile senza mascherarla, `deny` la rimuove all'interno della sandbox, e `error` ferma la configurazione della sandbox finché non correggi la configurazione. Richiede v2.1.224 o successivo |
| `decode` | la string `"jwt"` | Verifica che l'intero valore sia un JWT e sostituiscilo con un token falso strutturalmente valido, quindi il codice all'interno della sandbox che decodifica il token continua a funzionare; il proxy sostituisce l'intero token reale in uscita. Un valore che non supera la verifica passa senza essere mascherato, con un avviso. Richiede v2.1.224 o successivo |
| `maskClaims` | array di stringhe, almeno un nome di claim; richiede `decode` | Maschera solo i claim di payload di primo livello denominati all'interno del JWT decodificato e ricostruisci il token attorno al payload modificato, quindi gli altri claim rimangono leggibili. Quando nessun claim denominato corrisponde, la variabile passa senza essere mascherata, con un avviso. Richiede v2.1.224 o successivo |
| `injectHosts` | array di stringhe, ognuna un host che anche [`sandbox.network.allowedDomains`](#sandbox-network-alloweddomains) ammette | Restringi gli host dove il proxy della sandbox sostituisce il valore reale. Quando non impostato, il proxy lo sostituisce sulle richieste a ogni host in `sandbox.network.allowedDomains`. Scrivi una destinazione IPv6 come indirizzo compresso semplice, come `"::1"`, non nella forma tra parentesi quadre; vedi [IPv6 destinations in `injectHosts`](https://code.claude.com/docs/it/sandboxing#ipv6-destinations-in-injecthosts) |

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

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

### `sandbox.credentials.allowPlaintextInject`

Consenti la sostituzione `mask` sulle richieste HTTP semplice oltre che su HTTPS con terminazione TLS. Su HTTP semplice l'identità upstream non è verificata e la credenziale viaggia in chiaro, quindi lascia questa opzione disattivata al di fuori delle reti di test attendibili.

* **Scope**: [`User or managed`](#scopes)
* **Type**: Boolean
  * `true`: Claude Code consente la sostituzione `mask` sulle richieste HTTP semplice oltre che su HTTPS con terminazione TLS
  * `false`: Claude Code consente la sostituzione `mask` solo su HTTPS con terminazione TLS
* **Default**: `false`

```json settings.json theme={null}
{
  "sandbox": {
    "credentials": {
      "allowPlaintextInject": true
    }
  }
}
```

### `sandbox.credentials.awsPairs`

Raggruppa le variabili d'ambiente mascherate che formano una credenziale AWS per la [ri-firma SigV4](https://code.claude.com/docs/it/sandboxing.md#re-sign-aws-requests) quando la tua credenziale si trova in variabili con nomi non standard. Claude Code collega automaticamente il trio convenzionale `AWS_ACCESS_KEY_ID`, `AWS_SECRET_ACCESS_KEY` e `AWS_SESSION_TOKEN` quando mascheri i loro interi valori, quindi hai bisogno di questa chiave solo per altri nomi. Richiede Claude Code v2.1.224 o successivo.

* **Scope**: [`User or managed`](#scopes)
* **Type**: array di object, ognuno con `accessKeyIdVar`, `secretAccessKeyVar` e opzionalmente `sessionTokenVar`, che nominano voci di `sandbox.credentials.envVars`
* **Default**: non impostato, quindi solo il trio convenzionale è accoppiato

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

```json settings.json theme={null}
{
  "sandbox": {
    "credentials": {
      "awsPairs": [
        {
          "accessKeyIdVar": "MY_KEY_ID",
          "secretAccessKeyVar": "MY_SECRET_KEY",
          "sessionTokenVar": "MY_SESSION_TOKEN"
        }
      ]
    }
  }
}
```

Ogni variabile denominata deve essere una voce `mask` a valore intero in [`sandbox.credentials.envVars`](#sandbox-credentials-envvars), senza `extract` o `decode`, e può occupare un solo slot in tutte le coppie. Si applicano anche queste regole:

* Il proxy ri-firma le richieste sugli host elencati negli `injectHosts` della voce dell'ID della chiave di accesso
* Quando `sessionTokenVar` è impostato, il proxy invia il token reale come `x-amz-security-token` sulle richieste ri-firmate
* Nominare una qualsiasi delle variabili convenzionali in una coppia sostituisce l'accoppiamento automatico

### `sandbox.credentials.sigv4`

Scegli cosa fa il proxy della sandbox con le forme di richiesta AWS che [non può ri-firmare](https://code.claude.com/docs/it/sandboxing.md#re-sign-aws-requests): `streaming` per i caricamenti in streaming aws-chunked, `presigned` per gli URL pre-firmati, e `sigv4a` per le firme asimmetriche SigV4A. Questo si applica solo alle richieste firmate con l'ID della chiave di accesso segnaposto di una coppia mascherata. Richiede Claude Code v2.1.224 o successivo.

* **Scope**: [`User or managed`](#scopes)
* **Type**: object con `streaming`, `presigned` e `sigv4a`, ognuno uno tra:
  * `"deny"`: il proxy fa fallire la richiesta
  * `"passthrough"`: il proxy inoltra la richiesta firmata con il segnaposto mascherato, quindi lo strumento riceve il rifiuto di AWS
* **Default**: non impostato, quindi ogni forma è `"deny"`

Questo inoltra i caricamenti in streaming invece di farli fallire al proxy:

```json settings.json theme={null}
{
  "sandbox": {
    "credentials": {
      "sigv4": {
        "streaming": "passthrough"
      }
    }
  }
}
```

Con `deny`, il proxy fa fallire la richiesta. Con `passthrough`, il proxy inoltra la richiesta con la firma calcolata dal segnaposto mascherato, quindi AWS la rifiuta e lo strumento chiamante riceve la risposta di AWS stessa invece di un errore del proxy.

### `sandbox.network`

Controlla quali host, porte e socket i comandi in sandbox possono raggiungere. La sandbox instrada il traffico in uscita attraverso un proxy che applica questi elenchi; vedi [Network isolation](https://code.claude.com/docs/it/sandboxing.md#network-isolation) per come il proxy decide e quando chiede conferma.

* **Scope**: [`Any file`](#scopes). `strictAllowlist`, `allowManagedDomainsOnly` e `tlsTerminate` vengono letti da meno fonti, come indicano le rispettive voci.
* **Type**: object con le sotto-chiavi di seguito
* **Default**: non impostato, quindi nessun dominio è pre-consentito e la tua modalità di permesso decide [cosa succede a ogni nuovo host](https://code.claude.com/docs/it/sandboxing.md#hosts-outside-your-allowed-domains)

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

```json settings.json theme={null}
{
  "sandbox": {
    "network": {
      "allowedDomains": ["github.com", "*.npmjs.org"],
      "deniedDomains": ["uploads.github.com"],
      "allowLocalBinding": true
    }
  }
}
```

Claude Code esegue il merge delle sotto-chiavi array tra gli ambiti di impostazioni, quindi un progetto può aggiungere domini al tuo elenco utente a meno che non si applichi un [blocco del repository](https://code.claude.com/docs/it/sandboxing.md#repository-settings-under-an-admin-required-sandbox). Le [regole di permesso](https://code.claude.com/docs/it/sandboxing.md#permission-rules) allow e deny `WebFetch(domain:...)` alimentano gli stessi elenchi allow e deny.

### `sandbox.network.allowUnixSockets`

Elenca i percorsi dei socket Unix a cui i comandi in sandbox possono connettersi su macOS. Claude Code ignora questo elenco su Linux e WSL2, dove il filtro seccomp non può ispezionare i percorsi dei socket; lì usa invece [`allowAllUnixSockets`](#sandbox-network-allowallunixsockets).

* **Scope**: [`Any file`](#scopes), con [limiti sulle impostazioni di progetto e locali](https://code.claude.com/docs/it/sandboxing.md#repository-settings-under-an-admin-required-sandbox)
* **Type**: array di stringhe, ognuna un percorso di socket
* **Default**: non impostato, quindi la sandbox macOS blocca ogni socket Unix

```json settings.json theme={null}
{
  "sandbox": {
    "network": {
      "allowUnixSockets": ["~/.ssh/agent-socket"]
    }
  }
}
```

Un percorso di socket può concedere un accesso ampio: consentire `/var/run/docker.sock`, ad esempio, consente a un comando in sandbox di controllare il daemon Docker. Vedi [Security limitations](https://code.claude.com/docs/it/sandboxing.md#security-limitations).

### `sandbox.network.allowAllUnixSockets`

Consenti ai comandi in sandbox di connettersi a ogni socket Unix. Su Linux e WSL2, il [filtro seccomp](https://code.claude.com/docs/it/sandboxing.md#set-up-linux-and-wsl2) della sandbox blocca le chiamate `socket(AF_UNIX, ...)`, quindi questo è l'unico modo per consentire lì i socket Unix. Quando il filtro manca, cosa che `/sandbox` segnala nella sua scheda Dependencies, la sandbox non blocca le chiamate ai socket Unix. Vedi [Set up Linux and WSL2](https://code.claude.com/docs/it/sandboxing.md#set-up-linux-and-wsl2) per sapere da dove proviene il filtro.

* **Scope**: [`Any file`](#scopes), con [limiti sulle impostazioni di progetto e locali](https://code.claude.com/docs/it/sandboxing.md#repository-settings-under-an-admin-required-sandbox)
* **Tipo**: Boolean
  * `true`: i comandi in sandbox possono connettersi a ogni socket Unix. Su Linux e WSL2 possono anche connettersi ai socket VM, la famiglia di indirizzi `AF_VSOCK`
  * `false`: la sandbox blocca le connessioni ai socket Unix: su macOS tranne i percorsi in `allowUnixSockets`, e su Linux e WSL2 tramite il filtro seccomp quando è presente
* **Default**: `false`

```json settings.json theme={null}
{
  "sandbox": {
    "network": {
      "allowAllUnixSockets": true
    }
  }
}
```

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

### `sandbox.network.allowLocalBinding`

Consenti ai comandi in sandbox su macOS di mettersi in ascolto sulle porte di rete, ad esempio per avviare un server di sviluppo, e di connettersi a qualsiasi porta su localhost. Un comando in ascolto su un indirizzo non di loopback accetta connessioni da altre macchine. La chiave non ha effetto su Linux e WSL2, dove ogni comando in sandbox ha la propria interfaccia di loopback. Per raggiungere un server sull'host da Linux o WSL2, vedi [A command fails to reach a server on localhost](https://code.claude.com/docs/it/sandboxing.md#a-command-fails-to-reach-a-server-on-localhost).

* **Scope**: [`Any file`](#scopes), con [limiti sulle impostazioni di progetto e locali](https://code.claude.com/docs/it/sandboxing.md#repository-settings-under-an-admin-required-sandbox)
* **Type**: Boolean
  * `true`: i comandi in sandbox su macOS possono mettersi in ascolto su qualsiasi indirizzo locale e connettersi a qualsiasi porta su localhost
  * `false`: i comandi in sandbox su macOS non possono mettersi in ascolto su una porta né connettersi direttamente ai server su localhost
* **Default**: `false`

```json settings.json theme={null}
{
  "sandbox": {
    "network": {
      "allowLocalBinding": true
    }
  }
}
```

### `sandbox.network.allowMachLookup`

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

* **Scope**: [`Any file`](#scopes), con [limiti sulle impostazioni di progetto e locali](https://code.claude.com/docs/it/sandboxing.md#repository-settings-under-an-admin-required-sandbox)
* **Type**: array di stringhe, ognuna un nome di servizio; un singolo `*` finale corrisponde a un prefisso, e `"*"` da solo corrisponde a ogni servizio
* **Default**: non impostato

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

```json settings.json theme={null}
{
  "sandbox": {
    "network": {
      "allowMachLookup": ["com.apple.coresimulator.*"]
    }
  }
}
```

### `sandbox.network.allowedDomains`

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

* **Scope**: [`Any file`](#scopes), con [limiti sulle impostazioni di progetto e locali](https://code.claude.com/docs/it/sandboxing.md#repository-settings-under-an-admin-required-sandbox). Solo impostazioni gestite quando [`allowManagedDomainsOnly`](#sandbox-network-allowmanageddomainsonly) è impostato.
* **Type**: array di stringhe, ognuna un dominio, pattern con wildcard o letterale IP, con un suffisso opzionale `:port`
* **Default**: non impostato, quindi la tua modalità di permesso decide [cosa succede a ogni nuovo host](https://code.claude.com/docs/it/sandboxing.md#hosts-outside-your-allowed-domains)

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

```json settings.json theme={null}
{
  "sandbox": {
    "network": {
      "allowedDomains": ["github.com", "*.npmjs.org", "api.example.com:443"]
    }
  }
}
```

Scrivi i letterali IPv6 tra parentesi quadre, con una porta opzionale: `"[::1]"` consente ogni porta e `"[::1]:443"` una porta. La forma tra parentesi quadre richiede Claude Code v2.1.229 o successivo. Vedi [IPv6 addresses in domain lists](https://code.claude.com/docs/it/sandboxing.md#ipv6-addresses-in-domain-lists).

### `sandbox.network.deniedDomains`

Blocca i domini per il traffico in uscita dai comandi in sandbox, usando la stessa sintassi di wildcard, porta e IPv6 di [`allowedDomains`](#sandbox-network-alloweddomains). Un dominio negato rimane bloccato anche quando corrisponde anche a una voce `allowedDomains`.

* **Scope**: [`Any file`](#scopes)
* **Type**: array di stringhe, ognuna un dominio, pattern con wildcard o letterale IP, con un suffisso opzionale `:port`
* **Default**: non impostato

```json settings.json theme={null}
{
  "sandbox": {
    "network": {
      "deniedDomains": ["sensitive.cloud.example.com"]
    }
  }
}
```

Claude Code esegue il merge di questo elenco da ogni fonte di impostazioni che la sessione carica anche quando `allowManagedDomainsOnly` è impostato, quindi uno sviluppatore può sempre restringere l'elenco di negazione. Per i letterali IPv6, vedi [IPv6 addresses in domain lists](https://code.claude.com/docs/it/sandboxing.md#ipv6-addresses-in-domain-lists).

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

### `sandbox.network.strictAllowlist`

Nega ai comandi in sandbox l'accesso agli host al di fuori dell'allowlist invece di chiedere l'approvazione. L'allowlist è [`allowedDomains`](#sandbox-network-alloweddomains) più i domini dalle regole allow `WebFetch(domain:...)`, o solo le voci delle impostazioni gestite quando [`allowManagedDomainsOnly`](#sandbox-network-allowmanageddomainsonly) è impostato. [Locks that apply without an admin-required sandbox](https://code.claude.com/docs/it/sandboxing.md#locks-that-apply-without-an-admin-required-sandbox) tratta le voci di un repository. Richiede Claude Code v2.1.219 o successivo.

* **Scope**: [`User or managed`](#scopes). Un repository non può attivarlo o disattivarlo.
* **Type**: Boolean
  * `true`: Claude Code nega ai comandi in sandbox l'accesso agli host al di fuori dell'allowlist
  * `false`: a meno che un altro file di impostazioni attendibile non imposti `true`, Claude Code decide per un host al di fuori dell'allowlist in base alla modalità di permesso invece di negarlo direttamente: in modalità auto controlla l'host rispetto ai [domini consentiti per comando](https://code.claude.com/docs/it/sandboxing.md#per-command-allowed-domains-in-auto-mode) del comando, in modalità `dontAsk` lo nega, in modalità `bypassPermissions` e nelle sessioni interattive da terminale in plan mode in cui il bypass è disponibile lo consente, e altrimenti ti chiede
* **Default**: `false`

```json settings.json theme={null}
{
  "sandbox": {
    "network": {
      "strictAllowlist": true
    }
  }
}
```

Claude Code applica questa impostazione solo ai comandi in sandbox; gli strumenti in-process come `WebFetch` seguono comunque le loro [regole di permesso](https://code.claude.com/docs/it/sandboxing.md#permission-rules). Quando una qualsiasi delle fonti onorate la imposta su `true`, rimane attiva. Vedi [Network isolation](https://code.claude.com/docs/it/sandboxing.md#network-isolation). Richiede Claude Code v2.1.219 o successivo.

### `sandbox.network.allowManagedDomainsOnly`

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

* **Scope**: [`Managed`](#scopes)
* **Type**: Boolean
  * `true`: Claude Code onora solo `allowedDomains` e le regole allow `WebFetch(domain:...)` dalle impostazioni gestite e blocca un dominio non consentito invece di chiedere conferma
  * `false`: i domini da altri file di impostazioni possono essere inclusi tramite merge nell'allowlist
* **Default**: `false`

Questo blocca l'allowlist a GitHub e npm e ignora qualsiasi dominio aggiunto dagli sviluppatori:

```json managed-settings.json theme={null}
{
  "sandbox": {
    "network": {
      "allowManagedDomainsOnly": true,
      "allowedDomains": ["github.com", "*.npmjs.org"]
    }
  }
}
```

Mentre la chiave è `true`, la sandbox è [richiesta dall'amministratore](https://code.claude.com/docs/it/sandboxing.md#repository-settings-under-an-admin-required-sandbox), e solo le impostazioni gestite possono impostare una [porta proxy](#sandbox-network-httpproxyport).

I domini negati vengono comunque inclusi tramite merge da ogni fonte che la sessione carica. Vedi [Keep developers from widening the policy](https://code.claude.com/docs/it/sandboxing.md#keep-developers-from-widening-the-policy).

### `sandbox.network.httpProxyPort`

Punta la sandbox al tuo proxy HTTP invece di quello che Claude Code esegue. Le organizzazioni lo fanno per ispezionare il traffico HTTPS, applicare le proprie regole di filtro o registrare le richieste. Il tuo proxy assume il compito del filtraggio, e Claude Code smette di applicare i suoi elenchi di domini e le sue richieste di conferma di rete al traffico inviato lì. Quando non impostato, Claude Code avvia il proprio proxy per il traffico HTTP.

* **Scope**: [`Any file`](#scopes), a meno che [altre impostazioni della sandbox non limitino quali file possono impostare una porta](https://code.claude.com/docs/it/sandboxing.md#custom-proxy-configuration)
* **Type**: number, una porta TCP locale
* **Default**: non impostato, quindi Claude Code esegue il proprio proxy

```json settings.json theme={null}
{
  "sandbox": {
    "network": {
      "httpProxyPort": 8080
    }
  }
}
```

Imposta anche [`socksProxyPort`](#sandbox-network-socksproxyport) se il tuo proxy deve gestire anche il traffico SOCKS; con solo uno dei due impostato, Claude Code continua a eseguire il proprio proxy per l'altro protocollo. Vedi [Custom proxy configuration](https://code.claude.com/docs/it/sandboxing.md#custom-proxy-configuration).

### `sandbox.network.socksProxyPort`

Punta la sandbox al tuo proxy SOCKS5 invece di quello che Claude Code esegue. Il tuo proxy assume il compito del filtraggio, e Claude Code smette di applicare i suoi elenchi di domini e le sue richieste di conferma di rete al traffico inviato lì. Quando non impostato, Claude Code avvia il proprio proxy per il traffico SOCKS.

* **Scope**: [`Any file`](#scopes), a meno che [altre impostazioni della sandbox non limitino quali file possono impostare una porta](https://code.claude.com/docs/it/sandboxing.md#custom-proxy-configuration)
* **Type**: number, una porta TCP locale
* **Default**: non impostato, quindi Claude Code esegue il proprio proxy

```json settings.json theme={null}
{
  "sandbox": {
    "network": {
      "socksProxyPort": 8081
    }
  }
}
```

Vedi [Custom proxy configuration](https://code.claude.com/docs/it/sandboxing.md#custom-proxy-configuration).

### `sandbox.network.tlsTerminate`

Fai in modo che il proxy della sandbox termini TLS così da poter leggere i contenuti delle richieste HTTPS. Questa funzione è sperimentale, e la [sostituzione delle credenziali](https://code.claude.com/docs/it/sandboxing.md#mask-credentials) `mask` la richiede. Imposta `{}` per generare un'autorità di certificazione effimera per la sessione, o imposta `caCertPath` e `caKeyPath` per usare la tua.

* **Scope**: [`User or managed`](#scopes). Un repository non può attivarlo o fornire un'autorità di certificazione.
* **Type**: object con le stringhe opzionali `caCertPath` e `caKeyPath`, ognuna un percorso di file
* **Default**: non impostato, quindi il proxy non termina né ispeziona TLS

```json settings.json theme={null}
{
  "sandbox": {
    "network": {
      "tlsTerminate": {}
    }
  }
}
```

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

## Memoria e contesto

Controlla cosa Claude Code carica nel contesto, come lo compatta e dove conserva la memoria e i piani. Consulta [Gestire il contesto](https://code.claude.com/docs/it/context-window.md) e [Memoria](https://code.claude.com/docs/it/memory.md).

### `autoCompactEnabled`

Fai in modo che Claude Code [compatti automaticamente la conversazione](https://code.claude.com/docs/it/context-window.md#when-your-context-fills-up) quando il contesto si avvicina al limite. Appare in `/config` come **Auto-compact**, e attivarla o disattivarla lì scrive questa chiave nelle tue impostazioni utente.

* **Ambito**: [`Any file`](#scopes)
* **Tipo**: Boolean
  * `true`: Claude Code compatta automaticamente la conversazione quando il contesto si avvicina al limite
  * `false`: Claude Code non compatta automaticamente
* **Predefinito**: `true`
* **Override per sessione**: [`DISABLE_AUTO_COMPACT`](https://code.claude.com/docs/it/env-vars) disattiva la compattazione automatica per una sessione; qualunque dei due la disattivi, l'altro non può riattivarla

```json settings.json theme={null}
{
  "autoCompactEnabled": false
}
```

Il comando manuale `/compact` continua a funzionare mentre la compattazione automatica è disattivata. Se disattivi la compattazione automatica, si disattiva anche la [compattazione durante l'inattività](#idlecompaction).

### `autoCompactWindow`

Imposta quanto deve riempirsi la finestra di contesto prima che Claude Code [compatti automaticamente](https://code.claude.com/docs/it/context-window.md#when-your-context-fills-up).

* **Ambito**: [`Any file`](#scopes)
* **Tipo**: numero di token, da `100000` a `1000000`. Claude Code limita il valore alla finestra di contesto del tuo modello; la [panoramica dei modelli](https://platform.claude.com/docs/en/about-claude/models/overview) elenca la finestra di ciascun modello
* **Predefinito**: non impostato, quindi Claude Code sceglie una finestra calibrata per il tuo modello
* **Override per sessione**: [`--autocompact`](https://code.claude.com/docs/it/cli-reference#cli-flags) ha la precedenza su questa chiave per una sessione, e [`CLAUDE_CODE_AUTO_COMPACT_WINDOW`](https://code.claude.com/docs/it/env-vars) ha la precedenza su entrambi, a meno che Claude Code [ignori il valore della variabile](https://code.claude.com/docs/it/model-config.md#claude_code_auto_compact_window-values)

```json settings.json theme={null}
{
  "autoCompactWindow": 500000
}
```

Il comando [`/autocompact`](https://code.claude.com/docs/it/commands#all-commands) salva una finestra per il modello corrente in [`modelSettings`](#modelsettings), che per quel modello ha la precedenza su questa chiave nello stesso file. [Impostare la finestra di compattazione automatica](https://code.claude.com/docs/it/model-config.md#set-the-auto-compact-window) spiega come interagiscono comando, flag, variabile e impostazione.

### `autoMemoryDirectory`

Archivia la [memoria automatica](https://code.claude.com/docs/it/memory.md#storage-location) in una directory a tua scelta invece di quella predefinita per progetto.

* **Ambito**: [`Any file`](#scopes)
* **Tipo**: stringa, un percorso di directory assoluto o con prefisso `~/`
* **Predefinito**: non impostato, quindi Claude Code usa `~/.claude/projects/<project>/memory/`

```json settings.json theme={null}
{
  "autoMemoryDirectory": "~/my-memory-dir"
}
```

Dalle impostazioni di progetto o locali, Claude Code rispetta questa chiave secondo la stessa [regola di fiducia del workspace degli hook](https://code.claude.com/docs/it/permissions.md#what-runs-before-you-trust-a-folder), poiché un repository clonato può fornire quei file.

### `autoMemoryEnabled`

Attiva o disattiva la [memoria automatica](https://code.claude.com/docs/it/memory.md#enable-or-disable-auto-memory). Quando è `false`, Claude non legge né scrive nella directory della memoria automatica. Puoi anche attivarla o disattivarla con `/memory` durante una sessione, che scrive questa chiave nelle tue impostazioni utente.

* **Ambito**: [`Any file`](#scopes)
* **Tipo**: Boolean
  * `true`: equivale a non impostata; la memoria automatica resta attiva a meno che qualcosa con precedenza superiore a questa chiave la disattivi per la sessione, come `--bare`, la modalità sicura o `CLAUDE_CODE_DISABLE_AUTO_MEMORY`
  * `false`: Claude non legge né scrive nella directory della memoria automatica
* **Predefinito**: `true`
* **Override per sessione**: [`CLAUDE_CODE_DISABLE_AUTO_MEMORY`](https://code.claude.com/docs/it/env-vars) ha la precedenza su questa chiave per una sessione, in entrambe le direzioni

```json settings.json theme={null}
{
  "autoMemoryEnabled": false
}
```

### `bashOutputMaxChars`

Imposta quanti caratteri dell'[output di un comando Bash o PowerShell riuscito Claude riceve inline](https://code.claude.com/docs/it/tools-reference.md#output-limits). Quando l'output supera il limite, Claude Code lo salva in un file e Claude riceve una breve anteprima più il percorso del file. Alza il limite quando l'output dei comandi, come una build dettagliata o il log completo di una suite di test, supera abitualmente il valore predefinito e vuoi che Claude lo legga senza aprire il file. Richiede Claude Code v2.1.261 o successiva.

* **Ambito**: [`Any file`](#scopes)
* **Tipo**: numero di caratteri, un intero positivo. Claude Code vincola il valore all'intervallo da `4000` a `128000`
* **Predefinito**: non impostato, quindi Claude riceve fino a 30.000 caratteri inline

```json settings.json theme={null}
{
  "bashOutputMaxChars": 100000
}
```

Quando imposti questa chiave, Claude Code ignora la variabile d'ambiente [`BASH_MAX_OUTPUT_LENGTH`](https://code.claude.com/docs/it/env-vars).

### `claudeMd`

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

* **Ambito**: [`Managed`](#scopes)
* **Tipo**: stringa, il testo di un file CLAUDE.md; scrivilo come scriveresti il file, markdown incluso, con le interruzioni di riga come `\n`
* **Predefinito**: non impostato

Questo esempio distribuisce due regole come un breve elenco markdown:

```json managed-settings.json theme={null}
{
  "claudeMd": "# Engineering rules\n\n- Always run make lint before committing.\n- Never push directly to main."
}
```

Consulta [Distribuire un CLAUDE.md per tutta l'organizzazione](https://code.claude.com/docs/it/memory.md#deploy-organization-wide-claude-md).

### `claudeMdExcludes`

Salta file `CLAUDE.md` specifici quando Claude Code carica la [memoria](https://code.claude.com/docs/it/memory.md#exclude-specific-claude-md-files). In un monorepo di grandi dimensioni, usala per saltare i file CLAUDE.md di altri team che non sono rilevanti per il tuo lavoro; [Escludere i file CLAUDE.md irrilevanti](https://code.claude.com/docs/it/large-codebases.md#exclude-irrelevant-claude-md-files) nella guida sui codebase di grandi dimensioni illustra questo caso. I pattern vengono confrontati con i percorsi assoluti dei file.

* **Ambito**: [`Any file`](#scopes)
* **Tipo**: array di stringhe, ciascuna un pattern glob o un percorso assoluto
* **Predefinito**: non impostato, quindi Claude Code carica ogni CLAUDE.md che trova

```json settings.json theme={null}
{
  "claudeMdExcludes": ["**/vendor/**/CLAUDE.md"]
}
```

Le esclusioni si applicano solo ai file di memoria utente, di progetto e locali; i file CLAUDE.md dei criteri gestiti non possono essere esclusi.

### `env`

Imposta variabili d'ambiente per ogni sessione e per i sottoprocessi che Claude Code avvia da essa. La maggior parte delle variabili nel [riferimento delle variabili d'ambiente](https://code.claude.com/docs/it/env-vars.md) può essere inserita qui, ed è così che ne applichi una a ogni sessione o la distribuisci al tuo team. Le impostazioni di progetto e locali non possono impostarne [alcune](#variables-claude-code-ignores-in-env).

* **Ambito**: [`Any file`](#scopes)
* **Tipo**: oggetto che associa nomi di variabili a valori stringa
* **Predefinito**: non impostato

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

```json settings.json theme={null}
{
  "env": {
    "DISABLE_AUTO_COMPACT": "1",
    "ANTHROPIC_BASE_URL": "https://proxy.example.com"
  }
}
```

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

* Un valore qui sovrascrive la stessa variabile esportata nella tua shell, e quando più di un file di impostazioni imposta una variabile, si applica quello con [precedenza più alta](https://code.claude.com/docs/it/settings.md#settings-precedence). [Variabili che Claude Code ignora in `env`](#variables-claude-code-ignores-in-env) elenca le eccezioni per le impostazioni di progetto e locali.
* Quando è l'app Claude Desktop o un runner di [ambiente self-hosted](https://code.claude.com/docs/it/self-hosted-environments) ad avviare la sessione, ha invece la precedenza l'ambiente di avvio che costruisce: Claude Code ignora un valore `env` proveniente da qualsiasi file di impostazioni per una variabile che l'ambiente di avvio imposta già. Il [log di debug](https://code.claude.com/docs/it/debug-your-config.md) indica ogni variabile ignorata.
* Per annullare un'esportazione della shell, imposta la variabile su `""`. Claude Code tratta un valore vuoto come non impostato per la selezione del provider, e i sottoprocessi ereditano il valore vuoto.
* `NO_COLOR` e `FORCE_COLOR` impostate qui raggiungono solo i sottoprocessi. Per cambiare i colori dell'interfaccia di Claude Code stesso, impostale nella tua shell prima di avviare `claude`.
* I valori qui sono testo in chiaro nel file di impostazioni e raggiungono ogni sottoprocesso avviato da Claude Code. Per un bearer token OTLP che ruota, usa [`otelHeadersHelper`](#otelheadershelper); per le credenziali API, usa [`apiKeyHelper`](#apikeyhelper).

#### Quando Claude Code applica i valori di `env`

* Dalle impostazioni utente, da `--settings` e dalle impostazioni gestite: all'avvio, e di nuovo nella sessione in corso quando una modifica salvata altera l'`env` unificato.
* Dalle impostazioni di progetto e locali: dopo che hai dato fiducia al workspace, oppure all'avvio in modalità `-p`, che non mostra mai la finestra di dialogo di fiducia, e di nuovo quando una modifica salvata altera l'`env` unificato.
* Variabili che Claude Code classifica come sicure, come selezione del modello, timeout e limiti, e attivazione di funzionalità: all'avvio da ogni file di impostazioni, a parte le [variabili che le impostazioni di progetto e locali non possono impostare](#variables-claude-code-ignores-in-env).
* Dopo che hai [spostato la sessione con `/cd`](https://code.claude.com/docs/it/permissions#move-the-session-to-another-directory) nella v2.1.246 o successiva: i valori `env` di progetto e locali della nuova directory, in aggiunta a quelli della directory precedente.

#### Variabili che Claude Code ignora in `env`

* Le impostazioni di progetto e locali non possono impostare variabili che un repository estratto non dovrebbe controllare; impostale invece nella tua shell, nelle impostazioni utente o nelle impostazioni gestite. Claude Code scarta ciascuna di esse, a parte alcuni valori che disattivano la telemetria, e registra un avviso che puoi vedere con `claude --debug`. Tra queste:

  * Variabili che scelgono dove Claude Code archivia o scrive i propri file: `CLAUDE_CONFIG_DIR`, `CLAUDE_CODE_TMPDIR` e le variabili di directory del sistema operativo come `HOME`, `TMPDIR`, `TMP`, `TEMP` e la famiglia `XDG_*`.
  * Variabili Windows che scelgono i programmi e la configurazione a livello di macchina per i processi avviati da Claude Code, come `SystemRoot`, `ComSpec`, `ProgramData`, `LOCALAPPDATA`, `PATHEXT`, `PSModulePath` e la famiglia `ProgramFiles`.
  * Variabili che esportano il contenuto della sessione: [`OTEL_LOG_RAW_API_BODIES`](https://code.claude.com/docs/it/env-vars#variables) e la coppia di tracciamento beta dettagliato `ENABLE_BETA_TRACING_DETAILED` e `BETA_TRACING_ENDPOINT`.
  * Le variabili dell'[exporter OpenTelemetry](https://code.claude.com/docs/it/monitoring-usage.md) che attivano la telemetria, scelgono dove va o scelgono quale contenuto acquisisce:

    * `CLAUDE_CODE_ENABLE_TELEMETRY`, più la coppia beta della telemetria avanzata `CLAUDE_CODE_ENHANCED_TELEMETRY_BETA` e `ENABLE_ENHANCED_TELEMETRY_BETA`
    * I selettori di exporter `OTEL_LOGS_EXPORTER`, `OTEL_METRICS_EXPORTER` e `OTEL_TRACES_EXPORTER`
    * Le variabili di contenuto `OTEL_LOG_USER_PROMPTS`, `OTEL_LOG_ASSISTANT_RESPONSES`, `OTEL_LOG_TOOL_CONTENT` e `OTEL_LOG_TOOL_DETAILS`
    * Le variabili `OTEL_EXPORTER_OTLP_*` i cui nomi terminano con `_ENDPOINT`, `_HEADERS`, `_PROTOCOL`, `_CERTIFICATE`, `_CLIENT_KEY` o `_INSECURE`, nelle forme generiche e per segnale, come `OTEL_EXPORTER_OTLP_ENDPOINT` e `OTEL_EXPORTER_OTLP_METRICS_HEADERS`
    * `OTEL_EXPORTER_PROMETHEUS_HOST` e `OTEL_EXPORTER_PROMETHEUS_PORT`

    Solo questi valori si applicano ancora dalle impostazioni di progetto e locali, perché disattivano qualcosa: `none` per i tre selettori di exporter, e un valore di disattivazione come `0` per `OTEL_LOG_USER_PROMPTS`, `OTEL_LOG_TOOL_CONTENT` e `OTEL_LOG_TOOL_DETAILS`. Un valore del genere sovrascrive la stessa variabile nelle tue impostazioni utente, ma non una impostata dall'ambiente da cui avvii Claude Code, da un file `--settings` o dalle impostazioni gestite.

    Quando un file di impostazioni di progetto o locale imposta una variabile di questo gruppo, una sessione interattiva locale mostra un avviso all'avvio. Esegui `/status` o `claude doctor` per vedere quali ha ignorato Claude Code e quali hanno disattivato la telemetria; entrambi elencano i nomi, mai i valori. Un'esecuzione non interattiva con `-p` o una sessione dell'Agent SDK non mostra alcun avviso, quindi verifica che il tuo collector riceva ancora dati dopo l'aggiornamento. Se non è così, imposta le variabili nelle tue impostazioni utente, nelle impostazioni gestite, nell'ambiente del job o in un file che passi con `--settings`.

    L'esclusione di questo gruppo nelle impostazioni di progetto e locali richiede Claude Code v2.1.282 o successiva.
  * Variabili che cambiano il modo in cui Claude Code si avvia o si sincronizza, come `CLAUDE_CODE_PROCESS_WRAPPER`, `CLAUDE_CODE_SYNC_SKILLS`, `CLAUDE_CODE_SYNC_PLUGINS`, `CLAUDE_CODE_PLUGIN_CACHE_DIR` e `CLAUDE_CODE_PLUGIN_SEED_DIR`.
  * La variabile della [modalità screen reader](https://code.claude.com/docs/it/accessibility.md) `CLAUDE_AX_SCREEN_READER` e le altre variabili i cui nomi iniziano con `CLAUDE_AX_`, come [`CLAUDE_AX_STARTUP_QUIET_MS`](https://code.claude.com/docs/it/env-vars#variables).
  * [`CLAUDE_CODE_USER_DIALOG_TIMEOUT_MS`](https://code.claude.com/docs/it/env-vars#variables), che imposta il timer di una finestra di dialogo senza risposta.
  * [`CLAUDE_CODE_DISABLE_ATTACHMENTS`](https://code.claude.com/docs/it/env-vars#variables), che disattiva l'elaborazione degli allegati.
  * [`CLAUDE_CODE_DISABLE_FILE_MENTIONS`](https://code.claude.com/docs/it/env-vars#variables), che impedisce a Claude Code di espandere le menzioni `@` di file e directory.

  Prima della v2.1.251, le impostazioni di progetto e locali potevano impostare anche le variabili di questo elenco che scelgono dove Claude Code scrive i propri file o che esportano il contenuto della sessione, tranne `HOME` e `XDG_CONFIG_HOME`. Prima della v2.1.290, potevano impostare anche le variabili dei timer delle finestre di dialogo e `CLAUDE_CODE_DISABLE_ATTACHMENTS`.
* Le variabili di identità di cui sono proprietari gli ambienti di hosting di Claude Code, come `CLAUDE_CODE_REMOTE` e `CLAUDE_CODE_ACCOUNT_UUID`, vengono ignorate in ogni file.
* [`CLAUDE_CODE_MESSAGING_SOCKET` e `CLAUDE_CODE_MESSAGING_TOKEN`](https://code.claude.com/docs/it/env-vars#variables), che Claude Code esporta da sé, vengono ignorate in ogni file. L'esclusione della variabile del socket richiede Claude Code v2.1.224 o successiva, e l'esclusione del token richiede la v2.1.228 o successiva.
* [`CLAUDE_CODE_PROJECT_DIR_NAME`](https://code.claude.com/docs/it/sessions#name-the-project-directory-yourself), che Claude Code legge solo dall'ambiente di avvio, viene ignorata in ogni file; richiede la v2.1.234 o successiva.
* [`CLAUDE_CODE_RESTRICTED`](https://code.claude.com/docs/it/env-vars#variables), che Claude Code legge solo dall'ambiente di avvio, viene ignorata in ogni file.
* [`CLAUDE_CODE_DISABLE_POWERSHELL_CMD_RM_DENY`](https://code.claude.com/docs/it/env-vars#variables), che Claude Code legge solo dall'ambiente di avvio, viene ignorata in ogni file. La variabile richiede Claude Code v2.1.283 o successiva.
* [`CLAUDE_CODE_DISABLE_DANGEROUS_RM_TIMEOUT`, `CLAUDE_CODE_DISABLE_SUBSTITUTION_RM_PROMPT`, `CLAUDE_CODE_DISABLE_INLINE_SHELL_RM_PROMPT` e `CLAUDE_CODE_DISABLE_MOUNTED_DRIVE_RM_PROMPT`](https://code.claude.com/docs/it/env-vars#variables), che Claude Code legge solo dall'ambiente di avvio, vengono ignorate in ogni file.
* [`CLAUDE_CODE_WARN_DISK_FREE_GIB` e `CLAUDE_CODE_WARN_MEMORY_FREE_GIB`](https://code.claude.com/docs/it/env-vars#variables), che Claude Code legge solo dall'ambiente di avvio, vengono ignorate in ogni file. Le variabili richiedono Claude Code v2.1.304 o successiva.

### `fileCheckpointingEnabled`

Fai in modo che Claude Code crei uno snapshot dei file prima di ogni modifica così che [`/rewind`](https://code.claude.com/docs/it/checkpointing) possa ripristinarli. Appare in `/config` come **Rewind code (checkpoints)**, e attivarla o disattivarla lì scrive questa chiave nelle tue impostazioni utente.

* **Ambito**: [`Any file`](#scopes)
* **Tipo**: Boolean
  * `true`: Claude Code crea uno snapshot dei file prima di ogni modifica così che `/rewind` possa ripristinarli
  * `false`: Claude Code non crea snapshot dei file, quindi `/rewind` non può ripristinarli
* **Predefinito**: `true`
* **Override per sessione**: [`CLAUDE_CODE_DISABLE_FILE_CHECKPOINTING`](https://code.claude.com/docs/it/env-vars) disattiva il checkpointing per una sessione; qualunque dei due lo disattivi, l'altro non può riattivarlo

```json settings.json theme={null}
{
  "fileCheckpointingEnabled": false
}
```

In un'esecuzione `-p` o in una sessione dell'Agent SDK, Claude Code ignora questa chiave. L'SDK attiva il checkpointing con la sua opzione `enableFileCheckpointing`, e un'esecuzione `-p` semplice richiede `CLAUDE_CODE_ENABLE_SDK_FILE_CHECKPOINTING=true`. Consulta [Checkpointing dei file nell'Agent SDK](https://code.claude.com/docs/it/agent-sdk/file-checkpointing.md).

### `idleCompaction`

La compattazione durante l'inattività [compatta](https://code.claude.com/docs/it/context-window.md#what-survives-compaction) una conversazione lunga da cui ti sei allontanato. Il tuo messaggio successivo invia quindi un riepilogo invece dell'intera conversazione. Una volta compattata, la conversazione mostra un avviso:

* **Terminale**: una riga che inizia con `Compacted while idle, before the prompt cache expired`
* **[Pannello chat di VS Code](#idle-compaction-in-vs-code-and-the-desktop-app)**: un avviso che include `a summary written while you were away`
* **[App desktop](#idle-compaction-in-vs-code-and-the-desktop-app)**: lo stesso avviso, all'interno di una riga la cui etichetta include `Claude Code notice`. Se non vedi quella riga o il suo testo, passa alla [modalità di visualizzazione Verbose](https://code.claude.com/docs/it/desktop.md#switch-view-modes).

La compattazione durante l'inattività è attiva per impostazione predefinita per le conversazioni che soddisfano tutte queste condizioni:

* **Sessione**: sei in una sessione interattiva del terminale, oppure nel pannello chat dell'estensione VS Code o nella scheda Code dell'app desktop con un [account selezionato da Anthropic](#idle-compaction-in-vs-code-and-the-desktop-app)
* **Compattazione automatica**: [`autoCompactEnabled`](#autocompactenabled) è attiva
* **Cache del prompt**: la conversazione usa il [TTL di un'ora della cache del prompt](https://code.claude.com/docs/it/prompt-caching.md#which-ttl-each-request-gets)
* **Feature flag**: Claude Code può [recuperare i feature flag da Anthropic](https://code.claude.com/docs/it/env-vars.md#features-that-need-feature-flag-fetching)
* **Dimensione**: il contesto della conversazione ha raggiunto la soglia di token, che puoi [modificare](#change-the-idle-compaction-threshold) rispetto al valore predefinito di 200.000
* **Tempo di inattività**: sono trascorsi circa 54 minuti dall'ultima richiesta, e in quel momento il tuo computer è attivo

Per disattivare la compattazione durante l'inattività, imposta questa chiave su `false`.

* **Ambito**: [`Any file`](#scopes)
* **Tipo**: Boolean
  * `true`: Claude Code compatta le conversazioni inattive che soddisfano le condizioni
  * `false`: Claude Code non compatta mentre la tua sessione è inattiva
* **Predefinito**: `true`
* **Override per sessione**: [`DISABLE_AUTO_COMPACT`](https://code.claude.com/docs/it/env-vars) disattiva la compattazione durante l'inattività insieme alla compattazione automatica

```json settings.json theme={null}
{
  "idleCompaction": false
}
```

Per disattivare o attivare la compattazione durante l'inattività dall'interno di una sessione del terminale, esegui `/config` e modifica la riga **Idle compaction**. La tua scelta viene salvata nelle tue impostazioni utente e si applica subito. La riga richiede Claude Code v2.1.302 o successiva. Se esegui una di queste versioni e `/config` non mostra la riga, verifica queste cause:

* **Un'altra fonte di impostazioni imposta la chiave**: un valore nelle impostazioni gestite, nel flag `--settings` o in un file di impostazioni di progetto o locale sovrascrive le tue impostazioni utente. Modifica invece la chiave in quella fonte
* **I feature flag non sono disponibili**: dove Claude Code non può [recuperare i feature flag da Anthropic](https://code.claude.com/docs/it/env-vars.md#features-that-need-feature-flag-fetching), la compattazione durante l'inattività non viene eseguita, quindi non c'è nulla da disattivare

La chiave richiede Claude Code v2.1.290 o successiva. In una versione precedente, che ignora questa chiave, disattiva [`autoCompactEnabled`](#autocompactenabled) per fermare la compattazione durante l'inattività.

#### Modificare la soglia di compattazione durante l'inattività

Imposta [`CLAUDE_CODE_IDLE_COMPACT_MIN_TOKENS`](https://code.claude.com/docs/it/env-vars) sul numero di token che il contesto di una conversazione deve raggiungere prima che le si applichi la compattazione durante l'inattività. Usa un numero intero positivo. I valori inferiori a `100000` vengono portati a `100000`, la soglia minima.

Con il valore predefinito, una conversazione su una finestra di contesto da 200K si compatta automaticamente prima di raggiungere 200.000 token. Questo esempio abbassa la soglia a 150.000 in modo che quelle conversazioni rientrino:

```json settings.json theme={null}
{
  "env": {
    "CLAUDE_CODE_IDLE_COMPACT_MIN_TOKENS": "150000"
  }
}
```

#### Compattazione durante l'inattività in VS Code e nell'app desktop

Un avviso come questo significa che Claude Code [ha sostituito la tua conversazione precedente con un riepilogo](https://code.claude.com/docs/it/context-window.md#what-survives-compaction) a partire dal quale Claude ora lavora:

```text theme={null}
Compacted using a summary written while you were away · turn off with "idleCompaction": false in settings.json
```

Non devi fare nulla. Per disattivare la compattazione durante l'inattività, imposta `idleCompaction` su `false` in `~/.claude/settings.json` o in un altro [file di impostazioni](https://code.claude.com/docs/it/settings.md#settings-files-and-who-they-affect).

Nel pannello chat dell'estensione VS Code e nella scheda Code dell'app desktop, la compattazione durante l'inattività viene eseguita per gli account selezionati da Anthropic. Claude Code scrive il riepilogo mentre sei via, poi compatta usandolo solo se il tuo messaggio successivo arriva un'ora o più dopo l'ultima richiesta.

### `plansDirectory`

Scegli dove Claude Code archivia i file di piano che scrive in [plan mode](https://code.claude.com/docs/it/permission-modes.md#analyze-before-you-edit-with-plan-mode). Claude Code risolve il percorso relativamente alla radice del progetto.

* **Ambito**: [`Any file`](#scopes)
* **Tipo**: stringa, un percorso relativo alla radice del progetto
* **Predefinito**: non impostato, quindi Claude Code usa `~/.claude/plans`

```json settings.json theme={null}
{
  "plansDirectory": "./plans"
}
```

Claude Code archivia i piani in `~/.claude/plans` invece che nella directory che hai impostato in casi come questi:

* **Al di fuori della radice del progetto**: il percorso si risolve al di fuori della radice del progetto, come fa `"../plans"`.
* **Barra rovesciata su macOS, Linux e WSL**: il percorso risolto contiene una barra rovesciata, come fa `"docs\\plans"` in stile Windows. Scrivi `"docs/plans"`, che funziona anche su Windows.

### `skillListingBudgetFraction`

A ogni turno, Claude vede un [elenco delle tue skill](https://code.claude.com/docs/it/skills.md#skill-descriptions-are-cut-short) con le relative descrizioni, e Claude Code limita tale elenco a una quota della finestra di contesto. Quando l'elenco supera il limite, Claude Code mantiene il nome di ogni skill ma elimina le descrizioni delle skill meno usate, così Claude può ancora invocare quelle skill ma è meno probabile che ne scelga una di sua iniziativa. Alza questa chiave per mantenere visibili più descrizioni a costo di più contesto per turno.

* **Ambito**: [`Any file`](#scopes)
* **Tipo**: numero, una frazione maggiore di `0` e al massimo `1`
* **Predefinito**: `0.01`, che riserva l'1% della finestra di contesto

```json settings.json theme={null}
{
  "skillListingBudgetFraction": 0.02
}
```

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

### `skillListingMaxDescChars`

A ogni turno, Claude vede un [elenco delle tue skill](https://code.claude.com/docs/it/skills.md#skill-descriptions-are-cut-short) che mostra il testo `description` e `when_to_use` di ciascuna skill. Questa chiave limita quanti caratteri di quel testo Claude Code mostra per skill; il testo più lungo viene troncato al limite.

* **Ambito**: [`Any file`](#scopes)
* **Tipo**: numero di caratteri, un intero positivo
* **Predefinito**: `1536`

```json settings.json theme={null}
{
  "skillListingMaxDescChars": 2048
}
```

Alzala per mantenere intatte le descrizioni lunghe a costo di più contesto per turno; abbassala per far rientrare più skill in [`skillListingBudgetFraction`](#skilllistingbudgetfraction).

### `taskOutputMaxChars`

> [!WARNING]
>
> Rimossa nella v2.1.277, insieme allo strumento `TaskOutput` di cui determinava la dimensione. Impostarla non ha alcun effetto nelle versioni attuali. Claude legge invece il [file di output](https://code.claude.com/docs/it/tools-reference.md#background-commands) di un'attività in background con `Read`.

Fino alla v2.1.276, impostavi questa chiave sul numero di caratteri dell'output di un'[attività in background](https://code.claude.com/docs/it/tools-reference.md#background-commands) che Claude riceveva inline quando leggeva l'attività con lo strumento `TaskOutput`.

## Interfaccia e terminale

Cambia come Claude Code appare e si comporta nel tuo terminale: tema, modalità editor, riga di stato, spinner, notifiche all'interno della sessione e accessibilità. Vedi [Configurazione del terminale](https://code.claude.com/docs/it/terminal-config.md).

### `askUserQuestionTimeout`

Consenti a una finestra di dialogo [`AskUserQuestion`](https://code.claude.com/docs/it/tools-reference) senza risposta di continuare automaticamente dopo un periodo di inattività, inviando qualsiasi opzione tu avessi già selezionato. Impostalo quando ti allontani e vuoi che Claude continui senza di te. Con l'impostazione predefinita, le domande attendono fino a quando non rispondi. Per sapere quando il timer si mette in pausa o non parte mai, vedi [Timeout di continuazione automatica delle domande](https://code.claude.com/docs/it/tools-reference.md#question-auto-continue-timeout).

* **Scope**: [`User or managed`](#scopes)
* **Type**: string, uno di `"60s"`, `"5m"`, `"10m"`, o `"never"`
* **Default**: `"never"`

```json settings.json theme={null}
{
  "askUserQuestionTimeout": "5m"
}
```

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

### `autoContinueAtUsageLimit`

Dopo che un limite di utilizzo di claude.ai interrompe la tua sessione, attendi nella sessione aperta e continua l'attività automaticamente dopo il ripristino. Vedi [Disattiva continuazione automatica](https://code.claude.com/docs/it/interactive-mode.md#turn-automatic-continue-off). Richiede Claude Code v2.1.234 o successivo.

* **Scope**: [`User or managed`](#scopes). Leggi dalle impostazioni utente, `--settings` e impostazioni gestite solo. Quando nessuno di questi imposta la chiave, un file di impostazioni di progetto o locale che la imposta disattiva la funzione piuttosto che essere ignorato.
* **Type**: Boolean
  * `true`: dopo che un limite di utilizzo di claude.ai interrompe la tua sessione, Claude Code attende nella sessione aperta e continua l'attività automaticamente dopo il ripristino
  * `false`: Claude Code non avvia l'attesa da solo. Puoi comunque [avviare un'attesa tu stesso](https://code.claude.com/docs/it/interactive-mode.md#start-a-wait-yourself) dal menu delle opzioni del limite di utilizzo
* **Default**: `true`

```json settings.json theme={null}
{
  "autoContinueAtUsageLimit": false
}
```

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

### `autoScrollEnabled`

Segui il nuovo output fino in fondo alla conversazione nel [rendering a schermo intero](https://code.claude.com/docs/it/fullscreen.md). Disattivalo per rimanere dove hai fatto scorrere mentre Claude continua a lavorare; i prompt di autorizzazione scorrono comunque in vista.

* **Scope**: [`Any file`](#scopes)
* **Type**: Boolean
  * `true`: la conversazione segue il nuovo output fino in fondo
  * `false`: rimani dove hai fatto scorrere mentre Claude continua a lavorare; i prompt di autorizzazione appaiono comunque sotto la trascrizione
* **Default**: `true`

```json settings.json theme={null}
{
  "autoScrollEnabled": false
}
```

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

### `axScreenReader`

Renderizza output compatibile con i lettori di schermo: testo piatto senza bordi decorativi o animazioni. La modalità lettore di schermo utilizza il renderer classico, quindi l'impostazione `tui` non ha effetto mentre è attiva; le [sessioni in background](https://code.claude.com/docs/it/agent-view.md) allegate eseguono comunque il rendering a schermo intero.

* **Scope**: [`User or managed`](#scopes). Puoi anche impostare la chiave in un file che passi con `--settings`. Claude Code ignora la chiave nelle impostazioni di progetto e locali, quindi né un repository né il tuo `.claude/settings.local.json` possono attivare o disattivare la modalità lettore di schermo.
* **Type**: Boolean
  * `true`: Claude Code renderizza testo piatto senza bordi decorativi o animazioni, utilizzando il renderer classico
  * `false`: Claude Code renderizza normalmente
* **Default**: unset, quindi la modalità lettore di schermo è disattivata
* **Per-session overrides**: [`--ax-screen-reader`](https://code.claude.com/docs/it/cli-reference#cli-flags) ha la precedenza su [`CLAUDE_AX_SCREEN_READER`](https://code.claude.com/docs/it/env-vars), e entrambi hanno la precedenza su questa chiave per una sessione

```json settings.json theme={null}
{
  "axScreenReader": true
}
```

### `bashEditDiffEnabled`

Scegli se Claude Code registra quali file sono cambiati in un repository Git mentre un comando Bash è in esecuzione. Quando li registra, vedi il loro diff nel terminale dopo il comando, e i tuoi [hook Bash PostToolUse](https://code.claude.com/docs/it/hooks.md#bash) ricevono l'elenco dei file modificati.

Un file elencato non è sempre uno che il comando ha modificato. Una modifica che un altro programma o un'altra chiamata Bash ha fatto mentre il comando era in esecuzione può apparire lì anche.

Imposta la chiave su `true` per registrarli in ogni modalità di autorizzazione. Richiede Claude Code v2.1.269 o successivo.

* **Scope**: [`User or managed`](#scopes). Un `true` conta solo dalle tue impostazioni utente, JSON passato con `--settings`, o [impostazioni gestite](https://code.claude.com/docs/it/managed-settings.md), quindi un `true` nel `.claude/settings.json` o `.claude/settings.local.json` di un repository non può attivare la registrazione. Un `false` in uno qualsiasi dei file del repository disattiva comunque la registrazione a meno che un file con [precedenza più alta](https://code.claude.com/docs/it/settings.md#settings-precedence) non imposti `true`.
* **Type**: Boolean
* **Default**: unset, quindi Claude Code registra le modifiche in modalità auto e modalità `bypassPermissions` quando indirizza Claude a modificare i file tramite Bash
* **Per-session overrides**: [`CLAUDE_CODE_BASH_EDIT_DIFF`](https://code.claude.com/docs/it/env-vars) ha la precedenza su questa chiave per una sessione

```json settings.json theme={null}
{
  "bashEditDiffEnabled": true
}
```

### `companyAnnouncements`

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

* **Scope**: [`Any file`](#scopes)
* **Type**: array di stringhe
* **Default**: unset, quindi nessun annuncio viene visualizzato

```json settings.json theme={null}
{
  "companyAnnouncements": [
    "Welcome to Acme Corp! Review our code guidelines at docs.example.com"
  ]
}
```

### `defaultShell`

Scegli se Bash o PowerShell esegue i comandi shell che digiti con il prefisso [`!`](https://code.claude.com/docs/it/interactive-mode#shell-mode-with-prefix) nella casella di input, quelli che Claude Code esegue direttamente e aggiunge alla sessione.

`"powershell"` funziona solo mentre lo [strumento PowerShell](https://code.claude.com/docs/it/tools-reference.md#powershell-tool) è attivo. Lo strumento è attivo per impostazione predefinita su Windows senza Git Bash, e su Windows con Git Bash per account claude.ai e Console. Nelle sessioni Amazon Bedrock, Google Cloud's Agent Platform e Microsoft Foundry, e su macOS, Linux e WSL, imposta `CLAUDE_CODE_USE_POWERSHELL_TOOL=1` per attivare lo strumento. Imposta quella variabile su `0` per disattivare lo strumento.

* **Scope**: [`Any file`](#scopes)
* **Type**: string, uno di:
  * `"bash"`: Claude Code esegue i tuoi comandi `!` in Bash
  * `"powershell"`: Claude Code esegue i tuoi comandi `!` in PowerShell
* **Default**: `"bash"`, o `"powershell"` su Windows quando Bash non è disponibile

```json settings.json theme={null}
{
  "defaultShell": "powershell"
}
```

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

### `dialogExpiry`

Imposta la scadenza per le finestre di dialogo che Claude Code [inoltra a un client remoto](https://code.claude.com/docs/it/remote-control.md#limitations), come un host Remote Control o SDK, e per la finestra di dialogo di approvazione per un [messaggio tra sessioni mantenuto](https://code.claude.com/docs/it/cross-session-messaging.md#control-inbound-messages). Su Claude Code v2.1.236 o successivo, la stessa scadenza limita il prompt di consenso per i crediti di utilizzo [Fable](https://code.claude.com/docs/it/model-config.md#fable-and-usage-credits) a metà sessione in una sessione che potrebbe non avere nessuno al terminale. Quando nessuna risposta arriva prima della scadenza, Claude Code annulla la finestra di dialogo e continua con il suo default senza azione. Richiede Claude Code v2.1.224 o successivo.

* **Scope**: [`User or managed`](#scopes)
* **Type**: string, uno di `"60s"`, `"5m"`, `"10m"`, o `"never"`, che disabilita la scadenza
* **Default**: `"5m"`
* **Per-session overrides**: [`CLAUDE_CODE_USER_DIALOG_TIMEOUT_MS`](https://code.claude.com/docs/it/env-vars) ha la precedenza su questa chiave per una sessione

```json settings.json theme={null}
{
  "dialogExpiry": "10m"
}
```

I prompt di autorizzazione e le domande [`AskUserQuestion`](https://code.claude.com/docs/it/tools-reference#askuserquestion-tool-behavior) utilizzano i loro flussi propri e non sono governati da questa scadenza. Appare in `/config` come **Dialog expiry**, che scrive questa chiave nelle impostazioni utente; la riga richiede Claude Code v2.1.232 o successivo, e Claude Code la nasconde mentre le impostazioni gestite o il flag `--settings` impostano la chiave.

### `editorMode`

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

* **Scope**: [`Any file`](#scopes)
* **Type**: string, uno di:
  * `"normal"`: scorciatoie da tastiera standard nel prompt di input
  * `"vim"`: editing in stile vim con modalità NORMAL, INSERT e VISUAL
* **Default**: `"normal"`

```json settings.json theme={null}
{
  "editorMode": "vim"
}
```

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

### `emojiCompletionEnabled`

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

* **Scope**: [`Any file`](#scopes)
* **Type**: Boolean
  * `true`: Claude Code mostra suggerimenti emoji dopo `:` e sostituisce un codice breve completato con la sua emoji
  * `false`: Claude Code non suggerisce emoji né sostituisce codici brevi
* **Default**: `true`

```json settings.json theme={null}
{
  "emojiCompletionEnabled": false
}
```

Vedi [Codici brevi emoji](https://code.claude.com/docs/it/interactive-mode.md#emoji-shortcodes). Richiede Claude Code v2.1.217 o successivo.

### `fileSuggestion`

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

* **Scope**: [`Any file`](#scopes). Secondo i [gate di riga di stato e suggerimento file](#status-line-and-file-suggestion-gates), Claude Code disattiva il comando o esegue solo un valore gestito, e salta il tuo senza avviso.
* **Type**: object con `type`, sempre `"command"`, e `command`, il comando shell da eseguire
* **Default**: unset, quindi Claude Code utilizza il suggerimento file integrato

```json settings.json theme={null}
{
  "fileSuggestion": {
    "type": "command",
    "command": "~/.claude/file-suggestion.sh"
  }
}
```

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

#### Input e output del comando

Claude Code esegue il comando con le stesse variabili di ambiente dei [hooks](https://code.claude.com/docs/it/hooks.md), incluso `CLAUDE_PROJECT_DIR`, e smette di attendere dopo cinque secondi. Il comando riceve JSON su stdin con un campo `query` che contiene quello che hai digitato finora:

```json theme={null}
{"query": "src/comp"}
```

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

```text theme={null}
src/components/Button.tsx
src/components/Modal.tsx
src/components/Form.tsx
```

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

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

### `footerLinksRegexes`

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

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

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

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

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

#### Vincoli dei badge

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

| Vincolo | Comportamento |
| :- | :- |
| Origine URL | I valori catturati sono codificati in URL e l'URL costruito deve condividere l'origine letterale del template. Una cattura può riempire un segmento di percorso o un valore di query ma non può cambiare dove punta il link |
| Lunghezza URL | Gli URL costruiti più lunghi di 2048 caratteri vengono eliminati |
| Schema URL | Deve essere `https`, `http`, o uno schema di deep-link riconosciuto per editor o workspace: `vscode`, `vscode-insiders`, `cursor`, `windsurf`, `zed`, `jetbrains`, `idea`, `slack`, `linear`, `notion`, `figma` |
| Etichetta | Predefinita al testo corrispondente e troncata a 28 colonne di visualizzazione |
| Conteggio badge | Al massimo 5 badge vengono renderizzati. Il più vecchio viene sostituito da corrispondenze più recenti e `/clear` li rimuove |

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

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

### `keybindingFlavor`

> [!WARNING]
>
> Deprecato da v2.1.261 e non ha effetto. Le scorciatoie da tastiera di modifica delle parole del prompt seguono sempre [le convenzioni readline](https://code.claude.com/docs/it/interactive-mode.md#make-ctrl-w-delete-back-to-whitespace), come in Bash. Claude Code accetta comunque `keybindingFlavor`, quindi un file di impostazioni che lo imposta rimane valido.

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

* **Scope**: [`Any file`](#scopes)
* **Type**: string, `"classic"` o `"readline"`
* **Default**: unset

### `maxProseWidth`

Limita la larghezza della prosa nelle risposte di Claude in modo che le righe rimangono leggibili in un terminale ampio. I paragrafi, i titoli, gli elenchi e le citazioni si avvolgono entro questo numero di colonne, mentre le tabelle e i blocchi di codice mantengono la larghezza completa del terminale. Richiede Claude Code v2.1.282 o successivo.

* **Scope**: [`Any file`](#scopes)
* **Type**: numero di colonne del terminale, un numero intero, minimo `40`. Claude Code ignora qualsiasi altro valore
* **Default**: unset, quindi la prosa si avvolge al bordo del terminale

```json settings.json theme={null}
{
  "maxProseWidth": 80
}
```

### `prefersReducedMotion`

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

* **Scope**: [`Any file`](#scopes)
* **Type**: Boolean
  * `true`: Claude Code riduce o disattiva le animazioni dell'interfaccia come lo spinner, lo shimmer e gli effetti flash
  * `false`: lo stesso di unset; Claude Code mostra le sue animazioni
* **Default**: `false`

```json settings.json theme={null}
{
  "prefersReducedMotion": true
}
```

### `promptSuggestionEnabled`

Mostra o nascondi i [suggerimenti del prompt](https://code.claude.com/docs/it/interactive-mode.md#prompt-suggestions), le previsioni grigie che appaiono nel tuo input del prompt. Impostalo su `false`, o disattiva **Prompt suggestions** in `/config`, per nasconderli.

* **Scope**: [`Any file`](#scopes)
* **Type**: Boolean
  * `true`: vedi suggerimenti del prompt nel tuo input del prompt
  * `false`: Claude Code nasconde i suggerimenti del prompt
* **Default**: `true`
* **Per-session overrides**: [`CLAUDE_CODE_ENABLE_PROMPT_SUGGESTION`](https://code.claude.com/docs/it/env-vars) ha la precedenza su questa chiave per una sessione

```json settings.json theme={null}
{
  "promptSuggestionEnabled": false
}
```

I suggerimenti del prompt necessitano di un account claude.ai o Console con telemetria attiva. Su Amazon Bedrock, Google Cloud's Agent Platform e Microsoft Foundry, o con telemetria disattivata, come da [`DISABLE_TELEMETRY`](https://code.claude.com/docs/it/env-vars), questa chiave non ha effetto e solo `CLAUDE_CODE_ENABLE_PROMPT_SUGGESTION=1` li attiva.

### `respectGitignore`

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

* **Scope**: [`Any file`](#scopes). Quando nessun file di impostazioni lo imposta, Claude Code ritorna a `respectGitignore` in `~/.claude.json`, che l'interruttore `/config` scrive.
* **Type**: Boolean
  * `true`: il selettore file `@` esclude i file che corrispondono ai pattern `.gitignore`
  * `false`: il selettore file `@` include i file che corrispondono ai pattern `.gitignore`
* **Default**: `true`

```json settings.json theme={null}
{
  "respectGitignore": false
}
```

### `respondToBashCommands`

Scegli se Claude risponde dopo che esegui un comando shell con il prefisso [`!`](https://code.claude.com/docs/it/interactive-mode#shell-mode-with-prefix) nella casella di input. Per impostazione predefinita, Claude Code aggiunge l'output del comando alla conversazione e Claude vi risponde. Imposta questa chiave su `false` per aggiungere l'output al contesto senza una risposta, così puoi eseguire diversi comandi e chiedere informazioni su di essi insieme.

* **Scope**: [`Any file`](#scopes)
* **Type**: Boolean
  * `true`: Claude Code aggiunge l'output del comando alla conversazione e Claude vi risponde
  * `false`: Claude Code aggiunge l'output al contesto senza una risposta
* **Default**: `true`

```json settings.json theme={null}
{
  "respondToBashCommands": false
}
```

Vedi [Modalità shell con prefisso `!`](https://code.claude.com/docs/it/interactive-mode#shell-mode-with-prefix).

### `showClearContextOnPlanAccept`

Quando Claude termina un piano in [modalità piano](https://code.claude.com/docs/it/permission-modes.md#review-and-approve-a-plan), mostra un menu di approvazione. La pianificazione può utilizzare molto contesto, quindi questa chiave aggiunge una prima opzione a quel menu, **Yes, clear context and …**, che approva il piano, cancella il contesto della conversazione e inizia l'implementazione dal piano solo. Il resto dell'etichetta nomina la modalità di autorizzazione in cui la sessione continua, e mostra quanto contesto la pianificazione ha utilizzato.

* **Scope**: [`Any file`](#scopes)
* **Type**: Boolean
  * `true`: il menu di approvazione del piano ottiene una prima opzione, **Yes, clear context and …**, che approva il piano e cancella il contesto della conversazione
  * `false`: il menu di approvazione del piano non mostra alcuna opzione di cancellazione del contesto
* **Default**: `false`

```json settings.json theme={null}
{
  "showClearContextOnPlanAccept": true
}
```

### `showTurnDuration`

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

* **Scope**: [`Any file`](#scopes). Un valore in `~/.claude.json` da una versione precedente si applica quando nessun file di impostazioni lo imposta.
* **Type**: Boolean
  * `true`: vedi il messaggio di durata del turno dopo ogni risposta
  * `false`: Claude Code nasconde il messaggio di durata del turno
* **Default**: `true`

```json settings.json theme={null}
{
  "showTurnDuration": false
}
```

### `spellcheck`

Sottolinea le parole scritte male nel prompt di input mentre digiti, utilizzando un correttore ortografico che installi. Claude Code controlla solo il testo nella casella di input. [Controlla l'ortografia mentre digiti](https://code.claude.com/docs/it/interactive-mode.md#check-spelling-as-you-type) copre l'installazione di aspell, hunspell o ispell e cosa il correttore copre. Richiede Claude Code v2.1.235 o successivo.

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

```json settings.json theme={null}
{
  "spellcheck": { "enabled": true, "language": "en_GB" }
}
```

### `spinnerTipsEnabled`

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

* **Scope**: [`Any file`](#scopes)
* **Type**: Boolean
  * `true`: vedi suggerimenti nello spinner mentre Claude sta lavorando
  * `false`: Claude Code nasconde i suggerimenti dello spinner
* **Default**: `true`

```json settings.json theme={null}
{
  "spinnerTipsEnabled": false
}
```

### `spinnerTipsOverride`

Aggiungi i tuoi suggerimenti ai [suggerimenti dello spinner](#spinnertipsenabled) che Claude Code mostra mentre Claude lavora, o sostituisci i suggerimenti integrati con i tuoi. Claude Code mette i tuoi suggerimenti nella stessa rotazione di quelli integrati.

Se imposti [`spinnerTipsEnabled`](#spinnertipsenabled) su `false`, Claude Code nasconde tutti i suggerimenti, inclusi i tuoi.

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

Gli oggetti suggerimento, `tipsFile`, `label`, e la regola della riga Scope che i file di impostazioni di progetto e locale contribuiscono solo stringhe semplici richiedono Claude Code v2.1.247 o successivo.

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

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

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

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

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

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

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

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

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

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

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

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

### `spinnerVerbs`

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

* **Scope**: [`Any file`](#scopes)
* **Type**: object con un array `verbs` di stringhe e `mode`, uno di:
  * `"append"`: Claude Code aggiunge i tuoi verbi al set integrato
  * `"replace"`: Claude Code mostra solo i tuoi verbi
* **Default**: unset, quindi Claude Code utilizza i verbi integrati

Questo esempio aggiunge due verbi al set integrato:

```json settings.json theme={null}
{
  "spinnerVerbs": {
    "mode": "append",
    "verbs": ["Pondering", "Crafting"]
  }
}
```

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

### `statusLine`

Esegui il tuo comando per renderizzare una [riga di stato](https://code.claude.com/docs/it/statusline.md) sotto il prompt con contesto come il modello, il costo o il ramo git. I campi opzionali regolano la spaziatura, aggiungono re-esecuzioni periodiche e nascondono l'indicatore di modalità vim integrato quando il tuo script renderizza `vim.mode` stesso.

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

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

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

L'esempio ha bisogno di [`jq`](https://jqlang.org/) installato e viene eseguito in una shell. Per equivalenti PowerShell e Git Bash, vedi [Configurazione di Windows](https://code.claude.com/docs/it/statusline.md#windows-configuration); per la configurazione completa, vedi [Configura manualmente una riga di stato](https://code.claude.com/docs/it/statusline.md#manually-configure-a-status-line).

### `subagentStatusLine`

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

* **Scope**: [`Any file`](#scopes). Quando [`allowManagedHooksOnly`](#allowmanagedhooksonly) è attivo, o [`disableAllHooks`](#disableallhooks) è impostato al di fuori delle impostazioni gestite, solo il valore delle impostazioni gestite viene eseguito.
* **Type**: object con `type` impostato su `"command"` e una stringa `command`
* **Default**: unset, quindi Claude Code renderizza le righe predefinite

```json settings.json theme={null}
{
  "subagentStatusLine": {
    "type": "command",
    "command": "jq -c '.tasks[] | {id, content: \"\\(.name): \\(.tokenCount) tokens\"}'"
  }
}
```

Vedi [Righe di stato dei subagenti](https://code.claude.com/docs/it/statusline.md#subagent-status-lines).

### `syntaxHighlightingDisabled`

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

* **Scope**: [`Any file`](#scopes)
* **Type**: Boolean
  * `true`: Claude Code disattiva l'evidenziazione della sintassi nei diff, blocchi di codice e anteprime di file
  * `false`: Claude Code evidenzia la sintassi
* **Default**: `false`

```json settings.json theme={null}
{
  "syntaxHighlightingDisabled": true
}
```

### `terminalProgressBarEnabled`

Alcuni terminali possono mostrare un indicatore di progresso sulla scheda o nella barra delle applicazioni per il programma in esecuzione in essi. Mentre Claude sta lavorando, Claude Code segnala uno stato in corso al terminale, così puoi vedere da un'altra scheda o finestra se la sessione è ancora occupata. L'indicatore rimane visibile dopo che il turno termina mentre i [subagenti in background](https://code.claude.com/docs/it/sub-agents.md#run-subagents-in-foreground-or-background) o i [flussi di lavoro dinamici](https://code.claude.com/docs/it/workflows.md) sono ancora in esecuzione, e si cancella una volta che la sessione è inattiva.

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

* **Scope**: [`Any file`](#scopes). Un valore in `~/.claude.json` da una versione precedente si applica quando nessun file di impostazioni lo imposta.
* **Type**: Boolean
  * `true`: vedi la barra di progresso del terminale nei terminali che la supportano
  * `false`: Claude Code nasconde la barra di progresso del terminale
* **Default**: `true`

```json settings.json theme={null}
{
  "terminalProgressBarEnabled": false
}
```

### `terminalTitleFromRename`

Claude Code imposta il titolo della scheda del tuo terminale. Per impostazione predefinita utilizza un titolo che genera dalla conversazione, e una volta che dai alla sessione un [nome](https://code.claude.com/docs/it/sessions.md#name-your-sessions) con `/rename` o `--name`, la scheda mostra quel nome invece. Imposta questa chiave su `false` per mantenere il titolo generato sulla scheda anche dopo che nomini la sessione. Il nome stesso si applica comunque, quindi `/resume <name>` e il selettore di sessione lo trovano.

* **Scope**: [`Any file`](#scopes)
* **Type**: Boolean
  * `true`: il titolo della scheda del terminale mostra il nome della sessione che hai impostato
  * `false`: la scheda mantiene il titolo che Claude Code genera dalla tua conversazione
* **Default**: `true`

```json settings.json theme={null}
{
  "terminalTitleFromRename": false
}
```

Per impedire a Claude Code di aggiornare il titolo del terminale del tutto, imposta [`CLAUDE_CODE_DISABLE_TERMINAL_TITLE`](https://code.claude.com/docs/it/env-vars) su `1` invece.

### `theme`

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

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

```json settings.json theme={null}
{
  "theme": "light-daltonized"
}
```

Vedi [Crea un tema personalizzato](https://code.claude.com/docs/it/terminal-config.md#create-a-custom-theme).

### `timeFormat`

Scegli come Claude Code scrive i tempi che mostra nell'interfaccia, come il `done 6:05 PM` alla fine di ogni messaggio di durata del turno e i timestamp nel [visualizzatore di trascrizione](https://code.claude.com/docs/it/interactive-mode.md#transcript-viewer). Per scegliere un preset, esegui `/config` e imposta **Time format**. Richiede Claude Code v2.1.257 o successivo.

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

```json settings.json theme={null}
{
  "timeFormat": "24-hour"
}
```

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

```json settings.json theme={null}
{
  "timeFormat": "%H:%M"
}
```

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

```json settings.json theme={null}
{
  "timeFormat": "%Y-%m-%d %H:%M"
}
```

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

### `timeZone`

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

* **Scope**: [`Any file`](#scopes)
* **Type**: string, un nome di fuso orario IANA. Quando Claude Code non riconosce il nome, utilizza il tuo fuso orario di sistema
* **Default**: unset, quindi i tempi mostrano nel tuo fuso orario di sistema

```json settings.json theme={null}
{
  "timeZone": "Europe/Dublin"
}
```

### `tui`

Scegli il renderer dell'interfaccia utente del terminale. Usa `"fullscreen"` per il renderer [alt-screen](https://code.claude.com/docs/it/fullscreen.md) senza sfarfallio con scrollback virtualizzato, o `"default"` per il renderer classico dello schermo principale. Eseguire `/tui fullscreen` o `/tui default` scrive questa chiave per te.

* **Scope**: [`Any file`](#scopes)
* **Type**: string, uno di:
  * `"default"`: il renderer classico dello schermo principale
  * `"fullscreen"`: il renderer alt-screen senza sfarfallio con scrollback virtualizzato
* **Default**: unset, quindi Claude Code [sceglie il renderer per te](https://code.claude.com/docs/it/fullscreen.md#fullscreen-by-default)
* **Per-session overrides**: [`CLAUDE_CODE_NO_FLICKER`](https://code.claude.com/docs/it/env-vars) e [`CLAUDE_CODE_DISABLE_ALTERNATE_SCREEN`](https://code.claude.com/docs/it/env-vars) hanno la precedenza su questa chiave per una sessione: `CLAUDE_CODE_NO_FLICKER=1` attiva fullscreen, e `CLAUDE_CODE_NO_FLICKER=0` o `CLAUDE_CODE_DISABLE_ALTERNATE_SCREEN=1` lo disattiva; quando entrambi sono impostati, Claude Code lo disattiva

```json settings.json theme={null}
{
  "tui": "fullscreen"
}
```

Sotto tmux `-CC` o su SSH a Windows, Claude Code mantiene il renderer classico a meno che tu non imposti `CLAUDE_CODE_NO_FLICKER=1`. Le sessioni in background aperte da [agent view](https://code.claude.com/docs/it/agent-view.md) utilizzano sempre il renderer fullscreen indipendentemente da questa impostazione.

### `verbose`

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

* **Scope**: [`Any file`](#scopes). Un valore in `~/.claude.json` da una versione precedente si applica quando nessun file di impostazioni lo imposta.
* **Type**: Boolean
  * `true`: vedi l'output completo dello strumento
  * `false`: vedi riepiloghi troncati dell'output dello strumento
* **Default**: `false`
* **Per-session overrides**: [`--verbose`](https://code.claude.com/docs/it/cli-reference#cli-flags) ha la precedenza su questa chiave per una sessione

```json settings.json theme={null}
{
  "verbose": true
}
```

Un valore [`viewMode`](#viewmode) o una selezione sticky `/focus` sostituisce questa chiave ogni sessione.

### `viewMode`

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

* **Scope**: [`Any file`](#scopes)
* **Type**: string, uno di:
  * `"default"`: la trascrizione normale con output dello strumento troncato
  * `"verbose"`: la trascrizione con output dello strumento completo
  * `"focus"`: solo il tuo ultimo prompt, un riepilogo di una riga delle chiamate di strumento con diffstat di modifica, e la risposta finale. La visualizzazione focus necessita del [renderer fullscreen](#tui)
* **Default**: unset, quindi l'impostazione `verbose` e la tua ultima scelta `/focus` si applicano
* **Per-session overrides**: [`--verbose`](https://code.claude.com/docs/it/cli-reference#cli-flags) ha la precedenza su questa chiave per una sessione

```json settings.json theme={null}
{
  "viewMode": "focus"
}
```

### `vimInsertModeRemaps`

Mappa sequenze INSERT-mode a due tasti su Escape in [modalità editor vim](https://code.claude.com/docs/it/interactive-mode.md#vim-editor-mode). Ogni chiave è esattamente due caratteri stampabili digitati in sequenza, e `"<Esc>"` è l'unico target supportato; Claude Code ignora altre voci.

* **Scope**: [`User or managed`](#scopes). Un repository non può rimappare le tue scorciatoie da tastiera.
* **Type**: object che mappa una sequenza di due caratteri su `"<Esc>"`
* **Default**: unset

```json settings.json theme={null}
{
  "vimInsertModeRemaps": {
    "jj": "<Esc>"
  }
}
```

Non ha effetto a meno che `editorMode` non sia `"vim"`. Vedi [Rimappa sequenze di tasti INSERT-mode](https://code.claude.com/docs/it/interactive-mode.md#remap-insert-mode-key-sequences).

### `voice`

Attiva la [dettatura vocale](https://code.claude.com/docs/it/voice-dictation.md) e scegli come il tasto di dettatura si comporta. Claude Code scrive questo oggetto per te quando esegui `/voice`.

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

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

```json settings.json theme={null}
{
  "voice": {
    "enabled": true,
    "mode": "tap"
  }
}
```

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

### `voiceEnabled`

> [!WARNING]
>
> Deprecato da v2.1.92, quando l'oggetto [`voice`](#voice) lo ha sostituito. Claude Code lo legge comunque così i file di impostazioni precedenti continuano a funzionare, ma le nuove configurazioni dovrebbero impostare `voice.enabled`.

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

* **Scope**: [`Any file`](#scopes)
* **Type**: Boolean
  * `true`: la dettatura vocale è attiva quando sei connesso con un account claude.ai e la politica della tua organizzazione consente la voce, a meno che `voice.enabled` non sia impostato
  * `false`: la dettatura vocale è disattivata, a meno che `voice.enabled` non sia impostato
* **Default**: unset

```json settings.json theme={null}
{
  "voiceEnabled": true
}
```

### `wheelScrollAccelerationEnabled`

Accelera la velocità di scorrimento della rotella del mouse durante scorrimenti veloci nel [rendering a schermo intero](https://code.claude.com/docs/it/fullscreen.md#mouse-wheel-scrolling). Impostalo su `false` per una velocità di scorrimento costante per tacca della rotella.

* **Scope**: [`Any file`](#scopes)
* **Type**: Boolean
  * `true`: Claude Code accelera la velocità di scorrimento della rotella del mouse durante scorrimenti veloci
  * `false`: Claude Code scorre a una velocità costante per tacca della rotella
* **Default**: `true`

```json settings.json theme={null}
{
  "wheelScrollAccelerationEnabled": false
}
```

## Git e attribuzione

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

### `attribution`

Personalizzate l'attribuzione che Claude Code aggiunge ai commit git e alle pull request. I commit ricevono un [git trailer](https://git-scm.com/docs/git-interpret-trailers) come `Co-Authored-By` per impostazione predefinita; le descrizioni delle pull request ricevono testo semplice. Impostate ogni parte separatamente con le sotto-chiavi di seguito.

* **Ambito**: [`Any file`](#scopes)
* **Tipo**: oggetto con stringhe `commit` e `pr` e un Boolean `sessionUrl`, oppure `false` per nascondere tutta l'attribuzione. Il valore `false` richiede Claude Code v2.1.281 o successivo; le versioni precedenti lo rifiutano e [saltano l'intero file di impostazioni utente, progetto o locale](https://code.claude.com/docs/it/settings.md#fix-a-broken-settings-file) che lo contiene
* **Predefinito**: non impostato, quindi Claude Code utilizza l'attribuzione standard mostrata sotto ogni sotto-chiave

Per nascondere tutta l'attribuzione, impostate `attribution` su `false`. In un file di impostazioni che anche le versioni precedenti leggono, impostate [`commit`](#attribution-commit) e [`pr`](#attribution-pr) su stringhe vuote e [`sessionUrl`](#attribution-sessionurl) su `false` invece.

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

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

Una volta impostato `commit` o `pr`, Claude Code ignora l'impostazione deprecata `includeCoAuthoredBy` e utilizza il testo predefinito per quello dei due che avete lasciato non impostato.

Claude Code comunica a Claude che le vostre istruzioni personali sull'attribuzione, come una regola CLAUDE.md o [memory](https://code.claude.com/docs/it/memory.md), hanno la precedenza su queste righe di commit e PR, a meno che la riga non sia impostata in [managed settings](https://code.claude.com/docs/it/managed-settings.md).

### `includeCoAuthoredBy`

> [!WARNING]
>
> Deprecato dalla v2.0.62, quando [`attribution`](#attribution) lo ha sostituito. Claude Code lo legge ancora, ma le nuove configurazioni dovrebbero impostare `attribution`.

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

* **Ambito**: [`Any file`](#scopes)
* **Tipo**: Boolean
  * `true`: lo stesso di non impostato; Claude Code aggiunge il trailer del commit e il testo di attribuzione della pull request
  * `false`: Claude Code omette sia il trailer del commit che il testo di attribuzione della pull request, a meno che `attribution` non imposti `commit` o `pr`, nel qual caso si applicano le regole [`attribution`](#attribution)
* **Predefinito**: `true`

```json settings.json theme={null}
{
  "includeCoAuthoredBy": false
}
```

Per nascondere tutta l'attribuzione, vedete [`attribution`](#attribution).

### `includeGitInstructions`

Claude Code fornisce a Claude due elementi correlati a git: le sue istruzioni integrate su come scrivere commit e pull request, nella descrizione dello strumento Bash, e uno snapshot dello stato git del vostro repository. Lo snapshot contiene il ramo corrente, il ramo principale, l'output di `git status` e i commit recenti. Claude Code lo legge quando inizia una conversazione.

Impostate questa chiave su `false` per escludere entrambi, ad esempio quando utilizzate le vostre skill di flusso di lavoro git personalizzate.

* **Ambito**: [`Any file`](#scopes)
* **Tipo**: Boolean
  * `true`: Claude Code include le sue istruzioni integrate per il flusso di lavoro di commit e pull request e lo snapshot dello stato git. Le sessioni cloud non includono mai lo snapshot
  * `false`: Claude Code esclude entrambi
* **Predefinito**: `true`
* **Override per sessione**: [`CLAUDE_CODE_DISABLE_GIT_INSTRUCTIONS`](https://code.claude.com/docs/it/env-vars) ha la precedenza su questa chiave per una sessione

```json settings.json theme={null}
{
  "includeGitInstructions": false
}
```

Se sostituisci il prompt di sistema in [modalità non interattiva](https://code.claude.com/docs/it/headless.md) o nell'Agent SDK, la sessione inizia senza lo snapshot anche quando questa chiave è `true`:

* **Esecuzioni con `-p`**: sostituisci il prompt quando passi [`--system-prompt`](https://code.claude.com/docs/it/cli-reference#system-prompt-flags) o `--system-prompt-file`. Lo sostituisci anche quando esegui un agente personalizzato con il proprio prompt, selezionato con [`--agent`](https://code.claude.com/docs/it/sub-agents#invoke-subagents-explicitly) o con l'impostazione [`agent`](#agent). Al di fuori della [modalità bare](https://code.claude.com/docs/it/headless.md#start-faster-with-bare-mode), per mantenere lo snapshot, esegui senza un agente personalizzato e aggiungi le tue istruzioni con [`--append-system-prompt`](https://code.claude.com/docs/it/cli-reference#system-prompt-flags) invece di sostituire il prompt.
* **[Agent SDK](https://code.claude.com/docs/it/agent-sdk/modifying-system-prompts.md)**: sostituisci il prompt con un prompt di sistema personalizzato o con un agente personalizzato per il thread principale. Se non imposti alcun prompt di sistema, l'SDK utilizza il suo default minimo e anche in questo caso la sessione inizia senza lo snapshot. Al di fuori della [modalità bare](https://code.claude.com/docs/it/headless.md#start-faster-with-bare-mode), per mantenere lo snapshot, utilizza il preset `claude_code` senza un `agent` personalizzato.

### `prUrlTemplate`

Indirizzate i link PR che Claude Code renderizza, nel badge del footer e nei riepiloghi dei risultati degli strumenti, verso uno strumento di revisione del codice interno invece di `github.com`. Claude Code sostituisce `{host}`, `{owner}`, `{repo}`, `{number}` e `{url}` dall'URL della PR. I link delle [richieste di merge GitLab](https://code.claude.com/docs/it/interactive-mode.md#gitlab-merge-requests) su entrambe le superfici mantengono il loro URL GitLab.

* **Ambito**: [`Any file`](#scopes)
* **Tipo**: stringa, un modello di URL utilizzando uno qualsiasi dei cinque segnaposti
* **Predefinito**: non impostato

```json settings.json theme={null}
{
  "prUrlTemplate": "https://reviews.example.com/{owner}/{repo}/pull/{number}"
}
```

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

### `attribution.commit`

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

* **Ambito**: [`Any file`](#scopes)
* **Tipo**: stringa
* **Predefinito**: non impostato, quindi Claude Code aggiunge `Co-Authored-By: <name> <noreply@anthropic.com>`. Il nome è il modello in uso quando viene effettuato il commit, come `Claude Sonnet 5`. Quando un [subagent](https://code.claude.com/docs/it/sub-agents.md) effettua il commit, il trailer nomina il modello del subagent.
  * Quando Claude Code riconosce il modello come un modello Claude ma non può confermarne la versione esatta, scrive `Claude` da solo.
  * Quando non può abbinare l'ID del modello a nessun modello Claude, come un modello di terze parti servito attraverso un [`ANTHROPIC_BASE_URL`](https://code.claude.com/docs/it/env-vars) personalizzato, scrive `Claude Code`.

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

```json settings.json theme={null}
{
  "attribution": {
    "commit": "Generated with AI\n\nCo-Authored-By: AI <ai@example.com>"
  }
}
```

### `attribution.pr`

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

* **Ambito**: [`Any file`](#scopes)
* **Tipo**: stringa
* **Predefinito**: non impostato, quindi Claude Code aggiunge `🤖 Generated with [Claude Code](https://claude.com/claude-code)`

```json settings.json theme={null}
{
  "attribution": {
    "pr": ""
  }
}
```

### `attribution.sessionUrl`

Scegliete se Claude Code aggiunge il collegamento della sessione claude.ai quando esegue il commit o apre una pull request da una sessione [cloud](https://code.claude.com/docs/it/claude-code-on-the-web.md) o [Remote Control](https://code.claude.com/docs/it/remote-control.md). Claude Code aggiunge il collegamento come trailer `Claude-Session` sui commit e come collegamento nelle descrizioni delle pull request. Impostatelo su `false` per omettere il collegamento.

* **Ambito**: [`Any file`](#scopes)
* **Tipo**: Boolean
  * `true`: Claude Code aggiunge il collegamento della sessione claude.ai quando esegue il commit o apre una pull request da una sessione cloud o Remote Control
  * `false`: Claude Code omette il collegamento
* **Predefinito**: `true`

```json settings.json theme={null}
{
  "attribution": {
    "sessionUrl": false
  }
}
```

## Hook e automazione

Registra gli hook, limita quali hook vengono eseguiti e controlla i workflow. Per gli eventi e i payload degli hook, consulta il [riferimento degli hook](https://code.claude.com/docs/it/hooks.md).

### `allowedHttpHookUrls`

Limita gli URL che gli [HTTP hook](https://code.claude.com/docs/it/hooks.md#http-hook-fields) possono raggiungere. Quando definisci questa chiave, Claude Code esegue un HTTP hook solo se il suo URL corrisponde a uno dei modelli e blocca il resto senza eseguirli; un array vuoto blocca ogni HTTP hook.

* **Scope**: [`Any file`](#scopes). Degli array viene eseguito il merge tra i file di impostazioni.
* **Type**: array di modelli URL, con `*` come carattere jolly
* **Default**: non impostato, quindi qualsiasi URL è consentito

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

```json settings.json theme={null}
{
  "allowedHttpHookUrls": ["https://hooks.example.com/*", "http://localhost:*"]
}
```

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

Nell'opzione `managedSettings` dell'Agent SDK, Claude Code ignora un elenco che contiene voci, quindi passalo invece nell'[opzione `settings`](https://code.claude.com/docs/it/agent-sdk/typescript#options) dell'SDK. Vedi [cosa fa un elenco vuoto nelle impostazioni padre](https://code.claude.com/docs/it/claude-apps-gateway#how-hook-and-skill-keys-in-parent-settings-take-effect).

### `allowManagedHooksOnly`

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

* **Scope**: [`Managed`](#scopes)
* **Type**: Boolean
  * `true`: solo gli hook gestiti vengono eseguiti, più gli hook dell'Agent SDK e gli hook dai plugin che le tue impostazioni gestite forzano ad abilitare. Vedi [Cosa viene eseguito sotto `allowManagedHooksOnly`](#what-runs-under-allowmanagedhooksonly)
  * `false`: gli hook da ogni ambito di impostazioni e plugin vengono eseguiti
* **Default**: non impostato, quindi gli hook da ogni ambito di impostazioni e plugin vengono eseguiti

```json managed-settings.json theme={null}
{
  "allowManagedHooksOnly": true
}
```

#### Cosa viene eseguito sotto `allowManagedHooksOnly`

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

* **Gli hook gestiti e SDK vengono eseguiti**: gli hook dalle impostazioni gestite e gli hook che l'[Agent SDK](https://code.claude.com/docs/it/agent-sdk/overview.md) registra nel processo
* **Gli hook dei plugin forzati vengono eseguiti**: gli hook dai plugin che le tue impostazioni gestite forzano ad abilitare tramite [`enabledPlugins`](#enabledplugins). Claude Code confronta l'ID completo `plugin@marketplace`, quindi un plugin con lo stesso nome da un marketplace diverso rimane bloccato. Questo ti consente di distribuire hook verificati tramite un marketplace dell'organizzazione mentre blocchi tutto il resto. Un [mod](https://code.claude.com/docs/it/plugins/mods/overview.md) in tale plugin viene caricato solo quando [conta come quello della tua organizzazione](https://code.claude.com/docs/it/plugins/mods/admin.md#install-your-organizations-mods)
* **I monitor degli altri plugin sono bloccati**: i [monitor](https://code.claude.com/docs/it/plugins/components.md#monitors) di un plugin non si avviano a meno che il plugin non sia forzato ad abilitare. Richiede Claude Code v2.1.310 o successivo
* **Tutto il resto è bloccato**: gli hook dell'utente, del progetto e locali, gli hook e i mod da altri plugin installati e gli hook dichiarati nel frontmatter dell'agente. I [mod integrati in Claude Code](https://code.claude.com/docs/it/plugins/mods/overview.md#mods-built-into-claude-code) continuano a essere eseguiti. Per bloccare solo i mod degli utenti, imposta invece [`allowManagedModsOnly`](https://code.claude.com/docs/it/plugins/mods/admin#set-options-on-the-built-in-guard).
* **I plugin con origine comando sono disabilitati**: Claude Code disabilita anche i plugin con un'[origine `command`](https://code.claude.com/docs/it/plugins/marketplace-reference#command-plugin-source), inclusi i plugin forzati abilitati in `enabledPlugins` gestito, a meno che tu non imposti [`disableCommandPluginSources`](#disablecommandpluginsources) su `false` esplicitamente
* **I comandi marketplace `headersHelper` sono bloccati**: Claude Code blocca anche i comandi marketplace [`headersHelper`](https://code.claude.com/docs/it/plugins/host-marketplace#authenticate-archive-downloads) a meno che [`disableCommandPluginSources`](#disablecommandpluginsources) non sia esplicitamente impostato su `false`, ad eccezione di un marketplace che le impostazioni gestite stesse dichiarano. Richiede Claude Code v2.1.238 o successivo
* **La riga di stato e il suggerimento di file si restringono alle impostazioni gestite**: Claude Code legge [`statusLine`](https://code.claude.com/docs/it/statusline), [`fileSuggestion`](#filesuggestion) e [`subagentStatusLine`](https://code.claude.com/docs/it/statusline#subagent-status-lines) solo dalle impostazioni gestite, seguendo i [gate della riga di stato e del suggerimento di file](#status-line-and-file-suggestion-gates)

Il comando [`/goal`](https://code.claude.com/docs/it/goal) non può essere eseguito mentre questa chiave è impostata, perché dipende dagli hook.

### `disableAllHooks`

Disattiva gli [hook](https://code.claude.com/docs/it/hooks.md#disable-or-remove-hooks), qualsiasi [riga di stato](https://code.claude.com/docs/it/statusline.md) personalizzata e qualsiasi comando [suggerimento di file](#filesuggestion) personalizzato. Usalo per disattivare tutti questi temporaneamente senza eliminarli dalle tue impostazioni.

* **Scope**: [`Any file`](#scopes). Solo le impostazioni gestite possono disabilitare gli hook gestiti.
* **Type**: Boolean
  * `true`: Claude Code disattiva gli hook, qualsiasi riga di stato personalizzata e qualsiasi comando suggerimento di file personalizzato
  * `false`: gli hook, la riga di stato e il comando suggerimento di file vengono eseguiti
* **Default**: non impostato, quindi gli hook vengono eseguiti

```json settings.json theme={null}
{
  "disableAllHooks": true
}
```

La portata dipende da quale file contiene la chiave:

* **Nelle impostazioni gestite**: Claude Code disabilita ogni hook configurato, inclusi quelli gestiti, e continua a eseguire gli hook che l'[Agent SDK](https://code.claude.com/docs/it/agent-sdk/overview.md) registra nel processo
* **Nell'opzione `managedSettings` dell'Agent SDK**: su una macchina in cui un amministratore distribuisce impostazioni gestite, Claude Code ignora questa chiave a meno che l'amministratore non [consenta a un host di incorporamento di aggiungere policy](https://code.claude.com/docs/it/managed-settings.md#let-an-embedding-host-add-policy). Dove la chiave ha effetto, gli hook dell'utente, del progetto, locali e dei plugin si arrestano, così come quelli nell'opzione `settings` dell'SDK. Gli hook gestiti di un amministratore, gli hook dei plugin [forzati ad abilitare](#enabledplugins) e le tue [callback degli hook dell'SDK](https://code.claude.com/docs/it/agent-sdk/hooks.md) continuano a essere eseguiti. Richiede Claude Code v2.1.309 o successivo.
* **In qualsiasi altro file di impostazioni**: Claude Code disabilita gli hook dell'utente, del progetto, locali e dei plugin; gli hook gestiti, gli hook dell'Agent SDK e gli hook dai plugin forzati abilitati in [`enabledPlugins`](#enabledplugins) gestito continuano a essere eseguiti

La chiave arresta anche i [mod](https://code.claude.com/docs/it/plugins/mods/overview.md), che sono plugin il cui codice registra hook:

* **Nelle impostazioni gestite**: i mod in ogni plugin installato si arrestano, inclusi quelli della tua organizzazione
* **In qualsiasi altro file di impostazioni**: i mod che hai installato si arrestano e [i mod della tua organizzazione](https://code.claude.com/docs/it/plugins/mods/admin.md#install-your-organizations-mods) continuano a essere eseguiti

I mod integrati in Claude Code continuano a essere eseguiti in entrambi i casi. Ognuno ha [il proprio interruttore](https://code.claude.com/docs/it/plugins/mods/overview.md#mods-built-into-claude-code).

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

Il comando [`/goal`](https://code.claude.com/docs/it/goal) non può essere eseguito mentre gli hook sono disabilitati e il menu `/hooks` mostra un avviso invece dei tuoi hook.

#### Gate della riga di stato e del suggerimento di file

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

* **Disattivato completamente**: quando le impostazioni gestite impostano `disableAllHooks`, o quando la cartella non è attendibile secondo la stessa [regola di trust del workspace degli hook nei file di impostazioni](https://code.claude.com/docs/it/permissions.md#what-runs-before-you-trust-a-folder)
* **Ristretto alle impostazioni gestite**: quando [`allowManagedHooksOnly`](#allowmanagedhooksonly) è impostato, quando `disableAllHooks` è `true` al di fuori delle impostazioni gestite dopo l'applicazione della [precedenza delle impostazioni](https://code.claude.com/docs/it/hooks.md#disable-or-remove-hooks), o quando avvii Claude Code con `--safe-mode`

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

### `disableWorkflows`

Disattiva i [workflow dinamici](https://code.claude.com/docs/it/workflows.md#turn-workflows-off) e i comandi dei workflow in bundle per tutti coloro che le tue impostazioni raggiungono, come un'organizzazione tramite impostazioni gestite. Per attivare o disattivare i workflow solo per te stesso, usa invece [`enableWorkflows`](#enableworkflows), che l'interruttore **Dynamic workflows** in `/config` scrive nelle tue impostazioni utente.

* **Scope**: [`Any file`](#scopes)
* **Type**: Boolean
  * `true`: Claude Code disattiva i workflow dinamici e i comandi dei workflow in bundle per tutti coloro che le tue impostazioni raggiungono
  * `false`: lo stesso di non impostato; se i workflow sono attivi dipende da [`enableWorkflows`](#enableworkflows) e dal default del tuo piano
* **Default**: `false`
* **Per-session overrides**: [`CLAUDE_CODE_DISABLE_WORKFLOWS`](https://code.claude.com/docs/it/env-vars) disattiva i workflow per una sessione; qualunque dei due li disattivi, l'altro non può riattivarli

```json settings.json theme={null}
{
  "disableWorkflows": true
}
```

### `enableWorkflows`

Attiva o disattiva i [workflow dinamici](https://code.claude.com/docs/it/workflows.md) per te stesso quando il default del tuo piano non è quello che desideri. Appare in `/config` come **Dynamic workflows**, che scrive questa chiave nelle tue impostazioni utente e la rimuove di nuovo quando torni al default del tuo piano. Per disattivare i workflow per tutti dalle impostazioni gestite, usa invece [`disableWorkflows`](#disableworkflows).

* **Scope**: [`Any file`](#scopes)
* **Type**: Boolean
  * `true`: Claude Code attiva i workflow dinamici per te
  * `false`: Claude Code disattiva i workflow dinamici per te
* **Default**: non impostato, quindi i workflow sono attivi a meno che tu non sia su un piano Pro, dove sono disattivi
* **Per-session overrides**: [`CLAUDE_CODE_DISABLE_WORKFLOWS`](https://code.claude.com/docs/it/env-vars) disattiva i workflow per una sessione, e `true` qui non può riattivarli mentre è impostato

```json settings.json theme={null}
{
  "enableWorkflows": true
}
```

Anche [`disableWorkflows`](#disableworkflows) e la politica dei workflow della tua organizzazione hanno la precedenza: `enableWorkflows: true` non può riattivare i workflow mentre una qualsiasi fonte li disattiva. Claude Code nasconde la riga di `/config` mentre una fonte diversa dalle tue impostazioni utente imposta `enableWorkflows`, o imposta `disableWorkflows` su `true`.

### `hooks`

Esegui i tuoi comandi, prompt, agenti, richieste HTTP o strumenti MCP come [hook](https://code.claude.com/docs/it/hooks.md) in punti del ciclo di vita di Claude Code, come prima di una chiamata a uno strumento o quando una sessione inizia; il [riferimento degli hook](https://code.claude.com/docs/it/hooks.md#hook-events) elenca ogni evento, il suo payload e i suoi codici di uscita. Ogni evento è mappato a un elenco di gruppi di matcher, e ogni gruppo elenca i gestori da eseguire quando il matcher si applica.

* **Scope**: [`Any file`](#scopes). Degli hook viene eseguito il merge tra i file invece di sostituirsi a vicenda, e gli hook dalle impostazioni gestite non possono essere rimossi da altri file.
* **Type**: oggetto con chiave [hook event](https://code.claude.com/docs/it/hooks.md#hook-events); ogni valore è un array di gruppi `{ "matcher", "hooks" }` le cui voci `hooks` hanno un `type` di `"command"`, `"prompt"`, `"agent"`, `"http"` o `"mcp_tool"`
* **Default**: non impostato, quindi nessun hook viene eseguito

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

```json settings.json theme={null}
{
  "hooks": {
    "PreToolUse": [
      {
        "matcher": "Bash",
        "hooks": [
          { "type": "command", "command": "~/.claude/hooks/check-bash.sh" }
        ]
      }
    ]
  }
}
```

Per ogni evento, modello di matcher e campo del gestore, consulta il [riferimento degli hook](https://code.claude.com/docs/it/hooks.md#configuration). Per disattivare gli hook, vedi [`disableAllHooks`](#disableallhooks); per limitare gli hook a quelli che la tua organizzazione distribuisce, vedi [`allowManagedHooksOnly`](#allowmanagedhooksonly).

### `httpHookAllowedEnvVars`

Un [HTTP hook](https://code.claude.com/docs/it/hooks.md#http-hook-fields) può inserire il valore di una variabile d'ambiente in un'intestazione di richiesta, ad esempio un'intestazione `Authorization: Bearer $HOOK_TOKEN`, ma solo per le variabili che l'hook elenca nel proprio `allowedEnvVars`. Questa chiave imposta un limite esterno su tale elenco per ogni HTTP hook: un hook può utilizzare una variabile solo se sia il proprio `allowedEnvVars` sia questa chiave la nominano. Usala per impedire a un hook di leggere un segreto che non dovrebbe, anche quando la definizione dell'hook lo richiede.

* **Scope**: [`Any file`](#scopes). Degli array viene eseguito il merge tra i file di impostazioni.
* **Type**: array di nomi di variabili d'ambiente
* **Default**: non impostato, quindi si applica l'elenco `allowedEnvVars` di ogni hook

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

```json settings.json theme={null}
{
  "httpHookAllowedEnvVars": ["MY_TOKEN", "HOOK_SECRET"]
}
```

L'allowlist si applica agli hook da ogni fonte, incluse le impostazioni gestite.

Nell'opzione `managedSettings` dell'Agent SDK, Claude Code ignora un elenco che contiene voci, quindi passalo invece nell'[opzione `settings`](https://code.claude.com/docs/it/agent-sdk/typescript#options) dell'SDK. Vedi [cosa fa un elenco vuoto nelle impostazioni padre](https://code.claude.com/docs/it/claude-apps-gateway#how-hook-and-skill-keys-in-parent-settings-take-effect).

### `workflowKeywordTriggerEnabled`

Scegli se digitare la parola chiave `ultracode` in un prompt attiva un [workflow dinamico](https://code.claude.com/docs/it/workflows.md#ask-for-a-workflow-in-your-prompt). Impostalo su `false` per digitare la parola senza attivarne uno.

* **Scope**: [`Any file`](#scopes). Appare in `/config` come **Ultracode keyword trigger**.
* **Type**: Boolean
  * `true`: digitare `ultracode` in un prompt attiva un workflow dinamico
  * `false`: puoi digitare la parola senza attivarne uno
* **Default**: `true`

```json settings.json theme={null}
{
  "workflowKeywordTriggerEnabled": false
}
```

L'impostazione dello sforzo `ultracode`, `/workflows` e i comandi dei workflow salvati non sono interessati.

### `workflowSizeGuideline`

Imposta il [numero di agenti a cui Claude mira](https://code.claude.com/docs/it/workflows.md#set-a-size-guideline) nei workflow dinamici che scrive. Claude Code invia il valore a Claude come consiglio, non come limite imposto: `"small"` chiede meno di 5 agenti, `"medium"` meno di 10 e `"large"` meno di 50. Scegli `"small"` quando vuoi limitare ciò che un workflow spende. Richiede Claude Code v2.1.219 o successivo.

* **Scope**: [`Any file`](#scopes). Un valore lì ha la precedenza sulla scelta **Dynamic workflow size** in `/config`, che Claude Code memorizza in `~/.claude.json`, e Claude Code nasconde quella riga mentre un file di impostazioni imposta la chiave.
* **Type**: stringa, uno di:
  * `"unrestricted"`: nessuna linea guida, quindi Claude dimensiona il workflow in base al compito
  * `"small"`: Claude mira a meno di 5 agenti
  * `"medium"`: Claude mira a meno di 10 agenti
  * `"large"`: Claude mira a meno di 50 agenti
* **Default**: `"medium"`, o `"small"` quando hai effettuato l'accesso con un piano Pro con Claude Code v2.1.271 o successivo

```json settings.json theme={null}
{
  "workflowSizeGuideline": "small"
}
```

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

## Plugin e skills

Abilita i plugin, registra i marketplace, limita le origini dei plugin che un'organizzazione consente e controlla quali skills si caricano. Per l'installazione e la creazione di plugin, vedi [Plugin](https://code.claude.com/docs/it/plugins/overview.md).

### `disableBundledSkills`

Disattiva le [skills](https://code.claude.com/docs/it/skills.md) e i flussi di lavoro inclusi in Claude Code. Claude Code rimuove completamente le skills e i flussi di lavoro in bundle, mentre i comandi incorporati come `/init` rimangono digitabili ma sono nascosti al modello.

* **Scope**: [`Any file`](#scopes)
* **Type**: Boolean
  * `true`: Claude Code rimuove le skills e i flussi di lavoro in bundle e nasconde i comandi incorporati come `/init` dal modello
  * `false`: le skills in bundle si caricano
* **Default**: non impostato, quindi le skills in bundle si caricano
* **Per-session overrides**: [`CLAUDE_CODE_DISABLE_BUNDLED_SKILLS`](https://code.claude.com/docs/it/env-vars) impostato a `1` disattiva le skills in bundle per una sessione; quale dei due le disattiva, l'altro non può riattivarle

```json settings.json theme={null}
{
  "disableBundledSkills": true
}
```

Le skills dai plugin, da `.claude/skills/` e da `.claude/commands/` non sono interessate. `/doctor` rimane digitabile come i comandi incorporati; per nasconderlo, imposta [`DISABLE_DOCTOR_COMMAND`](https://code.claude.com/docs/it/env-vars) invece.

### `disableSkillShellExecution`

Disattiva l'esecuzione inline della shell per `` !`...` `` e ` ```! ` blocchi in [skills](https://code.claude.com/docs/it/skills.md) e comandi personalizzati da origini utente, progetto, plugin o directory aggiuntive. Claude Code sostituisce ogni comando con `[shell command execution disabled by policy]` invece di eseguirlo.

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

```json settings.json theme={null}
{
  "disableSkillShellExecution": true
}
```

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

### `skillOverrides`

Nascondi o comprimi una [skill](https://code.claude.com/docs/it/skills.md#override-skill-visibility-from-settings) senza modificare il suo `SKILL.md`. Claude Code applica il valore sotto il nome di ogni skill all'elenco delle skills che Claude vede e al tuo completamento automatico `/`.

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

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

```json settings.json theme={null}
{
  "skillOverrides": {
    "legacy-context": "name-only",
    "deploy": "off"
  }
}
```

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

Nelle impostazioni gestite e nei file passati con `--settings`, una chiave su un alias di una skill in bundle, come `checkup` per `/doctor`, si applica anche alla skill; vedi [come le chiavi alias si combinano con le chiavi sul nome della skill](https://code.claude.com/docs/it/skills.md#override-skill-visibility-from-settings).

### `syncClaudeAiSkills`

Disattiva il download delle [skills abilitate per il tuo account claude.ai](https://code.claude.com/docs/it/skills.md#how-synced-skills-behave). Claude Code le scarica in `~/.claude/skills/synced/` nelle [sessioni di terminale in cui accedi con il tuo account claude.ai](https://code.claude.com/docs/it/skills.md#where-synced-skills-load), interattive o non interattive, e nelle sessioni Cowork e cloud. Imposta `false` per interrompere il download e smettere di caricare le skills che ha già sincronizzato. Claude Code onora solo `false`: `true` è lo stesso di non impostato e non attiva la sincronizzazione dove è altrimenti disattivata.

* **Scope**: [`User, local, or managed`](#scopes), e file passati con `--settings`. Un repository non può disattivarla per te.
* **Type**: Boolean
  * `false`: Claude Code smette di scaricare le skills sincronizzate e smette di caricare quelle già in `~/.claude/skills/synced/`. Nelle impostazioni utente o gestite, le sposta anche in `~/.claude/skills/.trash/`
  * `true`: lo stesso di non impostato
* **Default**: non impostato, quindi le sessioni con accesso al tuo account claude.ai sincronizzano le tue skills

Questo esempio impedisce a una macchina di scaricare le skills dell'account in qualsiasi sessione:

```json settings.json theme={null}
{
  "syncClaudeAiSkills": false
}
```

### `syncClaudeAiPlugins`

Disattiva il download dei [plugin abilitati per il tuo account claude.ai](https://code.claude.com/docs/it/plugins/loading.md#synced-plugins). Claude Code li scarica in `~/.claude/plugins/synced/` all'inizio delle sessioni di terminale in cui accedi con il tuo account claude.ai e nelle sessioni Cowork, e carica ognuno come `<name>@synced`. Imposta `false` per interrompere il download e smettere di caricare i plugin che ha già sincronizzato. Claude Code onora solo `false`: `true` è lo stesso di non impostato e non attiva la sincronizzazione dove è altrimenti disattivata. Richiede Claude Code v2.1.273 o successivo.

* **Scope**: [`User, local, or managed`](#scopes), e file passati con `--settings`. Un repository non può disattivarla per te.
* **Type**: Boolean
  * `false`: Claude Code smette di scaricare i plugin sincronizzati e smette di caricare quelli già in `~/.claude/plugins/synced/`. Nelle impostazioni utente o gestite, li sposta anche in `~/.claude/plugins/.trash/`
  * `true`: lo stesso di non impostato
* **Default**: non impostato, quindi le sessioni con accesso al tuo account claude.ai sincronizzano i tuoi plugin

Per disattivare un plugin sincronizzato piuttosto che tutti, imposta `"<name>@synced": false` in [`enabledPlugins`](#enabledplugins).

Questo esempio impedisce a una macchina di scaricare i plugin dell'account in qualsiasi sessione:

```json settings.json theme={null}
{
  "syncClaudeAiPlugins": false
}
```

### `allowedChannelPlugins`

Scegli quali plugin di [channel](https://code.claude.com/docs/it/channels.md) possono inviare messaggi nelle sessioni della tua organizzazione. Quando lo imposti, Claude Code utilizza il tuo elenco al posto dell'allowlist predefinito di Anthropic; ogni voce nomina un plugin e il marketplace da cui proviene.

* **Scope**: [`Managed`](#scopes)
* **Type**: array di oggetti, ognuno con stringhe `marketplace` e `plugin`. Una voce può invece essere una stringa `"plugin@marketplace"` come `"telegram@claude-plugins-official"`, che Claude Code tratta come l'oggetto equivalente. La forma stringa richiede Claude Code v2.1.267 o successivo; le versioni precedenti rifiutano l'intero valore `allowedChannelPlugins` quando ne contiene uno
* **Default**: non impostato, quindi Claude Code utilizza l'allowlist predefinito di Anthropic

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

```json managed-settings.json theme={null}
{
  "channelsEnabled": true,
  "allowedChannelPlugins": [
    { "marketplace": "claude-plugins-official", "plugin": "telegram" }
  ]
}
```

Un array vuoto blocca ogni plugin di channel.

Questa chiave ha effetto una volta che i channel superano il gate [`channelsEnabled`](#channelsenabled) per l'account: nei piani Team e Enterprise, e negli account Console con impostazioni gestite, significa `channelsEnabled: true`. Vedi [Limita quali plugin di channel possono eseguirsi](https://code.claude.com/docs/it/channels.md#restrict-which-channel-plugins-can-run).

### `blockedMarketplaces`

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

Se imposti questa chiave nella [console di amministrazione claude.ai](https://code.claude.com/docs/it/server-managed-settings.md), claude.ai la applica anche quando chiunque nella tua organizzazione aggiunge un marketplace da un repository git su claude.ai, come [Come funzionano le restrizioni](https://code.claude.com/docs/it/plugins/org.md#restrict-what-users-can-install) descrive.

* **Scope**: [`Managed`](#scopes)
* **Type**: array di oggetti di origine del marketplace, nelle stesse forme di [`strictKnownMarketplaces`](#allowed-source-types)
* **Default**: non impostato, quindi nessun marketplace è bloccato

Questo esempio blocca un repository GitHub come origine del marketplace:

```json managed-settings.json theme={null}
{
  "blockedMarketplaces": [
    { "source": "github", "repo": "untrusted/plugins" }
  ]
}
```

Una voce `github` può utilizzare la forma [owner-wildcard](#owner-wildcards) `"owner/*"` per bloccare ogni repository sotto quel proprietario GitHub, che richiede Claude Code v2.1.223 o successivo. Aggiungi `{ "source": "skills-dir" }` per impedire a Claude Code di caricare i [plugin `@skills-dir`](https://code.claude.com/docs/it/plugins/loading#plugins-shared-through-a-repository) sia da `~/.claude/skills/` sia dalla `.claude/skills/` di un progetto, senza limitare alcun marketplace. Vedi [Restrizioni del marketplace gestito](https://code.claude.com/docs/it/plugins/org.md#restrict-what-users-can-install).

### `channelsEnabled`

Consenti i [channel](https://code.claude.com/docs/it/channels.md) per la tua organizzazione. Nei piani Team e Enterprise di claude.ai, Claude Code blocca i channel finché non imposti questo a `true`. Per gli account [Anthropic Console](https://code.claude.com/docs/it/authentication.md#claude-console-authentication) che si autenticano con una chiave API, i channel sono consentiti per impostazione predefinita. Se la tua organizzazione distribuisce impostazioni gestite, Claude Code blocca i channel anche su quegli account finché non imposti questa chiave a `true`.

* **Scope**: [`Managed`](#scopes)
* **Type**: Boolean
  * `true`: Claude Code consente i channel per la tua organizzazione
  * `false`: lo stesso di non impostato; se i channel sono bloccati dipende dal tuo piano, come dice il Default
* **Default**: non impostato; i channel sono bloccati nei piani Team e Enterprise e negli account Console con impostazioni gestite, e consentiti nei piani Pro e Max e negli account Console senza impostazioni gestite

```json managed-settings.json theme={null}
{
  "channelsEnabled": true
}
```

Per limitare quali plugin possono registrarsi come channel una volta abilitati, imposta [`allowedChannelPlugins`](#allowedchannelplugins). Vedi [Controlli Enterprise](https://code.claude.com/docs/it/channels.md#enterprise-controls).

### `disableCommandPluginSources`

Blocca l'[origine del plugin `command`](https://code.claude.com/docs/it/plugins/marketplace-reference#command-plugin-source), che installa un plugin eseguendo un comando dichiarato dal marketplace sulla macchina dell'utente. Quando lo imposti a `true`, Claude Code non esegue mai il comando, non installa o aggiorna i plugin con origine command, e smette di caricare quelli già installati. Imposta a `false` per consentirli esplicitamente. Ogni volta che blocca le origini command, che tu lo imposti a `true` o lo lasci non impostato sotto [`allowManagedHooksOnly`](#allowmanagedhooksonly), blocca anche i comandi [`headersHelper`](https://code.claude.com/docs/it/plugins/host-marketplace#authenticate-archive-downloads) del marketplace, tranne per un marketplace che le impostazioni gestite stesse dichiarano. Richiede Claude Code v2.1.229 o successivo, e il blocco `headersHelper` richiede v2.1.238 o successivo.

* **Scope**: [`Managed`](#scopes)
* **Type**: Boolean
  * `true`: Claude Code non esegue mai il comando dichiarato dal marketplace, non installa o aggiorna i plugin con origine command, e smette di caricare quelli già installati
  * `false`: Claude Code consente i plugin con origine command esplicitamente
* **Default**: non impostato, quindi Claude Code segue [`allowManagedHooksOnly`](#allowmanagedhooksonly): un'organizzazione che limita l'esecuzione degli hook alle impostazioni gestite ottiene anche le origini command disabilitate. Un'applicazione che passa [`disableAllHooks: true`](#disableallhooks) nell'opzione `managedSettings` dell'Agent SDK non disabilita di per sé le origini command.

```json managed-settings.json theme={null}
{
  "disableCommandPluginSources": true
}
```

Richiede Claude Code v2.1.229 o successivo.

### `pluginSuggestionMarketplaces`

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

* **Scope**: [`Managed`](#scopes)
* **Type**: array di nomi di marketplace
* **Default**: non impostato, quindi nessun suggerimento dichiarato dal marketplace appare

```json managed-settings.json theme={null}
{
  "pluginSuggestionMarketplaces": ["acme-corp-plugins"]
}
```

Un nome ha effetto solo quando il marketplace è registrato sulla macchina e la sua origine registrata è anche dichiarata nelle stesse impostazioni gestite, come voce [`extraKnownMarketplaces`](#extraknownmarketplaces) per quel nome o come voce di [`strictKnownMarketplaces`](#strictknownmarketplaces). Claude Code ignora un marketplace registrato da un'origine diversa sotto un nome nella allowlist. Il marketplace ufficiale è esente dal requisito di origine: consentire solo il suo nome è sufficiente, poiché quel nome può registrarsi solo dall'origine ufficiale di Anthropic. Vedi [Suggerisci plugin per contesto](https://code.claude.com/docs/it/plugins/relevance.md).

### `pluginTrustMessage`

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

* **Scope**: [`Managed`](#scopes)
* **Type**: string
* **Default**: non impostato, quindi Claude Code mostra solo l'avviso standard

```json managed-settings.json theme={null}
{
  "pluginTrustMessage": "All plugins from our marketplace are approved by IT"
}
```

### `strictKnownMarketplaces`

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

Se imposti questa chiave nella [console di amministrazione claude.ai](https://code.claude.com/docs/it/server-managed-settings.md), claude.ai la applica anche quando chiunque nella tua organizzazione aggiunge un marketplace da un repository git su claude.ai, come [Come funzionano le restrizioni](https://code.claude.com/docs/it/plugins/org.md#restrict-what-users-can-install) descrive.

* **Scope**: [`Managed`](#scopes)
* **Type**: array di oggetti di origine del marketplace; vedi [Tipi di origine consentiti](#allowed-source-types)
* **Default**: non impostato, quindi gli utenti possono aggiungere qualsiasi marketplace. Un array vuoto è un blocco completo che blocca ogni origine del marketplace, incluso il marketplace ufficiale di Anthropic

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

```json managed-settings.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" }
  ]
}
```

Puoi anche scrivere questa chiave come `allowedMarketplaces`; [Alias delle chiavi del marketplace](#marketplace-key-aliases) descrive come Claude Code tratta l'alias e quale versione lo accetta. Questa chiave è un gate di policy: controlla cosa gli utenti possono aggiungere ma non registra nulla. Per limitare e pre-registrare in un file, vedi [Combina con `extraKnownMarketplaces`](#combine-with-extraknownmarketplaces). Per la vista rivolta all'utente, vedi [Restrizioni del marketplace gestito](https://code.claude.com/docs/it/plugins/org.md#restrict-what-users-can-install).

#### Tipi di origine consentiti

Ogni voce di seguito mostra una voce della allowlist per tipo di origine e i campi che accetta. La maggior parte dei tipi corrisponde esattamente; `hostPattern` e `pathPattern` corrispondono per regex, e le voci `github` possono utilizzare un [owner wildcard](#owner-wildcards).

| Source | Example entry | Fields |
| :- | :- | :- |
| `github` | `{ "source": "github", "repo": "acme-corp/plugins", "ref": "main", "path": "marketplace" }` | `repo` obbligatorio; `ref` è un branch o tag; `path` è una sottodirectory |
| `git` | `{ "source": "git", "url": "https://gitlab.example.com/tools/plugins.git", "ref": "production" }` | `url` obbligatorio; `ref` e `path` come per `github` |
| `url` | `{ "source": "url", "url": "https://plugins.example.com/marketplace.json", "headers": { "Authorization": "Bearer ${TOKEN}" } }` | `url` obbligatorio; `headers` aggiunge intestazioni HTTP per l'accesso autenticato |
| `file` | `{ "source": "file", "path": "/opt/acme-corp/plugins/marketplace.json" }` | `path` obbligatorio, il percorso assoluto a un file `marketplace.json` |
| `directory` | `{ "source": "directory", "path": "/opt/acme-corp/approved-marketplaces" }` | `path` obbligatorio, il percorso assoluto a una directory contenente `.claude-plugin/marketplace.json` |
| `hostPattern` | `{ "source": "hostPattern", "hostPattern": "^github\\.example\\.com$" }` | `hostPattern` obbligatorio, una regex corrispondente in qualsiasi punto nell'host del marketplace; ancorarla con `^` e `$` per corrispondere all'intero host |
| `pathPattern` | `{ "source": "pathPattern", "pathPattern": "^/opt/approved/" }` | `pathPattern` obbligatorio, una regex corrispondente in qualsiasi punto nel `path` delle origini `file` e `directory`; iniziarla con `^` per fissare un prefisso |
| `skills-dir` | `{ "source": "skills-dir" }` | Nessun campo |

Alcuni tipi di origine portano regole oltre la tabella:

* **`url`**: un marketplace URL scarica solo il file `marketplace.json`, e Claude Code non recupera i file dei plugin per percorso relativo da quel server, quindi i suoi plugin devono utilizzare un'[origine del plugin](https://code.claude.com/docs/it/plugins/marketplace-reference.md#plugin-sources) diversa da un percorso relativo, come un URL di archivio, che può essere sullo stesso host. Per i plugin con percorsi relativi, utilizza un marketplace basato su Git. Vedi [I plugin con percorsi relativi falliscono nei marketplace basati su URL](https://code.claude.com/docs/it/plugins/troubleshooting.md#plugins-with-relative-paths-fail-in-url-based-marketplaces).
* **`hostPattern`**: usalo per consentire ogni marketplace su un GitHub Enterprise interno o un server GitLab senza elencare ogni repository. Claude Code confronta le origini `github` con `github.com`, prende il nome host dalle origini `url` e lo prende dalle origini `git` a seconda della forma dell'[URL git](https://git-scm.com/docs/git-clone#_git_urls):

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

  Le origini `file` e `directory` non hanno host e non corrispondono mai a una voce `hostPattern`.
* **`pathPattern`**: usalo per consentire marketplace del filesystem insieme alle voci `hostPattern` per le origini di rete. `".*"` consente ogni percorso locale; un pattern più stretto come `"^/opt/approved/"` limita a una directory.
* **`skills-dir`**: qualsiasi allowlist, anche una vuota, impedisce a Claude Code di caricare i [plugin `@skills-dir`](https://code.claude.com/docs/it/plugins/loading#plugins-shared-through-a-repository) sia da `~/.claude/skills/` sia dalla `.claude/skills/` di un progetto. Per continuare a caricarli, aggiungi la voce `{ "source": "skills-dir" }` e lascia non impostato [`strictPluginOnlyCustomization`](#strictpluginonlycustomization). La voce non ha significato al di fuori di questa chiave e di `blockedMarketplaces`.

#### Owner wildcard

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

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

```json managed-settings.json theme={null}
{
  "strictKnownMarketplaces": [
    { "source": "github", "repo": "acme-corp/*" }
  ]
}
```

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

Le regole di corrispondenza differiscono tra le due impostazioni:

| Rule | `strictKnownMarketplaces` | `blockedMarketplaces` |
| - | - | - |
| Corrispondenza dei nomi di origine | Solo forma `owner/repo`. Un URL git che clona lo stesso repository non corrisponde | Qualsiasi ortografia, inclusi gli URL git che si risolvono nello stesso repository github.com |
| Case dell'owner | Sensibile alle maiuscole | Insensibile alle maiuscole |
| `ref` | Segue le regole di corrispondenza esatta della voce: una voce con un `ref` corrisponde solo alle origini con quel ref esatto, e una voce senza uno corrisponde solo alle origini che non specificano un ref | Una voce senza un `ref` blocca tutti i ref dei repository che corrisponde |
| `path` | Più lasco delle regole di corrispondenza esatta della voce: una voce con un `path` richiede quel valore esatto, mentre una voce senza uno corrisponde a qualsiasi path all'interno del repository | Una voce senza un `path` blocca tutti i path dei repository che corrisponde |

#### Corrispondenza esatta

Per ogni tipo di origine tranne le voci `github` owner-wildcard e le voci `hostPattern` e `pathPattern` corrispondenti per regex, Claude Code consente l'aggiunta di un utente solo quando l'origine del marketplace corrisponde esattamente a una voce. Per le origini basate su git `github` e `git`, la corrispondenza esatta include i campi opzionali:

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

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

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

#### Consenti solo il marketplace ufficiale

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

```json managed-settings.json theme={null}
{
  "strictKnownMarketplaces": [
    { "source": "github", "repo": "anthropics/claude-plugins-official" }
  ]
}
```

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

* Ambienti non interattivi che vengono eseguiti prima della prima sessione di terminale interattiva della macchina.
* Macchine in cui Claude Code ha solo eseguito tramite l'estensione VS Code.
* Macchine in cui Claude Code ha già eseguito una sessione di terminale interattiva sotto una policy che ha bloccato il marketplace, come il blocco dell'array vuoto. Claude Code registra il tentativo bloccato e non ritenta dopo il cambio della policy.

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

#### Combina con `extraKnownMarketplaces`

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

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

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

```json managed-settings.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 un marketplace consentito da soli con `/plugin marketplace add`. Il marketplace ufficiale di Anthropic è l'unico che Claude Code registra automaticamente, e solo quando la allowlist lo consente. [Consenti solo il marketplace ufficiale](#allow-only-the-official-marketplace) elenca le macchine che manca.

### `strictPluginOnlyCustomization`

Blocca skills, agent, hook e server MCP dalle origini utente e progetto, quindi possono provenire solo da plugin o impostazioni gestite. Combinalo con [`strictKnownMarketplaces`](#strictknownmarketplaces) per controllare l'intera catena di approvvigionamento della personalizzazione: l'allowlist del marketplace controlla quali plugin gli utenti possono installare.

* **Scope**: [`Managed`](#scopes)
* **Type**: `true` per bloccare tutti e quattro i tipi di personalizzazione, o un array che nomina i tipi da bloccare, da `"skills"`, `"agents"`, `"hooks"` e `"mcp"`
* **Default**: non impostato, quindi nulla è bloccato

Questo esempio blocca skills e hook e lascia agent e server MCP sbloccati:

```json managed-settings.json theme={null}
{
  "strictPluginOnlyCustomization": ["skills", "hooks"]
}
```

Se blocchi una qualsiasi superficie, Claude Code smette anche di caricare i [plugin della directory skills](https://code.claude.com/docs/it/plugins/loading.md#skills-directory-plugins-blocked-by-managed-settings), le cartelle di plugin che gli utenti tengono in `~/.claude/skills/` o `.claude/skills/`. Gli utenti collocano queste cartelle da soli invece di installarle da un marketplace, quindi Claude Code le tratta come personalizzazione dell'utente ai fini di questa impostazione.

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

### `strictPluginOnlyCustomization.skills`

Blocca la superficie `skills`. Claude Code smette di caricare le skill da `~/.claude/skills/` e `.claude/skills/`, i comandi personalizzati da `~/.claude/commands/` e `.claude/commands/`, le skill e i comandi sotto le directory `--add-dir` e le skill sincronizzate dal tuo account claude.ai. Continua a caricare le skill incluse, le skill nella directory della policy gestita e le skill dei plugin diversi dai [plugin della directory skills](https://code.claude.com/docs/it/plugins/loading.md#skills-directory-plugins-blocked-by-managed-settings).

* **Scope**: [`Managed`](#scopes)
* **Type**: la stringa `"skills"` nell'array [`strictPluginOnlyCustomization`](#strictpluginonlycustomization)
* **Default**: non bloccato

```json managed-settings.json theme={null}
{
  "strictPluginOnlyCustomization": ["skills"]
}
```

### `strictPluginOnlyCustomization.agents`

Blocca la superficie `agents`. Claude Code smette di caricare gli agenti da `~/.claude/agents/`, `.claude/agents/` e dalle directory `--add-dir`. Continua a caricare gli agenti integrati, gli agenti nella directory della policy gestita e gli agenti dei plugin diversi dai [plugin della directory skills](https://code.claude.com/docs/it/plugins/loading.md#skills-directory-plugins-blocked-by-managed-settings).

* **Scope**: [`Managed`](#scopes)
* **Type**: la stringa `"agents"` nell'array [`strictPluginOnlyCustomization`](#strictpluginonlycustomization)
* **Default**: non bloccato

```json managed-settings.json theme={null}
{
  "strictPluginOnlyCustomization": ["agents"]
}
```

### `strictPluginOnlyCustomization.hooks`

Blocca la superficie `hooks`:

* **Smette di eseguire**:
  * Gli hook dai file `settings.json` utente, di progetto e locali
  * Gli hook nel frontmatter di skill, comandi personalizzati e agenti, dalle origini che un blocco [`skills`](#strictpluginonlycustomization-skills) o [`agents`](#strictpluginonlycustomization-agents) bloccherebbe
* **Continua a eseguire**: gli hook nelle impostazioni gestite e gli hook dei plugin diversi dai [plugin della directory skills](https://code.claude.com/docs/it/plugins/loading.md#skills-directory-plugins-blocked-by-managed-settings)

Le skill, i comandi personalizzati e gli agenti i cui hook nel frontmatter smettono di essere eseguiti continuano comunque a caricarsi finché la loro superficie non è bloccata.

Una [skill](https://code.claude.com/docs/it/skills.md#where-skills-live) personale o di progetto che dichiara `hooks` nel suo frontmatter perde anche la pre-approvazione [`allowed-tools`](https://code.claude.com/docs/it/skills#pre-approve-tools-for-a-skill), quindi i tuoi utenti ricevono richieste di permesso per gli strumenti elencati in quel campo. Quando una skill di questo tipo viene eseguita in un subagent tramite [`context: fork`](https://code.claude.com/docs/it/skills#run-skills-in-a-subagent), mantiene la pre-approvazione. Anche una skill che non dichiara `hooks` mantiene la sua pre-approvazione.

* **Scope**: [`Managed`](#scopes)
* **Type**: la stringa `"hooks"` nell'array [`strictPluginOnlyCustomization`](#strictpluginonlycustomization)
* **Default**: non bloccato

```json managed-settings.json theme={null}
{
  "strictPluginOnlyCustomization": ["hooks"]
}
```

### `strictPluginOnlyCustomization.mcp`

Blocca la superficie `mcp`. Claude Code smette di caricare i server MCP da `~/.claude.json` e `.mcp.json`. Continua a caricare i server [`managed-mcp.json`](https://code.claude.com/docs/it/managed-mcp), i server da [`managedMcpServers`](#managedmcpservers) e i server MCP dei plugin diversi dai [plugin della directory skills](https://code.claude.com/docs/it/plugins/loading.md#skills-directory-plugins-blocked-by-managed-settings).

* **Scope**: [`Managed`](#scopes)
* **Type**: la stringa `"mcp"` nell'array [`strictPluginOnlyCustomization`](#strictpluginonlycustomization)
* **Default**: non bloccato

```json managed-settings.json theme={null}
{
  "strictPluginOnlyCustomization": ["mcp"]
}
```

### `enabledPlugins`

Attiva o disattiva i singoli [plugin](https://code.claude.com/docs/it/plugins/overview.md), codificati come `plugin-name@marketplace-name`. Un plugin senza voce in alcuno scope ricade al suo valore [`defaultEnabled`](https://code.claude.com/docs/it/plugins/manifest-reference#fields). Quando abiliti o disabiliti un plugin con `/plugin` o `claude plugin enable`, Claude Code scrive questa chiave per te.

* **Scope**: [`Any file`](#scopes)
* **Type**: oggetto che mappa `plugin-name@marketplace-name` a un Boolean
* **Default**: non impostato, quindi ogni plugin segue il suo valore `defaultEnabled`

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

```json settings.json theme={null}
{
  "enabledPlugins": {
    "code-formatter@team-tools": true,
    "deployment-tools@team-tools": true,
    "experimental-features@personal": false
  }
}
```

Ogni scope serve a uno scopo diverso:

* **User settings**: le tue preferenze personali dei plugin
* **Project settings**: i plugin condivisi con tutti nel repository
* **Local settings**: override per macchina, gitignored quando Claude Code salva un'impostazione lì
* **Managed settings**: policy a livello organizzativo. Un plugin impostato a `false` qui è bloccato dall'installazione in ogni scope e nascosto dal marketplace

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

Abilitare un plugin da un'origine esterna come un repository GitHub o un pacchetto npm nel `.claude/settings.json` di un progetto non lo installa per altre persone. Su ogni percorso che carica i plugin, Claude Code segnala il plugin come non installato finché ogni utente non lo [installa da solo](https://code.claude.com/docs/it/plugins/org.md#require-plugins-per-repository).

### `extraKnownMarketplaces`

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

* **Scope**: [`Any file`](#scopes). Claude Code onora le voci nel `.claude/settings.json` o `.claude/settings.local.json` di un repository solo dopo che accetti il dialogo di fiducia dell'area di lavoro per quella cartella; in una cartella che non hai fidato, inclusa una corsa `-p` lì, le ignora senza un messaggio.
* **Type**: oggetto che mappa un nome di marketplace a un oggetto con un oggetto `source` e un Boolean `autoUpdate` opzionale
* **Default**: non impostato

Questo esempio registra un marketplace GitHub e un marketplace da un URL git self-hosted:

```json settings.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"
      }
    }
  }
}
```

[Cosa viene eseguito prima di fidare una cartella](https://code.claude.com/docs/it/permissions.md#what-runs-before-you-trust-a-folder) confronta il gate di fiducia con l'altro contenuto che un repository può fornire. Puoi anche scrivere questa chiave come `additionalMarketplaces`; vedi [Alias delle chiavi del marketplace](#marketplace-key-aliases).

Imposta `"autoUpdate": true` insieme a `source` per fare in modo che Claude Code aggiorni quel marketplace e aggiorni i suoi plugin installati in background dopo l'avvio. Quando omesso, `claude-plugins-official` e la maggior parte degli altri marketplace ufficiali di Anthropic predefiniti a `true`, e i marketplace di terze parti predefiniti a `false`. Vedi [Configura gli auto-aggiornamenti](https://code.claude.com/docs/it/plugins/install.md#keep-plugins-updated).

Quando più di un file di impostazioni definisce una voce del marketplace con lo stesso nome, Claude Code utilizza la voce dal [file di precedenza più alta](https://code.claude.com/docs/it/settings.md#settings-precedence) interamente. Quella voce sostituisce la voce di precedenza inferiore e non eredita nessuno dei suoi campi, quindi una ridefinizione non può combinare le credenziali `source.headers` di un file con un URL che un altro file controlla. Prima di v2.1.228, Claude Code univa le voci con lo stesso nome campo per campo, quindi una voce in un file di precedenza superiore poteva ereditare campi che non impostava, incluso `headers` di un altro file.

#### Tipi di origine del marketplace

L'oggetto `source` assume una di queste forme:

* **`github`**: un repository GitHub, con `repo`
* **`git`**: qualsiasi URL git, con `url`
* **`url`**: un URL diretto a un file `marketplace.json`, con `url` e `headers` opzionali e `headersHelper` per l'accesso autenticato. `headersHelper` nomina un comando che stampa intestazioni i cui valori sono troppo brevi per elencare in `headers`, e richiede Claude Code v2.1.238 o successivo
* **`file`**: un percorso locale a un file `marketplace.json`, con `path`
* **`directory`**: un percorso del filesystem locale, con `path`. Usalo per lo sviluppo, o per un marketplace che la tua organizzazione [distribuisce a ogni macchina](https://code.claude.com/docs/it/plugins/mods/admin.md#install-your-organizations-mods).
* **`settings`**: un marketplace inline dichiarato direttamente nel file di impostazioni senza un repository ospitato, con `name` e `plugins`

Il tipo di origine `git` funziona con qualsiasi servizio di hosting git, incluso GitLab self-hosted e Bitbucket. Claude Code clona il repository con la stessa autenticazione che `git clone` userebbe su quella macchina: helper di credenziali configurati o chiavi SSH. Un token del provider come `GITHUB_TOKEN` ha effetto tramite un helper di credenziali che lo legge. Vedi [Repository privati](https://code.claude.com/docs/it/plugins/host-marketplace.md#grant-access-to-a-private-marketplace) per i dettagli di configurazione.

Per le origini `github` e `git`, Claude Code non scarica mai il contenuto di [Git LFS](https://git-lfs.com) quando clona il repository del marketplace per aggiungerlo o aggiornarlo. I file tracciati da LFS vengono estratti come file puntatore, e l'output di aggiunta o aggiornamento segnala quanti.

Il campo `skipLfs` all'interno dell'oggetto `source` è accettato e non ha effetto. Prima di v2.1.274, Claude Code scaricava il contenuto LFS a meno che non impostassi `"skipLfs": true`.

Per un'origine `url`, imposta `headersHelper` all'interno dell'oggetto `source` quando la credenziale in `headers` scade e un comando deve produrne una fresca. Richiede Claude Code v2.1.238 o successivo. Per quello che il comando deve stampare e dove Claude Code lo esegue, vedi [Scrivi il comando headersHelper](https://code.claude.com/docs/it/plugins/host-marketplace.md#write-the-headershelper-command), e per i casi in cui Claude Code non lo esegue, vedi [Quando Claude Code salta un comando headersHelper](https://code.claude.com/docs/it/plugins/host-marketplace.md#when-claude-code-skips-a-headershelper-command-or-drops-its-output). Una volta che imposti `headersHelper` su un URL del marketplace `https://`, Claude Code esegue il comando in due punti, riutilizzando l'output di una corsa per fino a 60 secondi:

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

Claude Code ignora qualsiasi `headersHelper` impostato nel `.claude/settings.json` o `.claude/settings.local.json` di una directory che aggiungi con [`--add-dir`](https://code.claude.com/docs/it/permissions#what-runs-before-you-trust-a-folder), su un'origine `url` e su una voce di plugin inline allo stesso modo, e invia solo le `headers` fisse impostate in quel file. [Come gli utenti accettano un comando headersHelper](https://code.claude.com/docs/it/plugins/host-marketplace.md#how-users-accept-a-headershelper-command) copre gli altri file di impostazioni.

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

```json settings.json theme={null}
{
  "extraKnownMarketplaces": {
    "team-tools": {
      "source": {
        "source": "settings",
        "name": "team-tools",
        "plugins": [
          {
            "name": "code-formatter",
            "source": {
              "source": "github",
              "repo": "acme-corp/code-formatter"
            }
          }
        ]
      }
    }
  }
}
```

Una voce di plugin sotto `source: 'settings'` il cui `source` è un [`archive`](https://code.claude.com/docs/it/plugins/marketplace-reference#archive-plugin-source) può impostare `headers` per il download dell'archivio. Se il valore che metteresti in `headers` è breve, come un token che il tuo registro conia su richiesta, imposta un comando `headersHelper` invece. Una voce può impostare entrambi. Entrambi i campi richiedono Claude Code v2.1.238 o successivo.

Claude Code invia le `headers` della voce, e qualunque cosa il comando stampi, con il download dell'archivio di quel plugin e con nessun altro download. Claude Code esegue il comando solo quando un utente [installa o aggiorna quel solo plugin da solo](https://code.claude.com/docs/it/plugins/host-marketplace.md#how-users-accept-a-headershelper-command). Tre ulteriori regole dipendono da quale file contiene la voce:

* **`strict`**: a differenza di una voce nel `marketplace.json` di un marketplace, una voce nelle impostazioni non ha bisogno di `"strict": false`, perché un file di impostazioni non porta campi di manifest da inline. Vedi [Strict mode](https://code.claude.com/docs/it/plugins/marketplace-reference.md#strict-mode).
* **Folder trust**: per una voce nel `.claude/settings.json` o `.claude/settings.local.json` di un progetto, Claude Code esegue il comando solo dopo che l'utente ha anche [fidato quella cartella](https://code.claude.com/docs/it/permissions.md#what-runs-before-you-trust-a-folder).
* **Header filter**: Claude Code elimina i [nomi di intestazione di routing delle richieste e identità del client](https://code.claude.com/docs/it/plugins/host-marketplace.md#when-claude-code-skips-a-headershelper-command-or-drops-its-output) da una voce nel `.claude/settings.json` o `.claude/settings.local.json` di un progetto, perché un repository può fornire quei file. Claude Code applica lo stesso filtro a una voce del catalogo e a una voce nelle impostazioni di una directory `--add-dir`, e nessun filtro a una voce nelle tue impostazioni utente, un file `--settings` o impostazioni gestite.

#### Alias delle chiavi del marketplace

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

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

### `pluginConfigs`

Memorizza le risposte non sensibili che dai al dialogo di configurazione [`userConfig`](https://code.claude.com/docs/it/plugins/manifest-reference#user-configuration) di un plugin, codificate per ID del plugin. Claude Code scrive questa chiave nelle tue impostazioni utente quando riempi il dialogo, quindi non hai bisogno di modificarla a mano. Claude Code memorizza le opzioni sensibili nel Portachiavi di macOS invece, ricadendo a `~/.claude/.credentials.json` quando il Portachiavi rifiuta la scrittura; su piattaforme senza un portachiavi supportato, le memorizza in `~/.claude/.credentials.json`.

* **Scope**: [`User or managed`](#scopes)
* **Type**: oggetto che mappa un ID del plugin a un oggetto con un campo `options`, mappando ogni nome di opzione a una stringa, numero, Boolean o array di stringhe, e un campo `mcpServers` opzionale contenente i valori di configurazione utente per server nella stessa forma
* **Default**: non impostato

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

```json settings.json theme={null}
{
  "pluginConfigs": {
    "deployer@acme-tools": {
      "options": {
        "api_endpoint": "https://api.example.com"
      }
    }
  }
}
```

I plugin integrati memorizzano le loro opzioni sotto la stessa chiave con un suffisso `@builtin`. Ad esempio, l'impostazione [**Project instructions**](https://code.claude.com/docs/it/memory.md#choose-which-instruction-files-load) che controlla se Claude Code legge i file `AGENTS.md` è `pluginConfigs["cc-plugin-agents-md@builtin"].options.instructionFiles`. Prima di v2.1.285, l'ID del plugin era `agents-md@builtin`. Le versioni successive leggono una voce sotto l'uno o l'altro ID.

Claude Code ignora le voci di progetto e locali perché sostituisce questi valori nelle configurazioni di hook, MCP e LSP del plugin, e un repository clonato non deve poterli fornire.

### `prependPlugins`

Elenca i plugin gestiti i cui [mods](https://code.claude.com/docs/it/plugins/mods/overview.md) vengono eseguiti prima di ogni mod che un utente installa, nell'ordine elencato. Quando imposti questa chiave nelle impostazioni gestite, nomina `sec-default@builtin` nell'elenco per mantenere la guardia incorporata. Nelle impostazioni gestite, Claude Code salta un id il cui plugin non conta come della tua organizzazione. Vedi [Installa i mods della tua organizzazione e imposta l'ordine](https://code.claude.com/docs/it/plugins/mods/admin.md#install-your-organizations-mods) per quelle condizioni e per come le due chiavi di ordinamento funzionano insieme.

* **Scope**: [`User or managed`](#scopes). Claude Code legge la chiave dalle impostazioni gestite. Legge la chiave dalle impostazioni utente solo su una macchina senza impostazioni gestite, in una sessione la cui credenziale non è un `/login` Team o Enterprise. Ignora la chiave nelle impostazioni di progetto e locali e in un file `--settings`.
* **Type**: array di stringhe `plugin-name@marketplace-name`
* **Default**: non impostato

```json managed-settings.json theme={null}
{
  "extraKnownMarketplaces": {
    "acme-tools": {
      "source": { "source": "directory", "path": "/opt/acme/claude-plugins" }
    }
  },
  "enabledPlugins": { "acme-guard@acme-tools": true },
  "prependPlugins": ["acme-guard@acme-tools", "sec-default@builtin"]
}
```

### `appendPlugins`

Elenca i plugin gestiti i cui [mods](https://code.claude.com/docs/it/plugins/mods/overview.md) vengono eseguiti dopo ogni mod che un utente installa, nell'ordine elencato. Un id elencato sia in `prependPlugins` che in `appendPlugins` viene preposto. Nelle impostazioni gestite, Claude Code salta un id il cui plugin non [conta come della tua organizzazione](https://code.claude.com/docs/it/plugins/mods/admin.md#install-your-organizations-mods).

* **Scope**: [`User or managed`](#scopes). Claude Code legge la chiave dalle impostazioni gestite. Legge la chiave dalle impostazioni utente solo su una macchina senza impostazioni gestite, in una sessione la cui credenziale non è un `/login` Team o Enterprise. Ignora la chiave nelle impostazioni di progetto e locali e in un file `--settings`.
* **Type**: array di stringhe `plugin-name@marketplace-name`
* **Default**: non impostato

```json managed-settings.json theme={null}
{
  "extraKnownMarketplaces": {
    "acme-tools": {
      "source": { "source": "directory", "path": "/opt/acme/claude-plugins" }
    }
  },
  "enabledPlugins": { "acme-audit@acme-tools": true },
  "appendPlugins": ["acme-audit@acme-tools"]
}
```

## MCP

Controllare a quali server MCP Claude Code si connette e quali un'organizzazione consente. Vedere [Connettere a strumenti esterni con MCP](https://code.claude.com/docs/it/mcp.md) e [Configurazione MCP gestita](https://code.claude.com/docs/it/managed-mcp.md).

### `allowAllClaudeAiMcps`

Caricare i [connettori claude.ai](https://code.claude.com/docs/it/mcp.md#use-mcp-servers-from-claude-ai) che Claude Code recupera da solo insieme a un `managed-mcp.json` distribuito. Senza questa chiave, `managed-mcp.json` assume il controllo esclusivo dei server MCP e sopprime quei connettori.

* **Scope**: [`Managed`](#scopes). Gli utenti non possono riabilitare i connettori che il controllo esclusivo ha soppresso.
* **Type**: Boolean
  * `true`: Claude Code carica i connettori claude.ai insieme a un `managed-mcp.json` distribuito
  * `false`: un `managed-mcp.json` distribuito assume il controllo esclusivo dei server MCP e sopprime i connettori claude.ai [che Claude Code recupera da solo](https://code.claude.com/docs/it/mcp.md#how-connectors-reach-claude-code)
* **Default**: `false`, quindi un `managed-mcp.json` distribuito sopprime i connettori claude.ai che Claude Code recupera da solo

```json managed-settings.json theme={null}
{
  "allowAllClaudeAiMcps": true
}
```

[`allowedMcpServers`](#allowedmcpservers) e [`deniedMcpServers`](#deniedmcpservers) si applicano ancora ai connettori che questa chiave carica. I connettori consegnati a una [sessione cloud](https://code.claude.com/docs/it/claude-code-on-the-web.md) il cui host contiene un `managed-mcp.json`, come un runner auto-ospitato, rimangono soppressi. Vedere [Consentire i connettori claude.ai insieme al set gestito](https://code.claude.com/docs/it/managed-mcp.md#allow-claude-ai-connectors-alongside-the-managed-set).

### `allowClaudeInChromeWithManagedMcp`

Consentire al server [Claude in Chrome](https://code.claude.com/docs/it/chrome.md) incorporato di funzionare insieme a un `managed-mcp.json` distribuito. Senza questa chiave, un `managed-mcp.json` distribuito blocca Claude in Chrome nelle sessioni di terminale. Richiede Claude Code v2.1.282 o successivo.

* **Scope**: [`Managed`](#scopes), solo dalle impostazioni gestite del dispositivo: un plist distribuito da MDM o una chiave di registro HKLM, o un file `managed-settings.json` di sistema. Claude Code lo ignora nelle impostazioni gestite dal server, nel registro HKCU scrivibile dall'utente e nelle impostazioni utente o progetto.
* **Type**: Boolean
  * `true`: il server Claude in Chrome incorporato può funzionare insieme a un `managed-mcp.json` distribuito
  * `false`: un `managed-mcp.json` distribuito blocca Claude in Chrome nelle sessioni di terminale
* **Default**: `false`, quindi un `managed-mcp.json` distribuito blocca Claude in Chrome nelle sessioni di terminale

```json managed-settings.json theme={null}
{
  "allowClaudeInChromeWithManagedMcp": true
}
```

Una voce [`deniedMcpServers`](#deniedmcpservers) per `claude-in-chrome` blocca comunque il server con questa chiave attivata. Vedere [Consentire Claude in Chrome insieme al set gestito](https://code.claude.com/docs/it/managed-mcp.md#allow-claude-in-chrome-alongside-the-managed-set).

### `allowedMcpServers`

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

I server incorporati come Claude in Chrome, il server `ide` a cui Claude Code si connette in un [VS Code](https://code.claude.com/docs/it/vs-code.md#the-built-in-ide-mcp-server) o [JetBrains](https://code.claude.com/docs/it/jetbrains.md#the-built-in-ide-mcp-server) IDE in esecuzione e i server che la CLI stessa configura sono esenti dall'elenco di autorizzazione e l'elenco di negazione si applica ancora a loro. Su Claude Code v2.1.268 o successivo, gli strumenti Slack di una sessione [Claude Tag](https://code.claude.com/docs/it/claude-tag.md) sono anche esenti dall'elenco di autorizzazione e l'elenco di negazione si applica ancora a loro. I server `type: "sdk"` in-process sono esenti da entrambi gli elenchi; [l'app che ha avviato la sessione](https://code.claude.com/docs/it/mcp.md#how-connectors-reach-claude-code) li registra.

Anche i server che la tua organizzazione fornisce sono esenti dall'allowlist, e la denylist si applica ancora a loro. L'esenzione copre ogni voce [`managedMcpServers`](#managedmcpservers) e qualsiasi voce [`managed-mcp.json`](https://code.claude.com/docs/it/managed-mcp#exclusive-control-with-managed-mcp-json) i cui valori [non usano l'espansione `${VAR}` al di fuori di `env`](https://code.claude.com/docs/it/managed-mcp#how-allowlists-and-denylists-apply-to-the-managed-set). Consulta [Come viene valutato un server](https://code.claude.com/docs/it/managed-mcp.md#how-a-server-is-evaluated) per l'ordine di controllo completo. Prima della v2.1.259, anche i server da `managed-mcp.json` dovevano corrispondere.

* **Scope**: [`Any file`](#scopes). Le voci di ogni file si uniscono in un elenco di autorizzazione a meno che [`allowManagedMcpServersOnly`](#allowmanagedmcpserversonly) non sia impostato. Distribuirlo nelle impostazioni gestite per applicarlo.
* **Tipo**: array di oggetti, ciascuno con esattamente una chiave. Usa `serverName`, una stringa limitata a lettere, numeri, trattini e trattini bassi; `serverCommand`, un array del comando e dei suoi argomenti confrontati in modo esatto; oppure `serverUrl`, un pattern di URL con caratteri jolly `*`
* **Default**: non impostato, quindi ogni server è consentito; un array vuoto blocca ogni server che gli utenti aggiungono

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

```json settings.json theme={null}
{
  "allowedMcpServers": [
    { "serverCommand": ["npx", "-y", "@modelcontextprotocol/server-filesystem"] }
  ]
}
```

Una voce [`deniedMcpServers`](#deniedmcpservers) ha la precedenza, quindi un server in entrambi gli elenchi è bloccato. Una volta che l'elenco contiene qualsiasi voce `serverCommand`, un server stdio deve corrispondere a una voce `serverCommand`, e una volta che contiene qualsiasi voce `serverUrl`, un server remoto deve corrispondere a una voce `serverUrl`: una corrispondenza `serverName` non ammette più quel tipo di server. Vedere [Controllo basato su criteri con elenchi di autorizzazione e negazione](https://code.claude.com/docs/it/managed-mcp.md#policy-based-control-with-allowlists-and-denylists).

### `allowManagedMcpServersOnly`

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

* **Scope**: [`Managed`](#scopes)
* **Type**: Boolean
  * `true`: Claude Code legge `allowedMcpServers` solo dalle impostazioni gestite e ignora gli elenchi di autorizzazione nelle impostazioni utente, progetto e locale
  * `false`: gli elenchi di autorizzazione da ogni ambito di impostazioni si uniscono
* **Default**: `false`, quindi gli elenchi di autorizzazione da ogni ambito di impostazioni si uniscono

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

```json managed-settings.json theme={null}
{
  "allowManagedMcpServersOnly": true,
  "allowedMcpServers": [
    { "serverName": "github" }
  ]
}
```

Gli utenti possono comunque aggiungere server MCP propri; solo i server che corrispondono all'elenco di autorizzazione gestito vengono caricati. Vedere [Limitare l'elenco di autorizzazione alle sole impostazioni gestite](https://code.claude.com/docs/it/managed-mcp.md#restrict-the-allowlist-to-managed-settings-only).

### `deniedMcpServers`

Bloccare server MCP specifici. Claude Code rifiuta di caricare un server corrispondente ovunque sia definito, inclusi i server plugin, i server passati con `--mcp-config`, i server da `managed-mcp.json`, i server da [`managedMcpServers`](#managedmcpservers) e i connettori claude.ai [che recupera da solo](https://code.claude.com/docs/it/mcp.md#how-connectors-reach-claude-code). I server `type: "sdk"` in-process sono esenti; l'app che ha avviato la sessione li registra.

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

```json settings.json theme={null}
{
  "deniedMcpServers": [
    { "serverName": "filesystem" }
  ]
}
```

L'elenco di negazione ha la precedenza su [`allowedMcpServers`](#allowedmcpservers), quindi un server in entrambi gli elenchi è bloccato. Vedere [Controllo basato su criteri con elenchi di autorizzazione e negazione](https://code.claude.com/docs/it/managed-mcp.md#policy-based-control-with-allowlists-and-denylists).

### `disableClaudeAiConnectors`

Disattivare i [connettori MCP claude.ai](https://code.claude.com/docs/it/mcp.md#use-mcp-servers-from-claude-ai) [che Claude Code recupera da solo](https://code.claude.com/docs/it/mcp.md#how-connectors-reach-claude-code), in modo che non li recuperi né li connetta. Un `true` in qualsiasi file di impostazioni si applica: un `.claude/settings.json` di progetto archiviato può escludere un repository da quei connettori, ma un `false` a livello di progetto non può sovrascrivere un `true` a livello di utente o gestito.

* **Scope**: [`Any file`](#scopes)
* **Type**: Boolean
  * `true`: Claude Code non recupera né connette quei connettori
  * `false`: lo stesso di non impostato; Claude Code recupera i tuoi connettori a meno che un altro file di impostazioni o `ENABLE_CLAUDEAI_MCP_SERVERS` non li disattivi
* **Default**: `false`, quindi Claude Code recupera i tuoi connettori
* **Per-session overrides**: [`ENABLE_CLAUDEAI_MCP_SERVERS`](https://code.claude.com/docs/it/env-vars) impostato su `false` disattiva i connettori per una sessione; qualunque dei due li disattivi, l'altro non può riattivarli

```json settings.json theme={null}
{
  "disableClaudeAiConnectors": true
}
```

I server che passi esplicitamente con `--mcp-config` non sono interessati. Per bloccare i singoli connettori invece di tutti, usa [`deniedMcpServers`](#deniedmcpservers). Vedere [Disattivare i connettori claude.ai](https://code.claude.com/docs/it/mcp.md#disable-claude-ai-connectors).

### `disabledMcpjsonServers`

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

* **Scope**: [`Any file`](#scopes)
* **Type**: array di stringhe, i nomi dei server come appaiono in `.mcp.json`
* **Default**: non impostato

```json settings.json theme={null}
{
  "disabledMcpjsonServers": ["filesystem"]
}
```

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

### `enableAllProjectMcpServers`

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

* **Scope**: [`Any file`](#scopes). In una cartella la cui finestra di dialogo di fiducia non hai accettato, Claude Code la onora dalle impostazioni utente, impostazioni gestite e `--settings` e la ignora nel file di progetto condiviso, sia nella sessione che per `claude mcp list` e `claude mcp get`; [Approvazioni dei server di progetto e fiducia dell'area di lavoro](https://code.claude.com/docs/it/mcp.md#project-server-approvals-and-workspace-trust) dice quando un `.claude/settings.local.json` non tracciato conta anche.
* **Type**: Boolean
  * `true`: Claude Code approva ogni server MCP definito nei file `.mcp.json` del progetto senza un prompt
  * `false`: Claude Code ti chiede di approvare ogni server. In una cartella attendibile, un `false` in un file con precedenza più alta sovrascrive un `true` in uno inferiore; in una cartella che non hai attendibile, un `true` in qualsiasi file onorato è sufficiente
* **Default**: non impostato, quindi Claude Code ti chiede di approvare ogni server

```json settings.json theme={null}
{
  "enableAllProjectMcpServers": true
}
```

Una voce [`disabledMcpjsonServers`](#disabledmcpjsonservers) rifiuta comunque un server.

### `enabledMcpjsonServers`

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

* **Scope**: [`Any file`](#scopes). In una cartella la cui finestra di dialogo di fiducia non hai accettato, Claude Code la onora dalle impostazioni utente, impostazioni gestite e `--settings` e la ignora nel file di progetto condiviso, sia nella sessione che per `claude mcp list` e `claude mcp get`; [Approvazioni dei server di progetto e fiducia dell'area di lavoro](https://code.claude.com/docs/it/mcp.md#project-server-approvals-and-workspace-trust) dice quando un `.claude/settings.local.json` non tracciato conta anche.
* **Type**: array di stringhe, i nomi dei server come appaiono in `.mcp.json`
* **Default**: non impostato

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

```json settings.json theme={null}
{
  "enabledMcpjsonServers": ["memory", "github"]
}
```

Una voce [`disabledMcpjsonServers`](#disabledmcpjsonservers) rifiuta comunque un server.

### `managedMcpServers`

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

* **Scope**: [`Managed`](#scopes). Claude Code elimina la chiave con un avviso nelle impostazioni utente, progetto e locale e non la legge nella scheda Code dell'app Claude Desktop su una distribuzione di terze parti o nelle sessioni Cowork dell'app, dove Claude Desktop fornisce e blocca i server MCP di quelle sessioni stesso.
* **Type**: oggetto con chiave per nome del server. Ogni voce ha la forma `.mcp.json` per un server `http` o `sse`: un `url` `https://` obbligatorio e facoltativamente `headers`, `oauth` e le altre opzioni HTTP e SSE. Claude Code elimina le voci che non superano la convalida e [Cosa può contenere una voce](https://code.claude.com/docs/it/managed-mcp.md#what-an-entry-can-contain) elenca le condizioni
* **Default**: non impostato, quindi le impostazioni gestite non forniscono server

Questo esempio fornisce un server HTTP denominato `search`:

```json managed-settings.json theme={null}
{
  "managedMcpServers": {
    "search": {
      "type": "http",
      "url": "https://search.example.com/mcp"
    }
  }
}
```

Per la precedenza, come i server forniti si combinano con `managed-mcp.json` e gli elenchi di autorizzazione e negazione, e cosa vedono gli utenti, vedere [Fornire server tramite impostazioni gestite](https://code.claude.com/docs/it/managed-mcp.md#provide-servers-through-managed-settings).

## Agenti, sessioni e worktree

Imposta l'agente predefinito, controlla i compagni di squadra e la messaggistica tra sessioni, e configura i worktree. Consulta [Subagent](https://code.claude.com/docs/it/sub-agents.md) e [Worktree](https://code.claude.com/docs/it/worktrees.md).

### `agent`

Esegui il thread principale come un [subagent](https://code.claude.com/docs/it/sub-agents.md#invoke-subagents-explicitly) denominato, in modo che Claude Code applichi il prompt di sistema, le restrizioni degli strumenti e il modello di quel subagent alla tua sessione. La stessa chiave imposta l'agente predefinito per le sessioni che avvii da `claude agents`.

* **Scope**: [`Any file`](#scopes)
* **Type**: string, il nome di un agente integrato o personalizzato
* **Default**: non impostato, quindi il thread principale viene eseguito come agente predefinito di Claude Code
* **Per-session overrides**: `--agent` ha la precedenza su questa chiave per una sessione

```json settings.json theme={null}
{
  "agent": "code-reviewer"
}
```

Anche il `settings.json` di un plugin può fornire questa chiave; consulta [Ship default settings with your plugin](https://code.claude.com/docs/it/plugins/components.md#default-settings).

### `crossSessionInbound`

Scegli cosa fa questa sessione con i [messaggi provenienti dalle tue altre sessioni di Claude Code](https://code.claude.com/docs/it/cross-session-messaging.md#control-inbound-messages). Quando nessun valore si applica, Claude Code decide per ogni messaggio in base alle classi di modalità di permesso delle due sessioni. Richiede Claude Code v2.1.224 o successivo.

* **Scope**: [`Any file`](#scopes). Un valore di progetto o locale si applica solo quando è più rigoroso del valore fornito dalle impostazioni gestite, dal flag `--settings` o dalle impostazioni utente.
* **Type**: string, uno tra:
  * `"accept"`: Claude Code consegna il messaggio a Claude
  * `"hold"`: Claude Code mostra un avviso per il messaggio senza consegnarlo
  * `"refuse"`: Claude Code scarta il messaggio
* **Default**: non impostato, quindi Claude Code decide per ogni messaggio

```json settings.json theme={null}
{
  "crossSessionInbound": "hold"
}
```

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

Claude Code [mostra un avviso](https://code.claude.com/docs/it/errors.md#crosssessioninbound-must-be-one-of-accept-hold-refuse) quando imposti un valore che non riconosce. Finché quel valore è presente in un file utente, di progetto, locale o `--settings`, Claude Code trattiene i messaggi in entrata, anche quando una fonte che ha la precedenza imposta `accept`. Un `refuse` impostato da un'altra fonte si applica comunque. Correggi o rimuovi il valore per eliminare la sospensione.

Quando il valore non riconosciuto si trova nelle [impostazioni gestite](https://code.claude.com/docs/it/managed-settings.md), Claude Code lo tratta invece come `refuse` finché un amministratore non lo corregge. Prima della v2.1.248, Claude Code ignorava un valore non riconosciuto senza avvisare.

### `disableAgentView`

Disattiva gli [agenti in background e la visualizzazione agenti](https://code.claude.com/docs/it/agent-view.md): `claude agents`, `--bg`, `/background` e il supervisore su richiesta. Impostalo nelle [impostazioni gestite](https://code.claude.com/docs/it/managed-settings.md) per applicarlo a un'organizzazione.

* **Scope**: [`Any file`](#scopes)
* **Type**: Boolean
  * `true`: Claude Code disattiva `claude agents`, `--bg`, `/background` e il supervisore su richiesta
  * `false`: la visualizzazione agenti è disponibile
* **Default**: non impostato, quindi la visualizzazione agenti è disponibile
* **Per-session overrides**: [`CLAUDE_CODE_DISABLE_AGENT_VIEW`](https://code.claude.com/docs/it/env-vars) disattiva la visualizzazione agenti per una sessione; qualunque dei due la disattivi, l'altro non può riattivarla

```json settings.json theme={null}
{
  "disableAgentView": true
}
```

### `isolatePeerMachines`

Richiedi la tua approvazione esplicita prima che il `SendMessage` di Claude raggiunga una delle tue sessioni oltre questa macchina; consulta [Require approval for cross-machine messages](https://code.claude.com/docs/it/cross-session-messaging.md#require-approval-for-cross-machine-messages). La richiesta di approvazione appare anche nella [modalità `bypassPermissions`](https://code.claude.com/docs/it/permission-modes#skip-all-checks-with-bypasspermissions-mode).

* **Scope**: [`Any file`](#scopes). Un `true` da qualsiasi ambito si applica, quindi un file di progetto sottoposto a commit può attivare il requisito ma non disattivarlo.
* **Type**: Boolean
  * `true`: Claude Code chiede la tua approvazione prima che il `SendMessage` di Claude raggiunga una delle tue sessioni oltre questa macchina
  * `false`: i messaggi tra macchine non chiedono conferma
* **Default**: non impostato, quindi i messaggi tra macchine non chiedono conferma

```json settings.json theme={null}
{
  "isolatePeerMachines": true
}
```

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

### `processWrapper`

Su macOS e Linux, anteponi un comando di avvio aziendale ai [processi in background che Claude Code avvia](https://code.claude.com/docs/it/corporate-launcher.md#what-the-launcher-covers). Claude Code esegue il launcher aggiungendo la propria riga di comando, quindi il launcher deve eseguire Claude Code tramite exec; consulta [Run Claude Code behind a corporate launcher](https://code.claude.com/docs/it/corporate-launcher.md) per il contratto del launcher. Richiede Claude Code v2.1.210 o successivo.

* **Scope**: [`User or managed`](#scopes)
* **Type**: string, il comando del launcher come prefisso argv, ad esempio un percorso assoluto con argomenti facoltativi
* **Default**: non impostato, quindi i processi in background si avviano senza wrapper
* **Per-session overrides**: [`CLAUDE_CODE_PROCESS_WRAPPER`](https://code.claude.com/docs/it/env-vars) ha la precedenza su questa chiave per una sessione

```json settings.json theme={null}
{
  "processWrapper": "/opt/corp/launcher --profile claude"
}
```

Claude Code ignora il launcher su Windows e avvia ogni processo senza wrapper. Richiede Claude Code v2.1.210 o successivo.

### `teammateMode`

Scegli dove Claude Code mostra i compagni di squadra del [team di agenti](https://code.claude.com/docs/it/agent-teams.md): all'interno del riquadro principale del terminale, o in riquadri divisi quando il tuo terminale li supporta. Consulta [Choose a display mode](https://code.claude.com/docs/it/agent-teams.md#choose-a-display-mode).

* **Scope**: [`Any file`](#scopes). Claude Code legge anche un valore lasciato in `~/.claude.json` da versioni precedenti.
* **Type**: string, uno tra:
  * `"in-process"`: i compagni di squadra vengono eseguiti all'interno del riquadro principale del terminale
  * `"auto"`: riquadri divisi quando esegui all'interno di tmux, o all'interno di iTerm2 con `it2` nel tuo `PATH` o tmux installato; altrimenti in-process
  * `"tmux"`: riquadri divisi tramite tmux o iTerm2, rilevati dal tuo terminale
  * `"iterm2"`: riquadri divisi nativi di iTerm2 tramite la CLI `it2`
* **Default**: `"in-process"`
* **Per-session overrides**: `--teammate-mode` ha la precedenza su questa chiave per una sessione

```json settings.json theme={null}
{
  "teammateMode": "auto"
}
```

### `worktree`

Configura come Claude Code crea e gestisce i [worktree git](https://code.claude.com/docs/it/worktrees.md) per `--worktree`, lo strumento `EnterWorktree` e i subagent isolati e le sessioni in background.

* **Scope**: [`Any file`](#scopes)
* **Type**: object con `baseRef`, `symlinkDirectories`, `sparsePaths` e `bgIsolation`
* **Default**: non impostato

Questo esempio crea i branch dei nuovi worktree a partire dal tuo `HEAD` corrente e crea un collegamento simbolico a `node_modules` in ognuno:

```json settings.json theme={null}
{
  "worktree": {
    "baseRef": "head",
    "symlinkDirectories": ["node_modules"]
  }
}
```

Per copiare file ignorati da git come `.env` nei nuovi worktree, aggiungi un [file `.worktreeinclude`](https://code.claude.com/docs/it/worktrees#copy-gitignored-files-into-worktrees) alla radice del progetto invece di un'impostazione.

### `worktree.baseRef`

Scegli da quale ref vengono creati i branch dei nuovi worktree. `"fresh"` crea il branch da `origin/<default-branch>` per un albero pulito che corrisponde al remoto; `"head"` crea il branch dal tuo `HEAD` locale corrente, quindi i commit non inviati e lo stato del branch di funzionalità sono presenti nel worktree.

* **Scope**: [`Any file`](#scopes)
* **Type**: string, uno tra:
  * `"fresh"`: i branch dei nuovi worktree vengono creati da `origin/<default-branch>`
  * `"head"`: i branch dei nuovi worktree vengono creati dal tuo `HEAD` locale corrente, inclusi i commit non inviati
* **Default**: `"fresh"`

```json settings.json theme={null}
{
  "worktree": {
    "baseRef": "head"
  }
}
```

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

### `worktree.symlinkDirectories`

Crea collegamenti simbolici alle directory del repository principale in ogni worktree, così da non duplicare directory di grandi dimensioni su disco.

* **Scope**: [`Any file`](#scopes)
* **Type**: array di strings, percorsi di directory relativi alla radice del repository
* **Default**: non impostato, quindi Claude Code non crea collegamenti simbolici ad alcuna directory

Questo esempio crea collegamenti simbolici a `node_modules` e `.cache` dal repository principale in ogni nuovo worktree:

```json settings.json theme={null}
{
  "worktree": {
    "symlinkDirectories": ["node_modules", ".cache"]
  }
}
```

### `worktree.sparsePaths`

Estrai solo le directory elencate in ogni worktree tramite git sparse-checkout. Claude Code scrive su disco solo quelle directory più i file a livello di radice, il che è più veloce nei monorepo di grandi dimensioni; consulta [Check out only the directories you need](https://code.claude.com/docs/it/large-codebases.md#check-out-only-the-directories-you-need).

* **Scope**: [`Any file`](#scopes)
* **Type**: array di strings, percorsi di directory relativi alla radice del repository
* **Default**: non impostato, quindi ogni worktree estrae l'intero albero

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

```json settings.json theme={null}
{
  "worktree": {
    "sparsePaths": ["packages/my-app", "shared/utils"]
  }
}
```

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

### `worktree.bgIsolation`

Scegli come le [sessioni in background](https://code.claude.com/docs/it/agent-view.md#how-file-edits-are-isolated) isolano le loro modifiche ai file. Se hai spostato una sessione in background con `←` o `/background`, quella sessione modifica i file sul posto indipendentemente dal valore di questa chiave. Con `"worktree"`, Claude Code blocca `Edit` e `Write` nel checkout principale finché la sessione non chiama `EnterWorktree`; con `"none"`, i job in background modificano direttamente la copia di lavoro. Imposta `"none"` per un repository in cui i worktree git non sono praticabili.

* **Scope**: [`Any file`](#scopes)
* **Type**: string, uno tra:
  * `"worktree"`: Claude Code blocca `Edit` e `Write` nel checkout principale finché la sessione non chiama `EnterWorktree`
  * `"none"`: i job in background modificano direttamente la copia di lavoro
* **Default**: `"worktree"`

```json settings.json theme={null}
{
  "worktree": {
    "bgIsolation": "none"
  }
}
```

Al di fuori di un repository git, un [hook `WorktreeCreate`](https://code.claude.com/docs/it/worktrees#non-git-version-control) che fallisce rimuove il blocco, così che la sessione possa modificare la directory di lavoro sul posto.

### `worktree.location`

Scegli la cartella su una macchina remota in cui le [sessioni SSH di Desktop](https://code.claude.com/docs/it/desktop.md#choose-where-ssh-session-worktrees-go) creano i loro worktree, invece di `<project-root>/.claude/worktrees/`. Solo l'app desktop legge questa chiave: `--worktree`, lo strumento `EnterWorktree`, i subagent isolati e le sessioni in background la ignorano. Richiede Claude Desktop v1.44121.0 o successivo.

* **Scope**: [`User`](#scopes), in `~/.claude/settings.json` sulla macchina remota
* **Type**: string, un percorso assoluto o uno che inizia con `~/`
* **Default**: non impostato, quindi i worktree vengono creati all'interno del progetto

Questo esempio imposta la cartella su `~/worktrees`:

```json settings.json theme={null}
{
  "worktree": {
    "location": "~/worktrees"
  }
}
```

Una **Worktree folder** impostata sulla connessione SSH in Desktop ha la precedenza. Se la tua organizzazione limita le cartelle che le sessioni possono usare, Desktop mantiene i worktree all'interno del progetto.

## Controllo remoto, desktop e notifiche

Configura il Controllo remoto, gli ambienti cloud, l'app desktop e le notifiche che Claude Code invia quando ha bisogno di te. Vedi [Controllo remoto](https://code.claude.com/docs/it/remote-control.md).

### `agentPushNotifEnabled`

Consenti a Claude di inviare una notifica push al tuo telefono quando decide che ne vale la pena, ad esempio quando un'attività lunga si conclude. Claude può inviarne una mentre [Remote Control](https://code.claude.com/docs/it/remote-control.md) è connesso. Appare in `/config` come **Push quando Claude decide**. Quando lo modifichi lì, Claude Code salva anche il valore nel tuo account.

* **Scope**: [`Any file`](#scopes). Claude Code legge anche un valore lasciato in `~/.claude.json` da versioni precedenti.
* **Type**: Boolean
  * `true`: Claude può inviare una notifica push al tuo telefono quando decide che ne vale la pena
  * `false`: Claude non invia quelle notifiche
* **Default**: `false`

```json settings.json theme={null}
{
  "agentPushNotifEnabled": true
}
```

Se esegui sessioni sotto un server [`claude remote-control`](https://code.claude.com/docs/it/remote-control#start-a-remote-control-session), queste seguono il valore salvato nel tuo account anziché questa chiave. Per modificare quel valore, esegui `/config` in una sessione di Claude Code nel tuo terminale e attiva o disattiva **Push quando Claude decide**. Se l'interruttore mostra già il valore che desideri, modificalo e poi ripristinalo in modo che Claude Code salvi quel valore nel tuo account.

Vedi [Notifiche push mobile](https://code.claude.com/docs/it/remote-control.md#mobile-push-notifications).

### `awaySummaryEnabled`

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

* **Scope**: [`Any file`](#scopes)
* **Type**: Boolean
  * `true`: vedi un riepilogo di una riga della sessione quando torni dopo alcuni minuti di assenza
  * `false`: Claude Code non mostra alcun riepilogo
* **Default**: non impostato, quindi il riepilogo è attivo
* **Per-session overrides**: [`CLAUDE_CODE_ENABLE_AWAY_SUMMARY`](https://code.claude.com/docs/it/env-vars) ha la precedenza su questa chiave per una sessione, in entrambe le direzioni

```json settings.json theme={null}
{
  "awaySummaryEnabled": false
}
```

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

### `disableArtifact`

> [!WARNING]
>
> Deprecato e sostituito da [`enableArtifact`](#enableartifact). Claude Code onora ancora `disableArtifact: true` come equivalente a `enableArtifact: false` e ignora `disableArtifact: false`.

Usa [`enableArtifact`](#enableartifact) invece per disattivare lo strumento [Artifact](https://code.claude.com/docs/it/artifacts.md), che pubblica l'output della sessione come pagina web privata su claude.ai. Quando disattivi la riga **Artifacts** in `/config`, Claude Code scrive `enableArtifact` nelle tue impostazioni utente e cancella questa chiave.

* **Scope**: [`Any file`](#scopes)
* **Type**: Boolean
  * `true`: Claude Code disattiva lo strumento Artifact per ogni sessione a cui il file si applica e nessun altro file lo riattiva
  * `false`: ignorato; per lasciare lo strumento attivo, rimuovi la chiave
* **Default**: non impostato, quindi lo strumento segue la [disponibilità](https://code.claude.com/docs/it/artifacts.md#availability) del tuo account
* **Per-session overrides**: [`CLAUDE_CODE_DISABLE_ARTIFACT`](https://code.claude.com/docs/it/env-vars) impostato su `1` disattiva lo strumento per una sessione

```json settings.json theme={null}
{
  "disableArtifact": true
}
```

[Disabilita artefatti](https://code.claude.com/docs/it/artifacts.md#disable-artifacts) elenca ogni modo per disattivare lo strumento.

### `disableDeepLinkRegistration`

Impedisci a Claude Code di registrare il gestore del protocollo `claude-cli://` con il sistema operativo, che altrimenti fa dopo che invii il primo prompt di una sessione interattiva. I [Deep link](https://code.claude.com/docs/it/deep-links.md) consentono agli strumenti esterni di aprire una sessione Claude Code con un prompt precompilato. Impostalo in ambienti in cui la registrazione del gestore del protocollo è limitata o gestita separatamente.

* **Scope**: [`Any file`](#scopes)
* **Type**: la stringa `"disable"`
* **Default**: non impostato, quindi Claude Code registra il gestore

```json settings.json theme={null}
{
  "disableDeepLinkRegistration": "disable"
}
```

### `disableDesktopLocalSessions`

Disattiva le sessioni Code che vengono eseguite sul dispositivo nell'[app desktop](https://code.claude.com/docs/it/desktop.md#local-sessions-on-managed-devices), per distribuzioni in cui gli sviluppatori dovrebbero lavorare su macchine remote tramite SSH. Con la chiave impostata su `true`, gli utenti vedono quanto segue nella scheda Code:

* **Selettore dell'ambiente**: la voce per il computer dell'utente è disattivata e non selezionabile, con il tooltip **Disabled by your organization**. Su Windows la voce WSL è disattivata allo stesso modo, anche se l'esecuzione delle sessioni WSL su un dispositivo gestito è [governata separatamente](https://code.claude.com/docs/it/admin-setup.md#wsl-sessions-in-claude-code-desktop).
* **Nuove sessioni**: usano per impostazione predefinita la prima [connessione SSH](https://code.claude.com/docs/it/desktop.md#ssh-sessions), se ne è configurata una
* **Sessioni sul dispositivo**: l'app rifiuta di avviare o riprendere una sessione sul dispositivo, inclusa una connessione SSH verso la stessa macchina
* **Sessioni SSH verso altri host e sessioni cloud**: non interessate

L'app desktop legge questa chiave; la CLI del terminale la ignora. Richiede Claude Desktop v1.37937.0 o successivo.

* **Scope**: [`Managed`](#scopes). Per impostazione predefinita, l'app desktop legge la chiave da [una sola origine gestita](https://code.claude.com/docs/it/managed-settings.md#how-claude-code-combines-managed-sources).
* **Type**: Boolean; solo il Boolean JSON `true` ha effetto
  * `true`: l'app desktop non offre sessioni Code on-device; le sessioni locali esistenti rimangono elencate ma non possono continuare
  * `false`: le sessioni locali rimangono disponibili
* **Default**: non impostato, quindi le sessioni locali sono disponibili

```json managed-settings.json theme={null}
{
  "disableDesktopLocalSessions": true
}
```

L'app desktop ignora qualsiasi altro valore e un valore che non è un Boolean, come la stringa `"true"` o `1`, registra anche un avviso. Abbinalo a [`sshConfigs`](#sshconfigs) in modo che gli utenti si trovino su una connessione funzionante e con [`sshHostAllowlist`](#sshhostallowlist) per limitare quali host possono raggiungere. Vedi [Sessioni locali su dispositivi gestiti](https://code.claude.com/docs/it/desktop.md#local-sessions-on-managed-devices).

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

### `disableRemoteControl`

Disattiva il [Controllo remoto](https://code.claude.com/docs/it/remote-control.md): Claude Code rifiuta quindi `claude remote-control`, il flag `--remote-control`, l'avvio automatico e l'interruttore in-sessione e segnala che la policy della tua organizzazione lo ha disabilitato. Posizionalo nelle [impostazioni gestite](https://code.claude.com/docs/it/managed-settings.md) per l'applicazione MDM per dispositivo.

* **Scope**: [`Any file`](#scopes)
* **Type**: Boolean
  * `true`: Claude Code rifiuta `claude remote-control`, il flag `--remote-control`, l'avvio automatico e l'interruttore in-sessione
  * `false`: il Controllo remoto rimane disponibile
* **Default**: `false`

```json settings.json theme={null}
{
  "disableRemoteControl": true
}
```

### `enableArtifact`

Disattiva lo strumento [Artifact](https://code.claude.com/docs/it/artifacts.md), che pubblica l'output della sessione come pagina web privata su claude.ai. Quando disattivi la riga **Artifacts** in `/config`, Claude Code scrive questa chiave nelle tue impostazioni utente, quindi di solito non la modifichi manualmente.

* **Scope**: [`Any file`](#scopes). Ogni file può disattivare lo strumento e nessuno può riattivarlo.
* **Type**: Boolean
  * `false`: Claude Code disattiva lo strumento Artifact per ogni sessione a cui il file si applica
  * `true`: lo stesso di lasciare la chiave non impostata, perché non sovrascrive mai un `false` da un altro file, da [`CLAUDE_CODE_DISABLE_ARTIFACT`](https://code.claude.com/docs/it/env-vars) o dall'[impostazione amministratore](https://code.claude.com/docs/it/artifacts.md#manage-artifacts-for-your-organization) della tua organizzazione
* **Default**: non impostato, quindi lo strumento segue la [disponibilità](https://code.claude.com/docs/it/artifacts.md#availability) del tuo account

```json settings.json theme={null}
{
  "enableArtifact": false
}
```

Mentre un'origine diversa dalle tue impostazioni utente mantiene lo strumento disattivato, Claude Code nasconde la riga **Artifacts** in `/config`, perché attivarlo lì non cambierebbe nulla. [Disabilita artefatti](https://code.claude.com/docs/it/artifacts.md#disable-artifacts) elenca ogni modo per disattivare lo strumento.

### `inputNeededNotifEnabled`

Ricevi una notifica push sul tuo telefono quando un prompt di autorizzazione o una domanda è in attesa del tuo input. Claude Code invia questi solo mentre il [Controllo remoto](https://code.claude.com/docs/it/remote-control.md) è connesso. Appare in `/config` come **Push quando azioni richieste**.

* **Scope**: [`Any file`](#scopes). Claude Code legge anche un valore lasciato in `~/.claude.json` da versioni precedenti.
* **Type**: Boolean
  * `true`: ricevi una notifica push sul tuo telefono quando un prompt di autorizzazione o una domanda è in attesa, mentre il Controllo remoto è connesso
  * `false`: Claude Code non invia tali notifiche
* **Default**: `false`

```json settings.json theme={null}
{
  "inputNeededNotifEnabled": true
}
```

Vedi [Notifiche push mobile](https://code.claude.com/docs/it/remote-control.md#mobile-push-notifications).

### `preferredNotifChannel`

Scegli come Claude Code ti avvisa quando un'attività si completa o una richiesta di permesso è in attesa. Le [notifiche di un mod](https://code.claude.com/docs/it/plugins/mods/api.md#show-something-without-starting-a-turn) usano la stessa impostazione. Appare in `/config` come **Local notifications**.

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

```json settings.json theme={null}
{
  "preferredNotifChannel": "terminal_bell"
}
```

Con `"auto"`, Claude Code invia una notifica desktop in iTerm2, Ghostty e Kitty. In Terminal.app suona il carattere campanello solo quando hai disattivato il campanello udibile di Terminal e in altri terminali non fa nulla. Imposta `"terminal_bell"` per suonare il carattere campanello in qualsiasi terminale. Vedi [Ottieni un campanello terminale o una notifica](https://code.claude.com/docs/it/terminal-config.md#get-a-terminal-bell-or-notification).

### `remote.defaultEnvironmentId`

Scegli l'[ambiente cloud](https://code.claude.com/docs/it/cloud-environments.md) predefinito per le sessioni cloud che crei dalla CLI, come con `claude --cloud`. Claude Code scrive questa chiave nelle tue impostazioni utente quando scegli un ambiente con [`/remote-env`](https://code.claude.com/docs/it/cloud-environments#select-an-environment-from-the-cli).

* **Scope**: [`Any file`](#scopes). Per un ID ambiente self-hosted, impostazioni utente o gestite o il flag `--settings` solo.
* **Type**: stringa, un ID ambiente come `env_...` o `ccpool_...`
* **Default**: non impostato, quindi Claude Code utilizza l'ambiente ospitato da Anthropic quando il tuo elenco ne ha uno e altrimenti il primo ambiente nel tuo elenco che non è un'[ambiente ponte Controllo remoto](https://code.claude.com/docs/it/cloud-environments.md#the-default-environment), o il primo ambiente quando tutti sono ambienti ponte
* **Per-session overrides**: `--environment` ha la precedenza su questa chiave per la sessione cloud che crea

```json settings.json theme={null}
{
  "remote": {
    "defaultEnvironmentId": "env_0123abcd"
  }
}
```

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

### `remoteControlAtStartup`

Connetti il [Controllo remoto](https://code.claude.com/docs/it/remote-control.md) automaticamente quando ogni sessione interattiva inizia, invece di aspettare `/remote-control`. Impostalo su `true` per attivare la connessione automatica, `false` per disattivarla. Appare in `/config` come **Abilita Controllo remoto per tutte le sessioni**.

* **Scope**: [`Any file`](#scopes). Claude Code legge anche un valore lasciato in `~/.claude.json` da versioni precedenti.
* **Type**: Boolean
  * `true`: Claude Code connette il Controllo remoto automaticamente quando ogni sessione interattiva inizia
  * `false`: Claude Code aspetta `/remote-control`
* **Default**: non impostato, quindi l'[auto-connect default](https://code.claude.com/docs/it/remote-control.md#enable-remote-control-for-all-sessions) si applica
* **Per-session overrides**: `--remote-control` attiva il Controllo remoto per una sessione anche quando questa chiave è `false` e nessun flag lo disattiva per una sessione

```json settings.json theme={null}
{
  "remoteControlAtStartup": true
}
```

Claude Code ignora un `true` dalle impostazioni di progetto o locali, quindi un repository può disattivare la connessione automatica per il suo checkout ma non può attivarla. Per il comportamento completo per scope, vedi [Abilita Controllo remoto per tutte le sessioni](https://code.claude.com/docs/it/remote-control.md#enable-remote-control-for-all-sessions) e le [chiavi di sicurezza in cui il valore più rigoroso si applica](https://code.claude.com/docs/it/settings.md#security-keys-where-the-stricter-value-applies).

### `sshConfigs`

Aggiungi connessioni SSH al selettore dell'ambiente di [Desktop](https://code.claude.com/docs/it/desktop.md#pre-configure-ssh-connections-for-your-team). Gli amministratori usano `sshConfigs` per distribuire connessioni condivise a un team. Gli utenti possono selezionare una connessione gestita e [impostare la propria **Worktree folder**](https://code.claude.com/docs/it/desktop.md#set-the-worktree-folder-on-an-existing-connection) per essa. Non possono modificarne gli altri campi né eliminarla nell'app.

* **Scope**: [`User or managed`](#scopes). L'app desktop legge questa chiave. Per impostazione predefinita, legge le connessioni gestite da [una sola origine gestita](https://code.claude.com/docs/it/managed-settings.md#how-claude-code-combines-managed-sources).
* **Type**: array di oggetti, ognuno con `id`, `name` e `sshHost` obbligatori e `sshPort` e `sshIdentityFile` opzionali
* **Default**: non impostato

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

```json settings.json theme={null}
{
  "sshConfigs": [
    {
      "id": "dev-vm",
      "name": "Dev VM",
      "sshHost": "user@dev.example.com"
    }
  ]
}
```

### `sshHostAllowlist`

Limita gli host a cui una [sessione SSH Desktop](https://code.claude.com/docs/it/desktop.md#restrict-which-ssh-hosts-users-can-connect-to) può connettersi. Solo l'app Desktop legge questa chiave; il CLI non lo fa. I pattern sono case-insensitive: `*` corrisponde a qualsiasi host, `*.example.com` corrisponde a `example.com` e a ogni sottodominio e qualsiasi altra cosa è una corrispondenza esatta rispetto al nome host dopo la risoluzione di `~/.ssh/config`. Un array vuoto disattiva le sessioni SSH.

Con Claude Desktop v3.1623.0 o successivo, anche i [jump host](https://code.claude.com/docs/it/desktop.md#allow-jump-hosts) di una sessione devono corrispondere a un pattern.

* **Scope**: [`Managed`](#scopes). Per impostazione predefinita, Desktop legge la chiave da [una sola origine gestita](https://code.claude.com/docs/it/managed-settings.md#how-claude-code-combines-managed-sources).
* **Type**: array di pattern di nome host
* **Default**: non impostato, quindi qualsiasi host è consentito

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

```json managed-settings.json theme={null}
{
  "sshHostAllowlist": ["*.devboxes.example.com", "bastion.example.com"]
}
```

Un valore che Desktop non riesce a leggere come elenco di host, come `true` o un oggetto, viene considerato un array vuoto finché non lo correggi, tranne `null`, che viene considerato non impostato. Richiede Claude Desktop v2.26454.0 o successivo.

Se imposti [`managedSourcesBehavior`](#managedsourcesbehavior) su `"merge"` nella tua origine con la priorità più alta, Desktop combina gli elenchi di ogni [origine di amministrazione](https://code.claude.com/docs/it/managed-settings.md#how-claude-code-combines-managed-sources) e consente un host che corrisponde a uno qualsiasi di essi. Se imposti un array vuoto in un'origine, le sessioni SSH restano attive per gli host elencati da un'altra origine.

### `sshHostCommands`

Aggiungi al selettore dell'ambiente di [Desktop](https://code.claude.com/docs/it/desktop.md#create-an-ssh-connection-from-a-command) connessioni SSH il cui host proviene da un comando. Quando crei una connessione o ne sostituisci l'host, Desktop esegue il comando della voce sul tuo computer e si connette all'host che il comando stampa. Richiede Claude Desktop v3.6556.0 o successivo su macOS o Linux, con accesso effettuato con un account Claude.

* **Scope**: [`User or managed`](#scopes). Solo l'app desktop legge questa chiave. Legge le voci gestite da [un solo file di impostazioni gestite o policy MDM](https://code.claude.com/docs/it/desktop.md#distribute-commands-to-your-team) sul computer e ignora la chiave nelle [impostazioni gestite dal server](https://code.claude.com/docs/it/server-managed-settings.md).
* **Type**: array di oggetti, ognuno con `id`, `name` e `command` obbligatori e `sshIdentityFile` e `startDirectory` opzionali. Desktop avvia `command` senza una shell, quindi [scrivilo come programma e argomenti semplici](https://code.claude.com/docs/it/desktop.md#write-the-command).
* **Default**: non impostato

Questo esempio aggiunge una connessione denominata `Dev box`, dove `acme-dev create` rappresenta il tuo strumento:

```json settings.json theme={null}
{
  "sshHostCommands": [
    {
      "id": "devbox",
      "name": "Dev box",
      "command": "acme-dev create"
    }
  ]
}
```

Prima di Claude Code v2.1.307, lo strumento Edit rifiutava una modifica che aggiungeva questa chiave a un file di impostazioni valido, con l'errore `Unrecognized field: sshHostCommands`. In quelle versioni, aggiungi invece la chiave con un editor di testo; Claude Code carica un file che contiene la chiave. In Desktop, la versione che conta è la [versione di Claude Code della scheda Code](https://code.claude.com/docs/it/desktop.md#claude-code-version-in-the-code-tab), non quella del tuo terminale.

## Autenticazione e provider

Fornisci credenziali tramite script helper e, per le organizzazioni, forza un metodo di accesso o un'organizzazione. Vedi [Autenticazione](https://code.claude.com/docs/it/authentication.md).

### `allowedProviders`

Elenca i servizi attraverso i quali una macchina può raggiungere Claude, come l'API Anthropic, Amazon Bedrock, o un gateway LLM. Una sessione su un provider non elencato viene rifiutata all'avvio, al login e quando contatta successivamente l'API, quindi anche il passaggio a un provider non elencato durante la sessione viene rifiutato. Il [messaggio di rifiuto](https://code.claude.com/docs/it/errors.md#managed-settings-dont-allow-this-api-provider) nomina ciò che ha selezionato il provider e i passaggi per continuare. Richiede Claude Code v2.1.285 o successivo.

* **Scope**: [`Managed`](#scopes). Un elenco che le fonti admin della macchina stessa impostano, le policy MDM e i file di impostazioni gestite, continua ad applicarsi quando le impostazioni gestite dal server forniscono anche uno: una sessione può quindi utilizzare solo i provider su entrambi gli elenchi, quindi un elenco gestito dal server può restringere ciò che la macchina consente ma mai ampliarlo. Quale `allowedProviders` della fonte della macchina conta segue [come Claude Code combina le fonti gestite](https://code.claude.com/docs/it/managed-settings.md#how-claude-code-combines-managed-sources). Un elenco fornito solo tramite impostazioni gestite dal server raggiunge solo le sessioni che [recuperano impostazioni gestite dal server](https://code.claude.com/docs/it/server-managed-settings.md#platform-availability).
* **Type**: array di stringhe, ognuna di:
  * `"anthropic"`: l'API Anthropic su host proprio di Anthropic, tramite un accesso claude.ai o Console o una chiave API. Abbinalo a [`forceLoginMethod`](#forceloginmethod) o [`forceLoginOrgUUID`](#forceloginorguuid) per limitare anche l'accesso
  * `"bedrock"`: [Amazon Bedrock](https://code.claude.com/docs/it/amazon-bedrock.md)
  * `"vertex"`: [Google Cloud's Agent Platform](https://code.claude.com/docs/it/google-vertex-ai.md), precedentemente Vertex AI
  * `"foundry"`: [Microsoft Foundry](https://code.claude.com/docs/it/microsoft-foundry.md)
  * `"anthropicAws"`: [Claude Platform on AWS](https://code.claude.com/docs/it/claude-platform-on-aws.md)
  * `"mantle"`: l'[endpoint Mantle](https://code.claude.com/docs/it/amazon-bedrock.md#use-the-mantle-endpoint) di Amazon Bedrock. Una sessione che [esegue Mantle insieme all'API Invoke](https://code.claude.com/docs/it/amazon-bedrock.md#run-mantle-alongside-the-invoke-api) utilizza entrambi i provider, quindi elenca `"bedrock"` e `"mantle"` insieme per essa
  * `"customEndpoint"`: l'API Anthropic o l'API di un provider cloud inviata a un altro host, come un [gateway LLM](https://code.claude.com/docs/it/llm-gateway) denominato da `ANTHROPIC_BASE_URL` o dalla variabile di endpoint di un provider come `ANTHROPIC_BEDROCK_BASE_URL`. Claude Code lo ammette solo per il valore esatto che un blocco [`env`](#env) gestito fissa
  * `"gateway"`: un accesso [Cloud gateway](https://code.claude.com/docs/it/claude-apps-gateway)
* **Default**: non impostato, quindi qualsiasi provider può essere utilizzato

```json managed-settings.json theme={null}
{
  "allowedProviders": ["anthropic", "bedrock"]
}
```

La voce di ogni provider cloud significa il servizio proprio di quel provider, inclusi i suoi endpoint regionali, FIPS e privati.

Una voce che Claude Code non riconosce come nome di provider viene eliminata e segnalata, e il resto dell'elenco rimane applicato. Con un elenco vuoto, o uno le cui voci sono tutte non riconosciute, Claude Code rifiuta ogni provider e non si avvia sulla macchina.

#### Endpoint che necessitano di un pin in `env` gestito

Un pin è il valore di una variabile di endpoint impostato in un blocco [`env`](#env) gestito. Quando una sessione invia il traffico di un provider da qualche parte diversa dal servizio proprio di quel provider, Claude Code lo ammette solo se il valore della sessione è lo stesso del pin. Questi endpoint ne hanno bisogno:

* **Sessioni `"customEndpoint"`**: la variabile che nomina l'host, come `ANTHROPIC_BASE_URL`
* **Amazon Bedrock**: le variabili `AWS_ENDPOINT_URL`, `AWS_ENDPOINT_URL_BEDROCK` e `AWS_ENDPOINT_URL_BEDROCK_RUNTIME` dell'SDK AWS quando puntano al di fuori del servizio proprio di Bedrock. La sessione rimane sotto `"bedrock"` piuttosto che `"customEndpoint"`
* **L'URL di accesso di un gateway**: la sessione rimane sotto `"gateway"`, e [`forceLoginGatewayUrl`](#forcelogingatewayurl) conta anche come il pin

Quali blocchi `env` contano come pin dipende da dove è impostato l'elenco:

* **Una fonte amministratore sulla macchina imposta un elenco**: solo i blocchi `env` delle fonti amministratore della macchina stessa contano
* **Solo le impostazioni gestite dal server impostano un elenco**: un valore `env` in quelle impostazioni gestite dal server conta anche

L'elenco non giudica le variabili di credenziale e tenancy di un provider cloud o il percorso di rete, come `HTTPS_PROXY` e le impostazioni di certificato. Impostale per la flotta nel blocco `env` gestito.

### `apiKeyHelper`

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

* **Scope**: [`Any file`](#scopes)
* **Type**: string, una riga di comando shell
* **Default**: non impostato, quindi Claude Code non esegue un helper

```json settings.json theme={null}
{
  "apiKeyHelper": "/bin/generate_temp_api_key.sh"
}
```

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

* Dopo la durata della cache, cinque minuti per impostazione predefinita o l'intervallo che imposti con [`CLAUDE_CODE_API_KEY_HELPER_TTL_MS`](https://code.claude.com/docs/it/env-vars).
* Quando una richiesta all'API Anthropic, direttamente o tramite un [gateway LLM](https://code.claude.com/docs/it/llm-gateway), fallisce con `401` o `403`.
* Prima di inviare una richiesta all'API Anthropic, direttamente o tramite un gateway LLM, quando l'output memorizzato nella cache è un JWT scaduto dopo che l'helper lo ha prodotto. Richiede Claude Code v2.1.246 o successivo.

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

Nelle sessioni interattive, quando il comando proviene dalle impostazioni del progetto o locali, Claude Code non lo esegue finché non accetti il prompt di fiducia del workspace. Vedi [Gestione delle credenziali](https://code.claude.com/docs/it/authentication.md#credential-management).

### `awsAuthRefresh`

Esegui il tuo comando, come `aws sso login`, per aggiornare le credenziali nella tua directory `.aws` quando quelle che Claude Code ha per [Amazon Bedrock](https://code.claude.com/docs/it/amazon-bedrock.md) smettono di funzionare. Claude Code controlla prima le credenziali attuali rispetto a STS ed esegue il comando solo quando quel controllo fallisce, quindi legge la directory `.aws` aggiornata.

Quando il controllo fallisce contemporaneamente in più processi Claude Code che usano lo stesso comando e le stesse credenziali, come terminali separati o finestre dell'IDE, un processo esegue il comando e gli altri attendono quell'esecuzione invece di avviarne una propria. Un processo che ha atteso 60 secondi con una richiesta in sospeso esegue il comando da solo. Per disattivare questo comportamento, imposta [`CLAUDE_CODE_DISABLE_AUTH_REFRESH_LOCK`](https://code.claude.com/docs/it/env-vars) su `1`.

* **Scope**: [`Any file`](#scopes)
* **Type**: string, una riga di comando shell
* **Default**: non impostato, quindi Claude Code non aggiorna le credenziali AWS per te

```json settings.json theme={null}
{
  "awsAuthRefresh": "aws sso login --profile myprofile"
}
```

Usa questa chiave quando il tuo flusso di aggiornamento scrive in `.aws`; usa [`awsCredentialExport`](#awscredentialexport) quando stampa credenziali invece. Vedi [configurazione avanzata delle credenziali](https://code.claude.com/docs/it/amazon-bedrock.md#advanced-credential-configuration).

### `awsCredentialExport`

Esegui il tuo comando che stampa le credenziali AWS come JSON, in modo che Claude Code possa chiamare [Amazon Bedrock](https://code.claude.com/docs/it/amazon-bedrock.md) con credenziali che non vivono nella tua directory `.aws`. Claude Code accetta la forma di output `aws sts` e la forma piatta `aws configure export-credentials`, e limita le credenziali al suo client Bedrock, quindi i comandi shell che Claude esegue vedono ancora le tue credenziali ambientali.

* **Scope**: [`Any file`](#scopes)
* **Type**: string, una riga di comando shell
* **Default**: non impostato, quindi Claude Code utilizza la catena di credenziali AWS ambientale

```json settings.json theme={null}
{
  "awsCredentialExport": "/bin/generate_aws_grant.sh"
}
```

A differenza di [`awsAuthRefresh`](#awsauthrefresh), Claude Code esegue sempre questo comando quando è impostato, senza controllare prima le credenziali ambientali. Vedi [configurazione avanzata delle credenziali](https://code.claude.com/docs/it/amazon-bedrock.md#advanced-credential-configuration).

### `forceLoginMethod`

Limita il tipo di account con cui le persone possono accedere. Imposta `"claudeai"` per consentire solo account claude.ai, `"console"` per consentire solo account Claude Console, o `"gateway"` per inviare le persone a un [cloud gateway](https://code.claude.com/docs/it/claude-apps-gateway) invece di un accesso di prima parte. Gli amministratori lo impostano nelle impostazioni gestite e lo associano a [`forceLoginOrgUUID`](#forceloginorguuid) per mantenere gli accessi claude.ai degli sviluppatori all'interno di un'organizzazione. Se lo imposti su `"claudeai"` o `"console"` in qualsiasi file di impostazioni, Claude Code smette anche di offrire l'[accesso Console senza chiave](https://code.claude.com/docs/it/authentication.md#sign-in-without-an-api-key) nelle sessioni a cui si applica quel file.

* **Scope**: [`Any file`](#scopes). Claude Code onora `"gateway"` dalle stesse fonti di [`forceLoginGatewayUrl`](#forcelogingatewayurl) e lo tratta come non impostato ovunque altrove.
* **Type**: string, uno di:
  * `"claudeai"`: solo gli account claude.ai possono accedere
  * `"console"`: solo gli account Claude Console possono accedere
  * `"gateway"`: Claude Code invia le persone a un cloud gateway invece di un accesso di prima parte
* **Default**: non impostato, quindi le persone scelgono un metodo di accesso

```json settings.json theme={null}
{
  "forceLoginMethod": "claudeai"
}
```

Ogni percorso di accesso di prima parte applica la restrizione, inclusa l'[estensione VS Code](https://code.claude.com/docs/it/vs-code.md), l'Agent SDK, `claude setup-token`, e `/install-github-app`, ad eccezione della schermata di accesso interattiva del terminale, raggiunta da `/login` o dall'onboarding al primo avvio, che pre-seleziona il metodo senza applicarlo. Prima della v2.1.212, solo gli accessi al terminale lo applicavano. Vedi [Limita l'accesso alla tua organizzazione](https://code.claude.com/docs/it/authentication.md#restrict-login-to-your-organization) per come ogni percorso di accesso, le credenziali ambientali e i provider di terze parti vengono gestiti.

Quando una fonte gestita sulla macchina imposta `"gateway"`, Claude Code non utilizza un accesso residuo, una chiave API o una credenziale `apiKeyHelper`. Vedi [La policy dell'amministratore richiede un accesso Cloud gateway](https://code.claude.com/docs/it/errors.md#administrator-policy-requires-a-cloud-gateway-sign-in) per il messaggio che ognuno produce. Se selezioni un provider cloud tramite `CLAUDE_CODE_USE_BEDROCK` o una variabile d'ambiente simile, la sessione non ha bisogno dell'accesso al gateway. Prima della v2.1.261, Claude Code utilizzava un accesso residuo su queste macchine.

### `forceLoginGatewayUrl`

Imposta l'URL del gateway a cui si connette la schermata `/login` Cloud gateway, in modo che le persone raggiungano il tuo [cloud gateway](https://code.claude.com/docs/it/claude-apps-gateway) senza digitare il suo indirizzo. La schermata non ha un campo URL: con questa chiave impostata, mostra l'URL del tuo gateway e si connette quando la persona preme Invio; senza di essa, dice loro di contattare il loro amministratore IT.

Nelle impostazioni gestite, questa chiave o `forceLoginMethod: "gateway"` rende la macchina solo gateway, ad eccezione delle sessioni che selezionano un provider cloud con `CLAUDE_CODE_USE_*`. `/login` si apre quindi sulla schermata Cloud gateway senza un selettore di metodo di accesso. Vedi [La policy dell'amministratore richiede un accesso Cloud gateway](https://code.claude.com/docs/it/errors.md#administrator-policy-requires-a-cloud-gateway-sign-in) per cosa succede a un accesso di prima parte residuo o a una chiave API. Imposta entrambe le chiavi in modo che la schermata si connetta invece di mostrare un errore.

* **Scope**: [`User or managed`](#scopes). Letto da una fonte gestita sulla macchina: `managed-settings.json`, il plist macOS o il registro HKLM di Windows, o un helper di policy. Su una macchina che non ha nessuna di queste, Claude Code v2.1.295 o successivo lo legge anche dalle [impostazioni utente](https://code.claude.com/docs/it/claude-apps-gateway#set-the-gateway-url-in-user-settings). Claude Code lo ignora nelle impostazioni HKCU e gestite dal server.
* **Type**: string, un URL completo incluso lo schema
* **Default**: non impostato, quindi la schermata Cloud gateway mostra un errore che dice alle persone di contattare il loro amministratore IT

```json managed-settings.json theme={null}
{
  "forceLoginGatewayUrl": "https://claude-gateway.example.com"
}
```

Se il valore non è un URL valido, la schermata di accesso lo segnala e il resto del file di impostazioni gestite si applica comunque. Vedi [Imposta l'URL del gateway](https://code.claude.com/docs/it/claude-apps-gateway#set-the-gateway-url).

### `forceLoginOrgUUID`

Da una fonte gestita, richiedi che gli accessi dell'account claude.ai appartengano a un'organizzazione Anthropic, data come un singolo UUID, o a una qualsiasi di diverse organizzazioni, data come un array. Da qualsiasi file di impostazioni, Claude Code utilizza anche un singolo UUID per pre-selezionare quell'organizzazione durante un accesso claude.ai o Claude Console, e non pre-seleziona nulla per un array. Se imposti la chiave in qualsiasi file di impostazioni, Claude Code smette anche di offrire l'[accesso Console senza chiave](https://code.claude.com/docs/it/authentication.md#sign-in-without-an-api-key) nelle sessioni a cui si applica quel file e crea una chiave API invece.

* **Scope**: [`Any file`](#scopes). Solo una fonte gestita applica la restrizione; un singolo UUID in qualsiasi altro file di impostazioni pre-seleziona l'organizzazione durante l'accesso senza limitarla.
* **Type**: string, un UUID, o array di stringhe, diversi UUID
* **Default**: non impostato, quindi qualsiasi organizzazione può accedere

Questo esempio accetta accessi da una qualsiasi di due organizzazioni senza pre-selezionarne una:

```json managed-settings.json theme={null}
{
  "forceLoginOrgUUID": ["xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx", "yyyyyyyy-yyyy-yyyy-yyyy-yyyyyyyyyyyy"]
}
```

Se una fonte gestita imposta un array vuoto, o un valore che non è una stringa o un array di stringhe, gli utenti che accedono con un account Anthropic non possono avviare Claude Code né completare un accesso. Vedono un messaggio che nomina `forceLoginOrgUUID` e dice loro di contattare il loro amministratore. Un [`policyHelper`](#policyhelper) che emette un valore del tipo sbagliato invece [fallisce la sua esecuzione](#helper-failures).

Vedi [Limita l'accesso alla tua organizzazione](https://code.claude.com/docs/it/authentication.md#restrict-login-to-your-organization) per come Claude Code tratta gli accessi Claude Console, gli altri percorsi di accesso e le credenziali ambientali.

### `gatewayInternalNetworks`

Dichiara i blocchi IPv4 pubblici da cui la tua organizzazione numera la sua rete interna, in modo che `/login` accetti un [cloud gateway](https://code.claude.com/docs/it/claude-apps-gateway) lì. Richiede Claude Code v2.1.268 o successivo.

Senza questa chiave, `/login` si connette a qualsiasi gateway su un indirizzo privato e nient'altro. Con essa, `/login` accetta anche un gateway all'interno di un blocco elencato, solo su una connessione diretta. L'indirizzo della macchina stessa su quella connessione deve essere anche all'interno dello stesso blocco.

* **Scope**: [`Managed`](#scopes). Letto solo da una fonte sulla macchina: `managed-settings.json`, il plist macOS o il registro HKLM di Windows, o un helper di policy. Claude Code lo ignora nelle impostazioni HKCU e gestite dal server.
* **Type**: array di stringhe, al massimo quattro blocchi IPv4 CIDR, ognuno da `/8` a `/32`, non sovrapposti l'uno all'altro, e nessuno che si sovrappone allo spazio privato.
* **Default**: non impostato, quindi `/login` accetta solo gateway su indirizzi privati

```json managed-settings.json theme={null}
{
  "gatewayInternalNetworks": ["203.0.113.0/24"]
}
```

Sostituisci l'intervallo di documentazione nell'esempio con il tuo blocco. Claude Code rifiuta gli intervalli di documentazione, gli intervalli che i client VPN e NAT64 usano localmente, e lo spazio riservato da cui nessuna rete è numerata, come il multicast.

Se una voce non è valida, o il valore non è un elenco di stringhe, `/login` nomina il problema e rifiuta ogni nuovo accesso al gateway sulla macchina finché non correggi il valore. Gli accessi esistenti continuano a funzionare. Vedi [Consenti un gateway su spazio di indirizzi pubblico che possiedi](https://code.claude.com/docs/it/claude-apps-gateway#allow-a-gateway-on-public-address-space-you-own) per le regole complete e cosa vedono gli sviluppatori.

### `gcpAuthRefresh`

Esegui il tuo comando per aggiornare le credenziali predefinite dell'applicazione Google Cloud quando Claude Code scopre che sono scadute o non possono essere caricate, in modo che le richieste di [Google Cloud's Agent Platform](https://code.claude.com/docs/it/google-vertex-ai.md) continuino a funzionare senza che tu ti autentichi di nuovo manualmente.

Quando più processi Claude Code che usano lo stesso comando e le stesse credenziali, come terminali separati o finestre dell'IDE, le trovano scadute contemporaneamente, un processo esegue il comando e gli altri attendono quell'esecuzione invece di avviarne una propria. Un processo che ha atteso 60 secondi con una richiesta in sospeso esegue il comando da solo. Per disattivare questo comportamento, imposta [`CLAUDE_CODE_DISABLE_AUTH_REFRESH_LOCK`](https://code.claude.com/docs/it/env-vars) su `1`.

* **Scope**: [`Any file`](#scopes)
* **Type**: string, una riga di comando shell
* **Default**: non impostato, quindi l'errore di credenziale di Claude Code ti dice di eseguire `gcloud auth application-default login` tu stesso

```json settings.json theme={null}
{
  "gcpAuthRefresh": "gcloud auth application-default login"
}
```

Vedi [configurazione avanzata delle credenziali](https://code.claude.com/docs/it/google-vertex-ai.md#advanced-credential-configuration).

### `otelHeadersHelper`

Esegui il tuo comando per generare le intestazioni che Claude Code invia con le esportazioni OpenTelemetry, per backend i cui token ruotano. Claude Code lo esegue all'avvio e periodicamente dopo, e si aspetta un oggetto JSON di valori di intestazione stringa su stdout.

* **Scope**: [`Any file`](#scopes)
* **Type**: string, un percorso eseguibile o una riga di comando shell
* **Default**: non impostato, quindi Claude Code non aggiunge intestazioni generate da helper

```json settings.json theme={null}
{
  "otelHeadersHelper": "/bin/generate_otel_headers.sh"
}
```

Imposta l'intervallo di aggiornamento con [`CLAUDE_CODE_OTEL_HEADERS_HELPER_DEBOUNCE_MS`](https://code.claude.com/docs/it/env-vars). Vedi [Dynamic headers](https://code.claude.com/docs/it/monitoring-usage.md#dynamic-headers) per i requisiti dello script e cosa succede quando l'helper fallisce.

## Aggiornamenti e versioning

Scegli un canale di aggiornamento e, per le organizzazioni, fissa le versioni che le persone possono eseguire. Vedi [Aggiorna Claude Code](https://code.claude.com/docs/it/setup.md#update-claude-code).

### `autoUpdatesChannel`

Scegli quale [canale di rilascio](https://code.claude.com/docs/it/setup.md#configure-release-channel) seguono gli aggiornamenti automatici in background e `claude update`. Imposta `"stable"` per una versione che è tipicamente di circa una settimana fa e salta i rilasci con regressioni importanti, oppure `"latest"` per il rilascio più recente.

* **Scope**: [`Any file`](#scopes). Impostalo nelle impostazioni gestite per applicare un canale in tutta l'organizzazione.
* **Type**: string, uno di:
  * `"latest"`: gli aggiornamenti seguono il rilascio più recente
  * `"stable"`: gli aggiornamenti seguono una versione che è tipicamente di circa una settimana fa e salta i rilasci con regressioni importanti
* **Default**: non impostato, quindi Claude Code segue `"latest"`

```json settings.json theme={null}
{
  "autoUpdatesChannel": "stable"
}
```

Claude Code scrive `"stable"` nelle tue impostazioni utente quando lo scegli in **Auto-update channel** in `/config`, e rimuove la chiave quando torni a latest lì. `claude install stable` e `claude install latest` salvano anche il canale che nomini. Passare da `"latest"` a `"stable"` in `/config` chiede se consentire un downgrade o rimanere sulla versione corrente; rimanere imposta [`minimumVersion`](#minimumversion). Gli install di Homebrew ignorano questa chiave: il cask `claude-code` traccia stable e `claude-code@latest` traccia latest, e `claude update` si rimette a `brew upgrade`. Per disattivare completamente gli aggiornamenti automatici, imposta [`DISABLE_AUTOUPDATER`](https://code.claude.com/docs/it/setup#disable-auto-updates) in `env`.

### `minimumVersion`

Impedisci agli aggiornamenti automatici in background e a `claude update` di installare qualsiasi versione al di sotto di questa, quindi il passaggio al canale `"stable"` non ti fa eseguire il downgrade da una build `"latest"` più recente. Claude Code scrive questa chiave per te quando scegli di rimanere sulla versione corrente mentre cambi canale in `/config`, e la cancella quando torni a `"latest"`.

* **Scope**: [`Any file`](#scopes). Impostalo nelle impostazioni gestite per fissare un minimo a livello di organizzazione che le impostazioni utente e di progetto non possono abbassare.
* **Type**: string, un numero di versione come `"2.1.100"`; un valore che non è una versione valida viene ignorato
* **Default**: non impostato, quindi gli aggiornamenti possono installare qualsiasi versione che il canale offre

Questo esempio segue il canale stable e rifiuta di installare qualsiasi versione al di sotto di 2.1.100:

```json settings.json theme={null}
{
  "autoUpdatesChannel": "stable",
  "minimumVersion": "2.1.100"
}
```

Questa chiave vincola solo gli aggiornamenti. Per fare in modo che Claude Code rifiuti di avviarsi al di sotto di una versione, usa [`requiredMinimumVersion`](#requiredminimumversion) invece. Vedi [Fissa una versione minima](https://code.claude.com/docs/it/setup.md#pin-a-minimum-version).

### `requiredMaximumVersion`

Imposta la versione più recente di Claude Code che la tua organizzazione consente di avviare. Quando la versione in esecuzione è più recente, Claude Code esce all'avvio e dice all'utente di installare una versione approvata attraverso il metodo approvato della tua organizzazione; `claude install <version>` potrebbe funzionare anche. Richiede Claude Code v2.1.163 o successivo.

* **Scope**: [`Managed`](#scopes). Claude Code non dà alcun avviso quando ignora la chiave altrove.
* **Type**: string, un numero di versione come `"2.1.150"`; un valore che non è una versione valida viene ignorato
* **Default**: non impostato, quindi non si applica alcun limite massimo

```json managed-settings.json theme={null}
{
  "requiredMaximumVersion": "2.1.150"
}
```

Gli aggiornamenti automatici in background e `claude update` saltano le versioni al di sopra del limite, quindi un'installazione all'interno dell'intervallo rimane all'interno di esso. `claude update`, `claude install`, e `claude doctor` continuano a funzionare al di sopra del limite in modo che gli utenti possano recuperare. Abbinalo a [`requiredMinimumVersion`](#requiredminimumversion) per applicare un intervallo.

### `requiredMinimumVersion`

Imposta la versione più vecchia di Claude Code che la tua organizzazione consente di avviare. Quando la versione in esecuzione è più vecchia, Claude Code esce all'avvio e dice all'utente di aggiornare attraverso il metodo approvato della tua organizzazione. Il controllo viene eseguito solo all'avvio, quindi una sessione già in esecuzione continua. Richiede Claude Code v2.1.163 o successivo.

* **Scope**: [`Managed`](#scopes). Claude Code non dà alcun avviso quando ignora la chiave altrove.
* **Type**: string, un numero di versione come `"2.1.150"`; un valore che non è una versione valida viene ignorato
* **Default**: non impostato, quindi non si applica alcun limite minimo

```json managed-settings.json theme={null}
{
  "requiredMinimumVersion": "2.1.150"
}
```

`claude update`, `claude install`, e `claude doctor` continuano a funzionare al di sotto del limite in modo che gli utenti possano recuperare. A differenza di [`minimumVersion`](#minimumversion), che previene solo i downgrade, questa chiave blocca l'avvio. Abbinalo a [`requiredMaximumVersion`](#requiredmaximumversion) per applicare un intervallo.

## Tools

Disabilita strumenti specifici nell'[app desktop Claude](https://code.claude.com/docs/it/desktop.md). La CLI del terminale ignora queste chiavi. Per gli strumenti stessi, vedi [Strumenti disponibili per Claude](https://code.claude.com/docs/it/tools-reference.md).

### `browserExternalPageTools`

Impedisci a Claude di utilizzare i suoi strumenti per leggere o agire su pagine esterne nel [riquadro Browser](https://code.claude.com/docs/it/desktop.md#browse-external-sites) dell'app desktop. Le persone nella tua organizzazione possono comunque aprire siti esterni da sole, e le anteprime dei server di sviluppo locali continuano a funzionare con gli strumenti di Claude. L'app desktop legge questa chiave; la CLI del terminale la ignora.

* **Scope**: [`Managed`](#scopes)
* **Type**: stringa, `"disabled"`; l'app desktop accetta anche `"disable"`, in entrambi i casi
* **Default**: non impostato, quindi gli strumenti di Claude funzionano su pagine esterne

```json managed-settings.json theme={null}
{
  "browserExternalPageTools": "disabled"
}
```

Qualsiasi altro valore lascia gli strumenti di Claude attivi, e una stringa non vuota che non sia uno dei due valori accettati registra un avviso. Per bloccare i siti esterni sia per le persone che per Claude, imposta invece [`disableBrowserExternalNavigation`](#disablebrowserexternalnavigation). Vedi [Limitare la navigazione esterna per la tua organizzazione](https://code.claude.com/docs/it/desktop.md#restrict-external-browsing-for-your-organization).

### `disableBrowserExternalNavigation`

Disabilita la navigazione esterna nel [riquadro Browser](https://code.claude.com/docs/it/desktop.md#browse-external-sites) dell'app desktop sia per le persone che per Claude. Le anteprime dei server di sviluppo localhost continuano a funzionare. L'app desktop legge questa chiave; la CLI del terminale la ignora.

* **Scope**: [`Managed`](#scopes)
* **Type**: Booleano; solo il Booleano JSON `true` ha effetto
  * `true`: l'app desktop disabilita la navigazione esterna nel riquadro Browser sia per le persone che per Claude; le anteprime localhost continuano a funzionare
  * `false`: la navigazione esterna rimane attiva
* **Default**: non impostato, quindi la navigazione esterna è attiva

```json managed-settings.json theme={null}
{
  "disableBrowserExternalNavigation": true
}
```

L'app desktop ignora qualsiasi altro valore, e un valore che non sia un Booleano, come la stringa `"true"` o `1`, registra anche un avviso. Per lasciare la navigazione esterna attiva ma mantenere gli strumenti di Claude disabilitati su pagine esterne, imposta invece [`browserExternalPageTools`](#browserexternalpagetools). Vedi [Limitare la navigazione esterna per la tua organizzazione](https://code.claude.com/docs/it/desktop.md#restrict-external-browsing-for-your-organization).

### `disableMobileSimulatorTools`

Blocca gli strumenti di Claude per il [riquadro iOS Simulator](https://code.claude.com/docs/it/desktop-ios-simulator.md#turn-off-simulator-access) dell'app desktop. Le persone mantengono l'uso manuale del riquadro; solo l'accesso di Claude viene rimosso, e nessuno può riattivarlo dall'interno dell'app. L'app desktop legge questa chiave; la CLI del terminale la ignora.

* **Scope**: [`Managed`](#scopes)
* **Type**: Booleano; solo il Booleano JSON `true` ha effetto
  * `true`: l'app desktop blocca gli strumenti di Claude per il riquadro iOS Simulator
  * `false`: gli strumenti del simulatore di Claude seguono l'interruttore delle impostazioni di ogni persona nell'app desktop
* **Default**: non impostato, quindi gli strumenti del simulatore di Claude seguono l'interruttore delle impostazioni di ogni persona nell'app desktop

```json managed-settings.json theme={null}
{
  "disableMobileSimulatorTools": true
}
```

L'app desktop ignora qualsiasi altro valore, e un valore che non sia un Booleano, come la stringa `"true"` o `1`, registra anche un avviso.

## Privacy e telemetria

Controlla per quanto tempo Claude Code mantiene i dati della sessione e cosa invia. Gli interruttori che disattivano le metriche di utilizzo e i rapporti di errore sono variabili di ambiente, non chiavi di impostazione: imposta `DISABLE_TELEMETRY`, `DISABLE_ERROR_REPORTING`, o `CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC` nella chiave [`env`](#env) o nella shell. [Telemetry services](https://code.claude.com/docs/it/data-usage.md#telemetry-services) dice cosa disattiva ognuno. Due eccezioni si disattivano da un file di impostazioni: [`feedbackDrafts`](#feedbackdrafts) di seguito per il feedback redatto da Claude, e [`feedbackSurveyRate`](#feedbacksurveyrate) di seguito per il sondaggio della sessione.

### `cleanupPeriodDays`

Imposta quanti giorni Claude Code mantiene [i trascritti della sessione e altri dati dell'applicazione](https://code.claude.com/docs/it/claude-directory.md#cleaned-up-automatically) prima di eliminarli. Claude Code esegue l'eliminazione come una scansione di background dopo l'avvio di una sessione, purché possa determinare in modo sicuro il periodo di conservazione. La scansione elimina i trascritti senza mostrare un messaggio, quindi una sessione che non hai utilizzato per più tempo del periodo di conservazione non appare più nel selettore [`/resume`](https://code.claude.com/docs/it/sessions#resume-a-session).

* **Scope**: [`Any file`](#scopes)
* **Type**: numero di giorni, un numero intero, minimo `1`
* **Default**: `30`

```json settings.json theme={null}
{
  "cleanupPeriodDays": 20
}
```

L'impostazione di `0` non supera la convalida, quindi scegli un valore grande come `3650` per una conservazione a lungo termine. Per impedire a Claude Code di scrivere trascritti, vedi [Plaintext storage](https://code.claude.com/docs/it/claude-directory.md#plaintext-storage).

### `desktopSessionCleanupPeriodDays`

Imposta un limite di età in giorni per le trascrizioni delle sessioni che hai avviato o continuato più di recente in Claude Desktop o Cowork. Senza questa chiave, Claude Code [mantiene quelle trascrizioni a qualsiasi età](https://code.claude.com/docs/it/claude-directory.md#cleaned-up-automatically). Claude Code elimina ognuna una volta che è più vecchia sia di questo limite che di [`cleanupPeriodDays`](#cleanupperioddays), quindi con `cleanupPeriodDays` al suo valore predefinito di 30, un valore di `7` le mantiene comunque 30 giorni. [Cleaned up automatically](https://code.claude.com/docs/it/claude-directory.md#cleaned-up-automatically) elenca i casi in cui si applica invece `cleanupPeriodDays` e Claude Code ignora questa chiave. Richiede Claude Code v2.1.248 o successivo.

* **Scope**: [`User or managed`](#scopes). Claude Code legge anche la chiave da un file che passi con `--settings`, e la ignora nelle impostazioni di progetto e locali.
* **Type**: numero di giorni, un numero intero, minimo `0`
* **Default**: `0`, che non imposta alcun limite di età

```json settings.json theme={null}
{
  "desktopSessionCleanupPeriodDays": 90
}
```

### `feedbackDrafts`

Controlla [il feedback redatto da Claude](https://code.claude.com/docs/it/tools-reference.md#sendfeedback-tool-behavior): se Claude può mettere in coda le bozze di feedback per la tua revisione, e se Claude Code mostra una scheda quando Claude ne mette in coda una.

* **Scope**: [`User or managed`](#scopes)
* **Type**: stringa, uno di `"notify"`, `"quiet"`, o `"off"`
  * `"notify"`: Claude Code mostra una scheda sopra il prompt quando Claude mette in coda una bozza, fino a [tre schede in una sessione](https://code.claude.com/docs/it/tools-reference.md#what-you-see-when-claude-drafts) per impostazione predefinita
  * `"quiet"`: Claude redige senza una scheda. Vedi il conteggio delle bozze in coda nel footer del prompt e le rivedi in `/feedback`
  * `"off"`: Claude Code rimuove lo strumento SendFeedback, quindi Claude non può mettere in coda le bozze
* **Default**: `"notify"`
* **Per-session overrides**: [`CLAUDE_CODE_SEND_FEEDBACK`](https://code.claude.com/docs/it/env-vars) impostato a `0` disattiva la funzione per una sessione

```json settings.json theme={null}
{
  "feedbackDrafts": "quiet"
}
```

Appare in `/config` come **Claude-drafted feedback**, che scrive questa chiave nelle tue impostazioni utente. Vedi la riga `/config` solo nelle sessioni [dove Claude può redigere feedback](https://code.claude.com/docs/it/tools-reference.md#sessions-without-claude-drafted-feedback); l'impostazione di `"off"` non la nasconde, quindi puoi riattivare la funzione dalla stessa riga. Un valore nelle impostazioni gestite ha la precedenza sulla tua impostazione utente, quindi quando un amministratore imposta questa chiave, la riga mostra il valore gestito e modificarlo non ha effetto. Claude Code ignora questa chiave nelle impostazioni di progetto e locali.

### `feedbackSurveyRate`

Imposta la probabilità che il [sondaggio sulla qualità della sessione](https://code.claude.com/docs/it/data-usage.md#session-quality-surveys) appaia quando una sessione è idonea per esso. Imposta `0` per impedire che il sondaggio appaia.

* **Scope**: [`Any file`](#scopes)
* **Type**: numero tra `0` e `1`
* **Default**: non impostato, quindi Claude Code utilizza la velocità che Anthropic imposta da remoto, o la sua velocità incorporata di `0.005` su Amazon Bedrock, Google Cloud's Agent Platform, e Microsoft Foundry, che non ricevono configurazione remota
* **Per-session overrides**: [`CLAUDE_CODE_DISABLE_FEEDBACK_SURVEY`](https://code.claude.com/docs/it/env-vars) impostato a `1` disattiva il sondaggio per una sessione qualunque sia la velocità che questa chiave imposta

```json settings.json theme={null}
{
  "feedbackSurveyRate": 0.05
}
```

La stessa velocità si applica al sondaggio nell'estensione VS Code.

### `skipWebFetchPreflight`

Salta il [controllo di sicurezza del dominio WebFetch](https://code.claude.com/docs/it/data-usage.md#webfetch-domain-safety-check), che invia ogni nome host richiesto a `api.anthropic.com` prima di recuperare. Imposta `true` negli ambienti che bloccano il traffico verso Anthropic, come Amazon Bedrock, Google Cloud's Agent Platform, o distribuzioni Microsoft Foundry con egress restrittivo.

* **Scope**: [`Any file`](#scopes)
* **Type**: Boolean
  * `true`: Claude Code salta il controllo di sicurezza del dominio WebFetch
  * `false`: il controllo viene eseguito prima del primo recupero per ogni nome host in una sessione, e di nuovo per un nome host il cui controllo precedente è stato bloccato o non riuscito
* **Default**: non impostato, quindi il controllo viene eseguito prima del primo recupero per ogni nome host in una sessione

```json settings.json theme={null}
{
  "skipWebFetchPreflight": true
}
```

Con il controllo saltato, WebFetch tenta qualsiasi URL senza consultare la lista di blocco, quindi abbinalo alle [regole di autorizzazione `WebFetch`](https://code.claude.com/docs/it/permissions#webfetch) se hai bisogno di limitare quali domini Claude può raggiungere.

## Impostazioni aziendali e gestite

Chiavi che un'organizzazione utilizza per calcolare, aggiornare e combinare le impostazioni gestite. Vedi [Configurare le impostazioni gestite](https://code.claude.com/docs/it/admin-setup.md).

### `disableSideloadFlags`

Rifiuta i flag CLI `--plugin-dir`, `--plugin-url`, `--agents` e `--mcp-config` all'avvio, che gli utenti potrebbero altrimenti passare per aggirare [`strictKnownMarketplaces`](#strictknownmarketplaces) per una singola esecuzione. Claude Code esce con un errore che nomina i flag rifiutati. Nelle [sessioni cloud](https://code.claude.com/docs/it/claude-code-on-the-web.md), Claude Code invece avvia la sessione e elimina ogni voce `--mcp-config` consegnata dal server tranne le voci in-process `type: "sdk"` e gli strumenti Slack di una sessione [Claude Tag](https://code.claude.com/docs/it/claude-tag.md). Richiede Claude Code v2.1.193 o successivo.

* **Scope**: [`Managed`](#scopes)
* **Type**: Boolean
  * `true`: Claude Code rifiuta `--plugin-dir`, `--plugin-url`, `--agents` e `--mcp-config` all'avvio ed esce con un errore che li nomina. Nelle sessioni cloud, invece avvia la sessione ed elimina ogni voce `--mcp-config` consegnata dal server tranne le voci in-process `type: "sdk"` e gli strumenti Slack di una sessione Claude Tag
  * `false`: Claude Code accetta questi flag
* **Default**: `false`

```json managed-settings.json theme={null}
{
  "disableSideloadFlags": true
}
```

Claude Code accetta comunque un `--mcp-config` i cui server sono tutti voci in-process `type: "sdk"`, quindi l'Agent SDK e l'estensione VS Code continuano a funzionare. Gli utenti possono comunque aggiungere server con `claude mcp add` o un file `.mcp.json`; per il controllo per-server, imposta anche [`allowedMcpServers`](https://code.claude.com/docs/it/managed-mcp). Richiede Claude Code v2.1.193 o successivo.

Lo stesso controllo copre le cartelle plugin nominate nella variabile di ambiente [`CLAUDE_CODE_PLUGIN_DIRS`](https://code.claude.com/docs/it/env-vars#variables), che richiede Claude Code v2.1.280 o successivo. Quando la variabile nomina una cartella, Claude Code esce con lo stesso errore e l'errore dice di annullare l'impostazione della variabile.

Nelle sessioni cloud, Claude Code ignora anche gli aggiornamenti MCP mid-session consegnati dal server, il percorso dietro la configurazione della sessione cloud e le chiamate SDK `setMcpServers()` che raggiungono quelle sessioni. Le voci in-process `type: "sdk"` e gli strumenti Slack di una sessione Claude Tag rimangono esenti anche lì. Prima della v2.1.268, sia questo drop che lo startup drop rimuovevano anche gli strumenti Slack di una sessione Claude Tag. Prima della v2.1.239, un `--mcp-config` consegnato dal server bloccava l'avvio di una sessione cloud.

L'app desktop gestisce alcuni plugin da sola, inclusi i plugin sincronizzati da claude.ai e i plugin che la tua organizzazione distribuisce tramite l'app. Se distribuisci questa chiave a un dispositivo tramite MDM, politica a livello di sistema operativo o un file di impostazioni gestite, l'app desktop non passa questi plugin alle seguenti sessioni su quel dispositivo:

* **[Sessioni di codice sulla macchina dell'utente](https://code.claude.com/docs/it/desktop.md#environment-configuration)**: iniziano anche senza le competenze abilitate per l'account claude.ai dell'utente. I plugin che Claude Code installa dai marketplace nelle tue impostazioni gestite continuano a caricarsi. In [Claude Desktop su 3P](https://claude.com/docs/third-party/claude-desktop/overview), i server MCP dai plugin che distribuisci alla directory `org-plugins` del dispositivo rimangono disponibili anche, perché l'app desktop si connette a loro stessa. Prima di Claude Desktop v1.37937.0, queste sessioni fallivano all'avvio.
* **[Sessioni Cowork sulla macchina dell'utente](https://code.claude.com/docs/it/managed-settings.md#where-and-when-a-policy-applies)**: le competenze all'interno di questi plugin e le competenze abilitate per l'account claude.ai dell'utente rimangono disponibili. In [Claude Desktop su 3P](https://claude.com/docs/third-party/claude-desktop/overview), i server MCP dai plugin che distribuisci alla directory `org-plugins` del dispositivo rimangono disponibili anche, perché l'app desktop si connette a loro stessa. Prima di Claude Desktop v1.44121.0, queste sessioni fallivano all'avvio.

### `forceRemoteSettingsRefresh`

Blocca l'avvio della CLI fino a quando Claude Code non ha recuperato di recente le [impostazioni gestite dal server](https://code.claude.com/docs/it/server-managed-settings.md). Se il recupero fallisce, Claude Code esce invece di continuare con le impostazioni memorizzate nella cache o nessuna impostazione. Impostalo quando il tuo ambiente non può accettare nemmeno una breve finestra in cui una sessione viene eseguita senza la sua politica gestita.

Quando la chiave non è impostata, Claude Code non blocca l'avvio sul recupero, anche se quando lo sviluppatore accede all'avvio attende fino a cinque secondi per il recupero. Una sessione del gateway Cloud attende sempre ed esce se il gateway non può essere raggiunto.

* **Scope**: [`Managed`](#scopes). Claude Code onora un `true` da qualsiasi fonte gestita controllata dall'amministratore, anche una che non è la fonte con la priorità più alta.
* **Type**: Boolean
  * `true`: Claude Code blocca l'avvio fino a quando non ha recuperato di recente le impostazioni gestite dal server ed esce se il recupero fallisce
  * `false`: Claude Code non blocca l'avvio sul recupero, anche se all'avvio di un accesso attende fino a cinque secondi per il recupero
* **Default**: `false`

```json managed-settings.json theme={null}
{
  "forceRemoteSettingsRefresh": true
}
```

Impostalo in un profilo MDM o nel file delle impostazioni gestite per applicare l'avvio fail-closed prima che arrivi il primo payload del server. Claude Code applica il controllo solo nelle sessioni che recuperano le impostazioni gestite dal server, quindi una sessione che [non le recupera](https://code.claude.com/docs/it/server-managed-settings.md#platform-availability) si avvia senza attendere. I sottocomandi `claude auth` sono esenti, quindi gli utenti possono autenticarsi di nuovo quando le credenziali scadute sono il motivo per cui il recupero fallisce. Vedi [Applicare l'avvio fail-closed](https://code.claude.com/docs/it/server-managed-settings.md#enforce-fail-closed-startup).

### `managedSourcesBehavior`

Scegli se Claude Code applica solo la [fonte gestita](https://code.claude.com/docs/it/managed-settings.md#how-claude-code-combines-managed-sources) con la priorità più alta che la tua organizzazione fornisce, o combina ogni fonte amministrativa che fornisce. Per impostazione predefinita, Claude Code prende la fonte con la priorità più alta che contiene una [chiave di politica](https://code.claude.com/docs/it/managed-settings.md#how-claude-code-combines-managed-sources) e ignora il resto. Una chiave di politica è qualsiasi chiave di impostazioni diversa da questa e `wslInheritsWindowsSettings`. Con questa impostazione predefinita, una volta che le impostazioni gestite dal server o una politica MDM forniscono una chiave di politica, un file `managed-settings.json` contribuisce solo alle [chiavi che Claude Code legge da ogni fonte amministrativa](https://code.claude.com/docs/it/managed-settings.md#keys-read-from-every-admin-source). Con `"merge"`, ogni fonte amministrativa che fornisci contribuisce con le sue chiavi a una politica combinata. Richiede Claude Code v2.1.242 o successivo.

Imposta `"merge"` solo dove ogni fonte [classificata](https://code.claude.com/docs/it/managed-settings.md#how-claude-code-combines-managed-sources) sotto la tua più alta è sotto il controllo di un amministratore, perché Claude Code quindi aggiunge voci da una fonte inferiore, come le regole `permissions.allow`, alla politica.

* **Scope**: [`Managed`](#scopes). Claude Code legge questa chiave dalla fonte con la priorità più alta che contiene questa chiave o una chiave di politica e ignora questa chiave in ogni fonte classificata più in basso, quindi una fonte inferiore non può optare per la combinazione con la fonte sopra di essa. Né il registro HKCU di Windows né le [impostazioni padre da un host di incorporamento](https://code.claude.com/docs/it/managed-settings.md#let-an-embedding-host-add-policy) partecipano al merge.
* **Type**: string, uno di:
  * `"first-wins"`: la fonte con la priorità più alta che contiene una chiave di politica fornisce la politica e le fonti inferiori contribuiscono solo alle [chiavi che Claude Code legge da ogni fonte amministrativa](https://code.claude.com/docs/it/managed-settings.md#keys-read-from-every-admin-source)
  * `"merge"`: ogni fonte amministrativa che fornisci contribuisce con le sue chiavi, combinate secondo le regole sottostanti
* **Default**: `"first-wins"`

Fornisci la chiave nella fonte con la priorità più alta che distribuisci. Una macchina che non riceve mai le impostazioni gestite dal server ha bisogno della chiave anche nel suo profilo MDM, perché Claude Code legge la chiave dalla fonte con la priorità più alta che la contiene o una chiave di politica. Un file `managed-settings.json` è la fonte amministrativa con il rango più basso, quindi `"merge"` impostato lì non ha alcuna fonte sottostante con cui combinarsi. Nelle impostazioni gestite dal server, la chiave appare così:

```json theme={null}
{
  "managedSourcesBehavior": "merge"
}
```

Con `"merge"`, Claude Code combina ogni chiave in base al suo tipo. Questa tabella fornisce la regola per ogni tipo. Le righe della lista di restrizioni, valori-presi-interi e solo-fonte-più-alta nominano ogni chiave che coprono, e le altre righe forniscono esempi:

| Tipo di chiave | Come Claude Code la combina | Chiavi |
| :- | :- | :- |
| Liste | Combina voci da ogni fonte | [`permissions.allow`](#permissions-allow), [`sandbox.network.allowedDomains`](#sandbox-network-alloweddomains) e altre chiavi di lista |
| Blocchi | Applica il valore più rigoroso che qualsiasi fonte imposta. Quando nessuna fonte imposta un valore rigoroso, applica un valore più lasco solo dalla fonte con la priorità più alta | [`allowManagedPermissionRulesOnly`](#allowmanagedpermissionrulesonly), [`permissions.disableBypassPermissionsMode`](#permissions-disablebypasspermissionsmode) e altri blocchi booleani o enum |
| Liste di restrizioni | Prende la lista intera dalla fonte con la priorità più alta che la imposta, senza aggiungere voci da fonti inferiori. Quando la fonte con la priorità più alta non ne imposta una, la prende intera dalla fonte successiva | [`availableModels`](#availablemodels), [`allowedMcpServers`](#allowedmcpservers), [`allowedProviders`](#allowedproviders), [`strictKnownMarketplaces`](#strictknownmarketplaces), [`allowedChannelPlugins`](#allowedchannelplugins) e la catena [`fallbackModel`](#fallbackmodel) |
| Valori presi interi | Prende il valore intero dalla fonte con la priorità più alta che lo imposta, senza combinare voci o campi da fonti inferiori. Quando la fonte con la priorità più alta non lo imposta, lo prende intero dalla fonte successiva | [`sandbox.credentials.awsPairs`](#sandbox-credentials-awspairs), [`sandbox.ripgrep`](#sandbox-ripgrep) |
| Server MCP forniti | Combina i nomi dei server da ogni fonte. Quando due fonti impostano lo stesso nome, applica la voce intera della fonte più alta | [`managedMcpServers`](#managedmcpservers) |
| Leggi solo dalla fonte con la priorità più alta | Legge la chiave solo dalla fonte con la priorità più alta che contiene una chiave di politica, quindi il valore di una fonte inferiore viene ignorato anche quando la fonte con la priorità più alta non ne imposta uno | [`apiKeyHelper`](#apikeyhelper), [`awsAuthRefresh`](#awsauthrefresh), [`awsCredentialExport`](#awscredentialexport), [`gcpAuthRefresh`](#gcpauthrefresh), [`otelHeadersHelper`](#otelheadershelper), `proxyAuthHelper`, [`forceLoginOrgUUID`](#forceloginorguuid), i valori `"claudeai"` e `"console"` di [`forceLoginMethod`](#forceloginmethod), [`parentSettingsBehavior`](#parentsettingsbehavior), [`modelPicker`](#modelpicker), [`policyHelper`](#policyhelper), [`permissions.defaultMode`](#permissions-defaultmode) |
| `env` | [Unisce per variabile tra fonti amministrative](https://code.claude.com/docs/it/managed-settings.md#keys-read-from-every-admin-source), sia con `"first-wins"` che con `"merge"` | [`env`](#env) |
| Ogni altra chiave | Prende il valore dalla fonte con la priorità più alta che lo imposta | [`cleanupPeriodDays`](#cleanupperioddays), [`model`](#model) |

Prendere `sandbox.credentials.awsPairs` e `sandbox.ripgrep` interi richiede Claude Code v2.1.257 o successivo.

Alcune chiavi aggiungono una condizione che la tabella non mostra:

* **[`policyHelper`](#policyhelper)**: Claude Code lo onora solo quando la fonte con la priorità più alta che contiene una chiave di politica è una politica MDM o un file di impostazioni gestite, quindi con le impostazioni gestite dal server non si applica.
* **[`modelOverrides`](#modeloverrides)**: si accoppia con `availableModels`. Claude Code prende `modelOverrides` dalla fonte con la priorità più alta che lo imposta, a meno che una fonte più alta non imposti `availableModels` senza `modelOverrides`. In quel caso ignora `modelOverrides` da ogni fonte.
* **[`forceLoginGatewayUrl`](#forcelogingatewayurl), [`gatewayInternalNetworks`](#gatewayinternalnetworks) e il valore `"gateway"` di [`forceLoginMethod`](#forceloginmethod)**: Claude Code non li legge mai dalle impostazioni gestite dal server, quindi un valore lì non si applica né nasconde uno impostato in una politica MDM o un file di impostazioni gestite. Tra le fonti amministrative sulla macchina, solo quella con il rango più alto che contiene una chiave di politica le fornisce, indipendentemente dal fatto che le impostazioni gestite dal server siano presenti o meno.
* **[`allowedProviders`](#allowedproviders)**: dopo la regola della tabella, l'elenco della macchina stessa limita ancora il risultato, come afferma la nota Scope della sua voce.

Per confermare quali fonti si sono combinate su una macchina, esegui `/status` e [leggi la riga `Setting sources`](https://code.claude.com/docs/it/managed-settings#read-the-source-in-/status).

### `parentSettingsBehavior`

Scegli se Claude Code applica le impostazioni gestite fornite da un processo host di incorporamento, come l'Agent SDK o un'estensione IDE, quando è presente anche un livello gestito distribuito dall'amministratore. Con `"first-wins"`, Claude Code elimina le impostazioni fornite dall'host; con `"merge"`, le applica sotto il livello amministrativo attraverso un filtro solo restrittivo. Imposta `"merge"` quando un host ha bisogno di passare le sue stesse restrizioni alle sessioni che avvia, ad esempio Claude Desktop che fornisce la lista di egresso consentita di un gateway.

* **Scope**: [`Managed`](#scopes). Claude Code la legge dalla fonte gestita controllata dall'amministratore con la priorità più alta.
* **Type**: string, uno di:
  * `"first-wins"`: Claude Code elimina le impostazioni fornite dall'host quando è presente un livello gestito distribuito dall'amministratore
  * `"merge"`: Claude Code applica le impostazioni fornite dall'host sotto il livello amministrativo attraverso un filtro solo restrittivo
* **Default**: `"first-wins"`

```json managed-settings.json theme={null}
{
  "parentSettingsBehavior": "merge"
}
```

Questa chiave non ha effetto quando non esiste alcun livello gestito distribuito dall'amministratore: le impostazioni dell'host si applicano quindi come l'unico livello gestito, ancora filtrate a valori restrittivi. Per i limiti del filtro e come le fonti gestite interagiscono, vedi [Impostazioni padre da host di incorporamento](https://code.claude.com/docs/it/managed-settings.md#parent-settings-from-embedding-hosts) e [Limitare le impostazioni padre](https://code.claude.com/docs/it/claude-apps-gateway#restrict-parent-settings).

### `policyHelper`

Esegui un eseguibile che distribuisci che calcola le impostazioni gestite all'avvio, così puoi derivare la politica dalla postura del dispositivo, dall'identità o da un servizio remoto invece di un file statico. Claude Code esegue l'helper prima di accettare il primo prompt e tratta le impostazioni che emette come le impostazioni gestite per la sessione.

* **Scope**: [`Managed`](#scopes). Leggi dalla plist macOS, dal registro HKLM di Windows o dal file delle impostazioni gestite. Claude Code legge la chiave dalla fonte gestita con la priorità più alta che contiene una [chiave di politica](https://code.claude.com/docs/it/managed-settings.md#how-claude-code-combines-managed-sources) ed esegue l'helper solo quando quella fonte è una di quelle tre; ignora la chiave nelle impostazioni gestite dal server, nel registro HKCU e nelle impostazioni padre fornite dall'host.
* **Type**: object con `path`, `timeoutMs` e `refreshIntervalMs`
* **Default**: non impostato, quindi nessun helper viene eseguito

Quando le impostazioni gestite dal server forniscono la politica all'avvio, hanno la precedenza sulla fonte dell'helper e l'helper non viene eseguito.

Se un recupero di impostazioni successivo segnala che le impostazioni gestite dal server sono state rimosse, Claude Code esegue l'helper a quel punto piuttosto che attendere il prossimo avvio. Il suo output governa il resto della sessione e un'esecuzione che fallisce termina la sessione con lo stesso messaggio di un'[esecuzione di avvio fallita](#helper-failures).

Questo esempio esegue l'helper con un timeout di 5 secondi e lo riesegue ogni cinque minuti:

```json managed-settings.json theme={null}
{
  "policyHelper": {
    "path": "/usr/local/bin/claude-policy",
    "timeoutMs": 5000,
    "refreshIntervalMs": 300000
  }
}
```

#### Scrivi l'output dell'helper

Claude Code esegue l'helper senza argomenti, imposta `CLAUDE_CODE_VERSION` nel suo ambiente e legge un envelope JSON da stdout, limitato a 1 MiB.

Metti le impostazioni sotto una chiave `managedSettings`. Un oggetto di impostazioni bare senza una chiave `managedSettings` analizza con `managedSettings` non definito e non applica nulla, e Claude Code non segnala alcun errore:

```json theme={null}
{
  "managedSettings": {
    "permissions": { "deny": ["Read(//etc/secrets/**)"] }
  }
}
```

Quando l'helper emette `managedSettings`, quell'oggetto diventa l'unica fonte di impostazioni gestite per l'esecuzione: Claude Code ignora le fonti MDM, file e HKCU, legge le [chiavi cross-source](https://code.claude.com/docs/it/managed-settings.md#keys-read-from-every-admin-source) solo dall'output dell'helper e non unisce mai le [impostazioni padre](https://code.claude.com/docs/it/managed-settings.md#parent-settings-from-embedding-hosts).

Il controllo di avvio `forceRemoteSettingsRefresh` viene eseguito prima dell'helper e legge qualsiasi fonte amministrativa. Un helper che esce con `0` con un envelope che omette `managedSettings` non contribuisce con alcuna impostazione gestita e le altre fonti si applicano come al solito.

#### Errori dell'helper

Un'esecuzione dell'helper fallisce quando:

* `path` viola le regole in [`policyHelper.path`](#policyhelper-path).
* Nessun file regolare è in `path`. Claude Code controlla il file prima di avviare l'helper, entro lo stesso budget `timeoutMs`, quindi un mount di rete non responsivo può causare il fallimento dell'esecuzione.
* L'helper esce con un valore diverso da zero, è ancora in esecuzione quando `timeoutMs` trascorre o non si avvia affatto, ad esempio perché non è eseguibile.
* L'helper scrive più di 1 MiB su stdout o su stderr.
* stdout non è un singolo oggetto JSON, o il suo `managedSettings` ha una [violazione dello schema che Claude Code non può riparare](https://code.claude.com/docs/it/managed-settings.md#find-entries-claude-code-dropped).

Quando l'esecuzione di avvio fallisce, Claude Code stampa il motivo e rifiuta di avviarsi. Dopo un'uscita diversa da zero, il motivo include stderr dell'helper, o il suo stdout quando stderr è vuoto. Dopo un timeout, il motivo nomina il limite `timeoutMs` e non include alcun output dell'helper. Il rifiuto copre le sessioni interattive, `claude -p`, le sessioni dell'Agent SDK, le [sessioni in background](https://code.claude.com/docs/it/agent-view.md) e la maggior parte dei sottocomandi.

Il rifiuto è deliberato, quindi un helper che ha bisogno di resilienza alle interruzioni dovrebbe servire dalla sua stessa cache ed uscire con `0`.

Quando un aggiornamento in background fallisce, Claude Code mantiene l'ultima politica riuscita in vigore e `/status` mostra l'aggiornamento fallito con il suo motivo fino a quando un aggiornamento non riesce. Ogni aggiornamento viene eseguito secondo lo stesso `timeoutMs` e le stesse regole di fallimento dell'esecuzione di avvio.

Con `--debug`, Claude Code scrive stderr dell'helper da ogni esecuzione nel [log di debug](https://code.claude.com/docs/it/debug-your-config.md).

Claude Code segnala un valore `policyHelper` non valido come una [voce eliminata](https://code.claude.com/docs/it/managed-settings.md#find-entries-claude-code-dropped) e avvia la sessione sulle impostazioni gestite rimanenti senza eseguire un helper. I valori non validi includono una stringa di percorso bare e un `timeoutMs` al di sotto del [suo minimo](#policyhelper-timeoutms).

Per disattivare un helper, rimuovi la chiave dalla fonte che la imposta.

### `policyHelper.path`

Nomina l'eseguibile dell'helper che Claude Code esegue. Per quello che succede quando il percorso viola le regole sottostanti, vedi [Errori dell'helper](#helper-failures).

* **Scope**: [`Managed`](#scopes). Leggi dalla plist macOS, dal registro HKLM di Windows o dal file delle impostazioni gestite, ovunque [`policyHelper`](#policyhelper) sia letto.
* **Type**: string, un percorso assoluto in forma normalizzata, senza segmenti `.` o `..`; su Windows, un percorso con lettera di unità o UNC che termina in `.exe`
* **Default**: nessuno; obbligatorio quando `policyHelper` è impostato

```json managed-settings.json theme={null}
{
  "policyHelper": {
    "path": "/usr/local/bin/claude-policy"
  }
}
```

### `policyHelper.timeoutMs`

Imposta quanto tempo Claude Code attende l'helper prima di trattare l'esecuzione come fallita. Un'esecuzione scaduta fallisce allo stesso modo di un'uscita diversa da zero, quindi all'avvio Claude Code rifiuta di avviarsi.

* **Scope**: [`Managed`](#scopes). Leggi dalla plist macOS, dal registro HKLM di Windows o dal file delle impostazioni gestite, ovunque [`policyHelper`](#policyhelper) sia letto.
* **Type**: integer, millisecondi, minimo `1000`
* **Default**: `10000`

```json managed-settings.json theme={null}
{
  "policyHelper": {
    "path": "/usr/local/bin/claude-policy",
    "timeoutMs": 5000
  }
}
```

### `policyHelper.refreshIntervalMs`

Fai in modo che Claude Code riesegua l'helper in background su un intervallo in modo che i cambiamenti di politica raggiungano una sessione in esecuzione. Quando un aggiornamento riesce, il suo output sostituisce le impostazioni gestite precedenti senza un riavvio; quando un aggiornamento fallisce, Claude Code mantiene la politica che ha già.

* **Scope**: [`Managed`](#scopes). Leggi dalla plist macOS, dal registro HKLM di Windows o dal file delle impostazioni gestite, ovunque [`policyHelper`](#policyhelper) sia letto.
* **Type**: integer, millisecondi: `0` per disabilitare l'aggiornamento, altrimenti almeno `60000`
* **Default**: non impostato, quindi Claude Code esegue l'helper una volta all'avvio

Questo esempio riesegue l'helper ogni cinque minuti:

```json managed-settings.json theme={null}
{
  "policyHelper": {
    "path": "/usr/local/bin/claude-policy",
    "refreshIntervalMs": 300000
  }
}
```

### `wslInheritsWindowsSettings`

Fai in modo che Claude Code su WSL legga le impostazioni gestite dalla catena di politica di Windows, con HKLM e il file di impostazioni gestite di Windows che hanno priorità su `/etc/claude-code` e HKCU sottostante. Mentre la catena è attiva, Claude Code legge `/etc/claude-code` solo quando [nessun documento amministrativo di Windows è presente](https://code.claude.com/docs/it/managed-settings.md#present-admin-documents) nel valore del registro HKLM o nella cartella `C:\Program Files\ClaudeCode\`. Impostalo per estendere la politica che distribuisci già su Windows alle sessioni WSL sulla stessa macchina, in modo che seguano le stesse regole delle sessioni host. Claude Code lo onora solo quando impostato nella chiave del registro HKLM o in un file di impostazioni gestite o drop-in sotto `C:\Program Files\ClaudeCode\`, entrambi i quali richiedono privilegi di amministratore di Windows per scrivere.

* **Scope**: [`Managed`](#scopes). In una fonte Windows controllata dall'amministratore.
* **Type**: Boolean
  * `true`: Claude Code su WSL legge le impostazioni gestite dalla catena di politica di Windows e legge `/etc/claude-code` solo quando nessun documento amministrativo di Windows è presente
  * `false`: WSL legge solo `/etc/claude-code`
* **Default**: `false`, quindi WSL legge solo `/etc/claude-code`

```json managed-settings.json theme={null}
{
  "wslInheritsWindowsSettings": true
}
```

Una volta che una fonte amministrativa attiva la catena, la politica HKCU si unisce ad essa su WSL solo quando HKCU imposta anche la chiave su `true`. Quella copia non attiva la catena da sola. Una fonte Windows che contiene solo questa chiave, impostata su `true` o `false`, non conta come fonte di politica, quindi una fonte con priorità inferiore fornisce comunque la politica. Questa chiave non ha effetto su Windows nativo.

Claude Code legge `true` e `false` con o senza virgolette e legge `null` come rimozione della chiave. Una fonte Windows controllata dall'amministratore che contiene qualsiasi altro valore conta come un [documento amministrativo presente](https://code.claude.com/docs/it/managed-settings.md#present-admin-documents) con la catena attivata: né `/etc/claude-code` né HKCU si applica e un avviso di avvio nomina la chiave. Un valore HKLM o un file di cartella Windows che esiste ma non può essere letto mantiene anche `/etc/claude-code` dall'applicarsi indipendentemente dal fatto che la catena sia attiva o meno. Richiede Claude Code v2.1.282 o successivo.

## Impostazioni di configurazione globale

Salvate queste chiavi in `~/.claude.json`, non in un file di impostazioni. Claude Code le ignora ovunque altrove. Claude Code e `/config` le scrivono per voi nella maggior parte dei casi, e potete anche modificarle manualmente.

### `autoConnectIde`

Connettiti a un IDE in esecuzione automaticamente quando avvii Claude Code da un terminale esterno. Appare in `/config` come **Auto-connect to IDE (external terminal)** quando esegui Claude Code al di fuori di un terminale VS Code o JetBrains.

* **Scope**: [`Global config`](#scopes)
* **Type**: Boolean
  * `true`: Claude Code si connette a un IDE in esecuzione automaticamente quando lo avvii da un terminale esterno
  * `false`: Claude Code non si connette automaticamente da un terminale esterno; all'interno di un terminale VS Code o JetBrains, o con `--ide`, si connette comunque
* **Default**: `false`
* **Per-session overrides**: [`CLAUDE_CODE_AUTO_CONNECT_IDE`](https://code.claude.com/docs/it/env-vars) ha la precedenza su questa chiave per una sessione, in entrambe le direzioni

```json ~/.claude.json theme={null}
{
  "autoConnectIde": true
}
```

Claude Code ignora questa chiave in `settings.json`.

### `autoInstallIdeExtension`

Installa l'estensione IDE di Claude Code automaticamente quando esegui Claude Code da un terminale VS Code. Appare in `/config` come **Auto-install IDE extension** quando esegui Claude Code all'interno di un terminale VS Code o JetBrains.

* **Scope**: [`Global config`](#scopes)
* **Type**: Boolean
  * `true`: Claude Code installa l'estensione IDE automaticamente quando lo esegui da un terminale VS Code
  * `false`: Claude Code non installa l'estensione automaticamente
* **Default**: `true`
* **Per-session overrides**: [`CLAUDE_CODE_IDE_SKIP_AUTO_INSTALL`](https://code.claude.com/docs/it/env-vars) impostato su `1` salta l'installazione per una sessione anche quando questa chiave è `true`

```json ~/.claude.json theme={null}
{
  "autoInstallIdeExtension": false
}
```

Claude Code ignora questa chiave in `settings.json`.

### `claudeInChromeDefaultEnabled`

Avvia ogni sessione CLI interattiva con l'[integrazione Chrome](https://code.claude.com/docs/it/chrome.md) attivata, senza passare `--chrome` ogni volta. Se esegui [`claude remote-control`](https://code.claude.com/docs/it/remote-control), anche una sessione che avvia per uno dei tuoi thread di [progetto](https://code.claude.com/docs/it/claude-projects.md) segue questa chiave, tranne in modalità `bypassPermissions`. Con Claude Code v2.1.287 o successivo, questa chiave si applica anche alle sessioni nell'[estensione VS Code](https://code.claude.com/docs/it/vs-code.md#automate-browser-tasks-with-chrome): consulta [Enable Chrome by default](https://code.claude.com/docs/it/chrome.md#enable-chrome-by-default).

Eseguire `/chrome` e selezionare **Enabled by default** imposta questa chiave per te. Appare in `/config` come **Claude in Chrome enabled by default**.

* **Scope**: [`Global config`](#scopes)
* **Type**: Boolean
  * `true`: Claude Code attiva l'integrazione Chrome quando una sessione CLI interattiva si avvia, come fa quando passi `--chrome`. Nell'estensione VS Code, le sessioni si connettono al browser all'avvio
  * `false`: le sessioni CLI interattive si avviano con l'integrazione Chrome disattivata, e Claude Code smette di [offrire di configurarla](https://code.claude.com/docs/it/chrome.md#install-the-extension-when-claude-asks). Passa `--chrome` per attivarla per una sessione interattiva. Nell'estensione VS Code, una sessione si connette quando digiti `@browser`, come quando la chiave non è impostata
* **Default**: non impostato, quindi l'integrazione Chrome è disattivata e Claude Code può ancora offrire di configurarla
* **Per-session overrides**: `--chrome` e [`--no-chrome`](https://code.claude.com/docs/it/cli-reference) hanno la precedenza su questa chiave per una sessione interattiva

```json ~/.claude.json theme={null}
{
  "claudeInChromeDefaultEnabled": true
}
```

Claude Code ignora questa chiave in `settings.json`.

### `copyFullResponse`

Fai in modo che [`/copy`](https://code.claude.com/docs/it/commands) copi la risposta completa ogni volta, senza mostrare il selettore. Selezionare **Always copy full response** in quel selettore imposta questa chiave su `true`. Appare in `/config` come **Skip the /copy picker**.

* **Scope**: [`Global config`](#scopes)
* **Type**: Boolean
  * `true`: `/copy` copia la risposta completa senza mostrare il selettore
  * `false`: quando la risposta contiene blocchi di codice o citazioni, `/copy` mostra un selettore dove scegli un blocco o la risposta completa
* **Default**: `false`

```json ~/.claude.json theme={null}
{
  "copyFullResponse": true
}
```

Claude Code ignora questa chiave in `settings.json`.

### `copyOnSelect`

Copia il testo negli appunti automaticamente quando finisci di selezionarlo con il mouse nel [rendering a schermo intero](https://code.claude.com/docs/it/fullscreen.md#use-the-mouse) o nella [vista agente](https://code.claude.com/docs/it/agent-view.md). Appare in `/config` come **Copy on select** mentre il rendering a schermo intero è attivo.

* **Scope**: [`Global config`](#scopes)
* **Type**: Boolean
  * `true`: Claude Code copia il testo negli appunti quando finisci di selezionarlo
  * `false`: la selezione del testo lascia gli appunti invariati, e [copi la selezione con una scorciatoia da tastiera](https://code.claude.com/docs/it/fullscreen.md#use-the-mouse) invece
* **Default**: `true`

```json ~/.claude.json theme={null}
{
  "copyOnSelect": false
}
```

Claude Code ignora questa chiave in `settings.json`.

### `defaultToAgentsView`

Apri la [vista agente](https://code.claude.com/docs/it/agent-view.md) invece di una nuova conversazione quando esegui `claude` senza argomenti. Appare in `/config` come **Open agents view by default** a meno che la vista agente non sia [disattivata](#disableagentview).

* **Scope**: [`Global config`](#scopes)
* **Type**: Boolean
  * `true`: `claude` senza argomenti apre la vista agente, a meno che la vista agente non sia [disattivata](#disableagentview)
  * `false`: `claude` senza argomenti avvia una nuova conversazione
* **Default**: `false`

```json ~/.claude.json theme={null}
{
  "defaultToAgentsView": true
}
```

Claude Code ignora questa chiave in `settings.json`.

### `diffTool`

Scegli dove Claude Code mostra il diff di una modifica `Edit` o `Write` che propone quando un IDE [VS Code](https://code.claude.com/docs/it/vs-code.md) o [JetBrains](https://code.claude.com/docs/it/jetbrains.md#features) è connesso: `"auto"` lo apre nel visualizzatore diff dell'IDE, `"terminal"` lo mantiene nel terminale. Appare in `/config` come **Diff tool** solo mentre Claude Code è connesso a un IDE VS Code o JetBrains.

* **Scope**: [`Global config`](#scopes)
* **Type**: string, uno di:
  * `"auto"`: Claude Code apre il diff nel visualizzatore diff dell'IDE quando un IDE VS Code o JetBrains è connesso
  * `"terminal"`: Claude Code mantiene il diff nel terminale
* **Default**: `"auto"`

```json ~/.claude.json theme={null}
{
  "diffTool": "terminal"
}
```

Claude Code ignora questa chiave in `settings.json`.

### `externalEditorContext`

Quando premi `Ctrl+G`, Claude Code apre il prompt che stai digitando nel tuo [editor esterno](https://code.claude.com/docs/it/interactive-mode.md#general-controls). Con questa chiave attivata, il buffer dell'editor inizia con la risposta precedente di Claude come righe di commento `#`, così puoi leggerla mentre scrivi, e Claude Code rimuove quelle righe quando salvi. Appare in `/config` come **Show last response in external editor**.

* **Scope**: [`Global config`](#scopes)
* **Type**: Boolean
  * `true`: il buffer dell'editor inizia con la risposta precedente di Claude come righe di commento `#`, che Claude Code rimuove quando salvi
  * `false`: il buffer dell'editor si apre solo con il tuo prompt
* **Default**: `false`

```json ~/.claude.json theme={null}
{
  "externalEditorContext": true
}
```

Con questa opzione attivata, il buffer che Claude Code apre assomiglia a questo, e solo il testo sotto la riga del marcatore viene inviato come tuo prompt:

```text theme={null}
# ─── Claude's last response (for reference; removed on save) ───
# I added the retry loop to fetchUser in src/api.ts and a test
# for the timeout case. Want me to wire the same retry into
# fetchOrders?
# ─── Write your reply below this line ──────────────────────────

Yes, and cap it at three attempts.
```

Claude Code mantiene le ultime 50 righe della risposta e contrassegna il taglio con `# … (earlier output truncated)`.

Claude Code ignora questa chiave in `settings.json`.

### `leftArrowOpensAgents`

Premi `←` su un prompt vuoto per [mettere in background la sessione e aprire la vista agente](https://code.claude.com/docs/it/agent-view.md#switch-sessions-without-leaving-the-terminal). Imposta questa chiave su `false` per disattivare la scorciatoia. Appare in `/config` come **← opens agents** quando la vista agente è disponibile.

* **Scope**: [`Global config`](#scopes)
* **Type**: Boolean
  * `true`: premendo `←` su un prompt vuoto in una sessione che hai avviato nel terminale la mette in background e apre la vista agente
  * `false`: Claude Code disattiva la scorciatoia; in una sessione che hai [collegato dalla vista agente](https://code.claude.com/docs/it/agent-view.md#attach-to-a-session), `←` su un prompt vuoto si scollega comunque
* **Default**: `true`

```json ~/.claude.json theme={null}
{
  "leftArrowOpensAgents": false
}
```

Claude Code ignora questa chiave in `settings.json`.

### `permissionExplainerEnabled`

> [!WARNING]
>
> Rimosso nella v2.1.257, insieme al comando di spiegazione `Ctrl+E` sui prompt di autorizzazione Bash e PowerShell. Impostarlo non ha alcun effetto sulle versioni attuali.

Fino alla v2.1.256, potevi premere `Ctrl+E` su un prompt di autorizzazione Bash o PowerShell per vedere una spiegazione generata dal modello del comando, e impostare questa chiave su `false` per disattivare quella scorciatoia.

* **Scope**: [`Global config`](#scopes). Sulla v2.1.256 e precedenti.
* **Type**: Boolean
* **Default**: `true`

### `prStatusFooterEnabled`

Mostra un badge nel footer del prompt per la pull request o merge request aperta del ramo corrente, con una sottolineatura colorata che mostra il suo [stato](https://code.claude.com/docs/it/interactive-mode.md#pr-review-status). Appare in `/config` come **Show PR status footer**.

* **Scope**: [`Global config`](#scopes)
* **Type**: Boolean
  * `true`: il footer mostra il badge secondo le condizioni in [PR review status](https://code.claude.com/docs/it/interactive-mode.md#pr-review-status)
  * `false`: Claude Code salta il controllo della pull request e merge request del footer e non mostra quel badge. Una sessione che hai [collegato dalla vista agente](https://code.claude.com/docs/it/agent-view.md#attach-to-a-session) può comunque mostrare un link semplice a una pull request [collegata ad essa](https://code.claude.com/docs/it/agent-view.md#pull-request-status)
* **Default**: `true`

```json ~/.claude.json theme={null}
{
  "prStatusFooterEnabled": false
}
```

Claude Code ignora questa chiave in `settings.json`.

### `teammateDefaultModel`

> [!WARNING]
>
> Rimosso nella v2.1.234, insieme alla sua riga `/config` **Default teammate model**. Impostarlo non ha alcun effetto sulle versioni attuali.

Fino alla v2.1.233, impostavi questa chiave sul modello per i compagni di squadra del [team agente](https://code.claude.com/docs/it/agent-teams.md#specify-teammates-and-models) che il tuo prompt non ha nominato un modello per: un alias come `"sonnet"`, o `null` per seguire il modello del lead. Per il modello che Claude Code sceglie per tali compagni di squadra ora, vedi [specifica compagni di squadra e modelli](https://code.claude.com/docs/it/agent-teams.md#specify-teammates-and-models).

* **Scope**: [`Global config`](#scopes). Sulla v2.1.233 e precedenti.
* **Type**: string, un alias di modello o ID modello completo, o `null`
* **Default**: unset

## Vedi anche

* [Configurare i permessi](https://code.claude.com/docs/it/permissions.md): sintassi delle regole, modalità di permesso e trust dell'area di lavoro
* [Variabili di ambiente](https://code.claude.com/docs/it/env-vars.md): ogni variabile `CLAUDE_*`, `ANTHROPIC_*` e di provider che Claude Code legge
* [Strumenti disponibili per Claude](https://code.claude.com/docs/it/tools-reference.md): gli strumenti integrati e quali richiedono approvazione
* [File di impostazioni di esempio](https://code.claude.com/docs/it/settings-example.md): un file personale, un file di team e un file gestito da un'organizzazione
* [Configurare le impostazioni gestite](https://code.claude.com/docs/it/admin-setup.md): come le organizzazioni decidono cosa applicare
* [Distribuire le impostazioni gestite](https://code.claude.com/docs/it/managed-settings.md): meccanismi di consegna, precedenza all'interno del livello gestito e voci non valide nelle impostazioni gestite
* [Eseguire il debug della configurazione](https://code.claude.com/docs/it/debug-your-config.md): `claude doctor` e la finestra di dialogo Errore impostazioni
