Pular para o conteúdo principal
O Claude Code oferece uma variedade de configurações para personalizar seu comportamento de acordo com suas necessidades. Você pode configurar o Claude Code executando o comando /config ao usar o REPL interativo, que abre uma interface de Configurações com abas onde você pode visualizar informações de status e modificar opções de configuração.

Escopos de configuração

O Claude Code usa um sistema de escopo para determinar onde as configurações se aplicam e com quem são compartilhadas. Compreender os escopos ajuda você a decidir como configurar o Claude Code para uso pessoal, colaboração em equipe ou implantação empresarial.

Escopos disponíveis

EscopoLocalizaçãoQuem afetaCompartilhado com a equipe?
ManagedConfigurações gerenciadas pelo servidor, plist / registro, ou managed-settings.json em nível de sistemaTodos os usuários na máquinaSim (implantado por TI)
UserDiretório ~/.claude/Você, em todos os projetosNão
Project.claude/ no repositórioTodos os colaboradores neste repositórioSim (confirmado no git)
Local.claude/settings.local.jsonVocê, apenas neste repositórioNão (ignorado pelo git)

Quando usar cada escopo

O escopo Managed é para:
  • Políticas de segurança que devem ser aplicadas em toda a organização
  • Requisitos de conformidade que não podem ser substituídos
  • Configurações padronizadas implantadas por TI/DevOps
O escopo User é melhor para:
  • Preferências pessoais que você deseja em todos os lugares (temas, configurações do editor)
  • Ferramentas e plugins que você usa em todos os projetos
  • Chaves de API e autenticação (armazenadas com segurança)
O escopo Project é melhor para:
  • Configurações compartilhadas pela equipe (permissões, hooks, MCP servers)
  • Plugins que toda a equipe deve ter
  • Padronização de ferramentas entre colaboradores
O escopo Local é melhor para:
  • Substituições pessoais para um projeto específico
  • Testar configurações antes de compartilhar com a equipe
  • Configurações específicas da máquina que não funcionarão para outros

Como os escopos interagem

Quando a mesma configuração é definida em vários escopos, escopos mais específicos têm precedência:
  1. Managed (mais alta) - não pode ser substituída por nada
  2. Argumentos de linha de comando - substituições de sessão temporárias
  3. Local - substitui configurações de projeto e usuário
  4. Project - substitui configurações de usuário
  5. User (mais baixa) - se aplica quando nada mais especifica a configuração
Por exemplo, se uma permissão é permitida nas configurações do usuário, mas negada nas configurações do projeto, a configuração do projeto tem precedência e a permissão é bloqueada.

O que usa escopos

Os escopos se aplicam a muitos recursos do Claude Code:
RecursoLocalização do usuárioLocalização do projetoLocalização local
Settings~/.claude/settings.json.claude/settings.json.claude/settings.local.json
Subagents~/.claude/agents/.claude/agents/Nenhum
MCP servers~/.claude.json.mcp.json~/.claude.json (por projeto)
Plugins~/.claude/settings.json.claude/settings.json.claude/settings.local.json
CLAUDE.md~/.claude/CLAUDE.mdCLAUDE.md ou .claude/CLAUDE.mdNenhum

Arquivos de configuração

O arquivo settings.json é o mecanismo oficial para configurar o Claude Code através de configurações hierárquicas:
  • As configurações do usuário são definidas em ~/.claude/settings.json e se aplicam a todos os projetos.
  • As configurações do projeto são salvas no diretório do seu projeto:
    • .claude/settings.json para configurações que são verificadas no controle de origem e compartilhadas com sua equipe
    • .claude/settings.local.json para configurações que não são verificadas, úteis para preferências pessoais e experimentação. O Claude Code configurará o git para ignorar .claude/settings.local.json quando for criado.
  • Configurações gerenciadas: Para organizações que precisam de controle centralizado, o Claude Code suporta múltiplos mecanismos de entrega para configurações gerenciadas. Todos usam o mesmo formato JSON e não podem ser substituídos por configurações de usuário ou projeto:
    • Configurações gerenciadas pelo servidor: entregues dos servidores da Anthropic através do console de administração do Claude.ai. Veja configurações gerenciadas pelo servidor.
    • Políticas de nível MDM/SO: entregues através do gerenciamento nativo de dispositivos no macOS e Windows:
      • macOS: domínio de preferências gerenciadas com.anthropic.claudecode (implantado via perfis de configuração em Jamf, Kandji ou outras ferramentas MDM)
      • Windows: chave de registro HKLM\SOFTWARE\Policies\ClaudeCode com um valor Settings (REG_SZ ou REG_EXPAND_SZ) contendo JSON (implantado via Política de Grupo ou Intune)
      • Windows (nível de usuário): HKCU\SOFTWARE\Policies\ClaudeCode (prioridade de política mais baixa, usada apenas quando nenhuma fonte de nível de administrador existe)
    • Baseado em arquivo: managed-settings.json e managed-mcp.json implantados em diretórios do sistema:
      • macOS: /Library/Application Support/ClaudeCode/
      • Linux e WSL: /etc/claude-code/
      • Windows: C:\Program Files\ClaudeCode\
      O caminho legado do Windows C:\ProgramData\ClaudeCode\managed-settings.json não é mais suportado a partir da v2.1.75. Administradores que implantaram configurações nesse local devem migrar arquivos para C:\Program Files\ClaudeCode\managed-settings.json.
      Configurações gerenciadas baseadas em arquivo também suportam um diretório drop-in em managed-settings.d/ no mesmo diretório do sistema ao lado de managed-settings.json. Isto permite que equipes separadas implantem fragmentos de política independentes sem coordenar edições em um único arquivo. Seguindo a convenção systemd, managed-settings.json é mesclado primeiro como base, então todos os arquivos *.json no diretório drop-in são classificados alfabeticamente e mesclados por cima. Arquivos posteriores substituem anteriores para valores escalares; arrays são concatenados e desduplicados; objetos são mesclados profundamente. Arquivos ocultos começando com . são ignorados. Use prefixos numéricos para controlar a ordem de mesclagem, por exemplo 10-telemetry.json e 20-security.json.
    Veja configurações gerenciadas e Configuração MCP gerenciada para detalhes.
    Implantações gerenciadas também podem restringir adições ao marketplace de plugins usando strictKnownMarketplaces. Para mais informações, veja Restrições de marketplace gerenciado.
  • Outra configuração é armazenada em ~/.claude.json. Este arquivo contém suas preferências (tema, configurações de notificação, modo do editor), sessão OAuth, configurações de MCP server para escopos de usuário e local, estado por projeto (ferramentas permitidas, configurações de confiança), e vários caches. Os MCP servers com escopo de projeto são armazenados separadamente em .mcp.json.
O Claude Code cria automaticamente backups com timestamp dos arquivos de configuração e retém os cinco backups mais recentes para evitar perda de dados.
Exemplo settings.json
{
  "$schema": "https://json.schemastore.org/claude-code-settings.json",
  "permissions": {
    "allow": [
      "Bash(npm run lint)",
      "Bash(npm run test *)",
      "Read(~/.zshrc)"
    ],
    "deny": [
      "Bash(curl *)",
      "Read(./.env)",
      "Read(./.env.*)",
      "Read(./secrets/**)"
    ]
  },
  "env": {
    "CLAUDE_CODE_ENABLE_TELEMETRY": "1",
    "OTEL_METRICS_EXPORTER": "otlp"
  },
  "companyAnnouncements": [
    "Welcome to Acme Corp! Review our code guidelines at docs.acme.com",
    "Reminder: Code reviews required for all PRs",
    "New security policy in effect"
  ]
}
A linha $schema no exemplo acima aponta para o esquema JSON oficial para configurações do Claude Code. Adicioná-la ao seu settings.json ativa o preenchimento automático e validação inline no VS Code, Cursor e qualquer outro editor que suporte validação de esquema JSON.

Configurações disponíveis

settings.json suporta várias opções:
ChaveDescriçãoExemplo
apiKeyHelperScript personalizado, a ser executado em /bin/sh, para gerar um valor de autenticação. Este valor será enviado como cabeçalhos X-Api-Key e Authorization: Bearer para solicitações de modelo/bin/generate_temp_api_key.sh
autoMemoryDirectoryDiretório personalizado para armazenamento de memória automática. Aceita caminhos expandidos com ~/. Não aceito em configurações de projeto (.claude/settings.json) para evitar que repositórios compartilhados redirecionem escritas de memória para locais sensíveis. Aceito de configurações de política, local e usuário"~/my-memory-dir"
cleanupPeriodDaysSessões inativas por mais tempo que este período são deletadas na inicialização (padrão: 30 dias).

Definir como 0 deleta todas as transcrições existentes na inicialização e desabilita a persistência de sessão completamente. Nenhum novo arquivo .jsonl é escrito, /resume não mostra conversas, e hooks recebem um transcript_path vazio.
20
companyAnnouncementsAnúncio a ser exibido aos usuários na inicialização. Se múltiplos anúncios forem fornecidos, eles serão alternados aleatoriamente.["Welcome to Acme Corp! Review our code guidelines at docs.acme.com"]
envVariáveis de ambiente que serão aplicadas a cada sessão{"FOO": "bar"}
attributionPersonalizar atribuição para commits git e pull requests. Veja Configurações de atribuição{"commit": "🤖 Generated with Claude Code", "pr": ""}
includeCoAuthoredByDescontinuado: Use attribution em vez disso. Se deve incluir a linha co-authored-by Claude em commits git e pull requests (padrão: true)false
includeGitInstructionsIncluir instruções de workflow de commit e PR integradas no prompt do sistema do Claude (padrão: true). Defina como false para remover essas instruções, por exemplo ao usar suas próprias skills de workflow git. A variável de ambiente CLAUDE_CODE_DISABLE_GIT_INSTRUCTIONS tem precedência sobre esta configuração quando definidafalse
permissionsVeja a tabela abaixo para a estrutura de permissões.
autoModePersonalizar o que o classificador de modo automático bloqueia e permite. Contém arrays environment, allow, e soft_deny de regras em prosa. Veja Configurar o classificador de modo automático. Não lido de configurações de projeto compartilhadas{"environment": ["Trusted repo: github.example.com/acme"]}
disableAutoModeDefina como "disable" para impedir que o modo automático seja ativado. Remove auto do ciclo Shift+Tab e rejeita --permission-mode auto na inicialização. Mais útil em configurações gerenciadas onde os usuários não podem substituir"disable"
useAutoModeDuringPlanSe o Plan Mode usa semântica de modo automático quando o modo automático está disponível. Padrão: true. Não lido de configurações de projeto compartilhadas. Aparece em /config como “Use auto mode during plan”false
hooksConfigure comandos personalizados para executar em eventos do ciclo de vida. Veja documentação de hooks para formatoVeja hooks
disableAllHooksDesabilitar todos os hooks e qualquer linha de status personalizadatrue
allowManagedHooksOnly(Apenas configurações gerenciadas) Impedir carregamento de hooks de usuário, projeto e plugin. Apenas permite hooks gerenciados e hooks SDK. Veja Configuração de hookstrue
allowedHttpHookUrlsLista de permissões de padrões de URL que hooks HTTP podem almejar. Suporta * como curinga. Quando definido, hooks com URLs não correspondentes são bloqueados. Indefinido = sem restrição, array vazio = bloquear todos os hooks HTTP. Arrays se mesclam entre fontes de configuração. Veja Configuração de hooks["https://hooks.example.com/*"]
httpHookAllowedEnvVarsLista de permissões de nomes de variáveis de ambiente que hooks HTTP podem interpolar em cabeçalhos. Quando definido, o allowedEnvVars efetivo de cada hook é a interseção com esta lista. Indefinido = sem restrição. Arrays se mesclam entre fontes de configuração. Veja Configuração de hooks["MY_TOKEN", "HOOK_SECRET"]
allowManagedPermissionRulesOnly(Apenas configurações gerenciadas) Impedir que configurações de usuário e projeto definam regras de permissão allow, ask ou deny. Apenas regras em configurações gerenciadas se aplicam. Veja Configurações apenas gerenciadastrue
allowManagedMcpServersOnly(Apenas configurações gerenciadas) Apenas allowedMcpServers de configurações gerenciadas são respeitados. deniedMcpServers ainda se mescla de todas as fontes. Usuários ainda podem adicionar MCP servers, mas apenas a lista de permissões definida pelo administrador se aplica. Veja Configuração MCP gerenciadatrue
modelSubstituir o modelo padrão a usar para Claude Code"claude-sonnet-4-6"
availableModelsRestringir quais modelos os usuários podem selecionar via /model, --model, ferramenta Config, ou ANTHROPIC_MODEL. Não afeta a opção Padrão. Veja Restringir seleção de modelo["sonnet", "haiku"]
modelOverridesMapear IDs de modelo Anthropic para IDs de modelo específicos do provedor, como ARNs de perfil de inferência Bedrock. Cada entrada do seletor de modelo usa seu valor mapeado ao chamar a API do provedor. Veja Substituir IDs de modelo por versão{"claude-opus-4-6": "arn:aws:bedrock:..."}
effortLevelPersistir o nível de esforço entre sessões. Aceita "low", "medium", ou "high". Escrito automaticamente quando você executa /effort low, /effort medium, ou /effort high. Suportado em Opus 4.6 e Sonnet 4.6"medium"
otelHeadersHelperScript para gerar cabeçalhos OpenTelemetry dinâmicos. Executa na inicialização e periodicamente (veja Cabeçalhos dinâmicos)/bin/generate_otel_headers.sh
statusLineConfigure uma linha de status personalizada para exibir contexto. Veja documentação de statusLine{"type": "command", "command": "~/.claude/statusline.sh"}
fileSuggestionConfigure um script personalizado para preenchimento automático de arquivo @. Veja Configurações de sugestão de arquivo{"type": "command", "command": "~/.claude/file-suggestion.sh"}
respectGitignoreControlar se o seletor de arquivo @ respeita padrões .gitignore. Quando true (padrão), arquivos correspondentes a padrões .gitignore são excluídos das sugestõesfalse
outputStyleConfigure um estilo de saída para ajustar o prompt do sistema. Veja documentação de estilos de saída"Explanatory"
agentExecutar a thread principal como um subagent nomeado. Aplica o prompt do sistema, restrições de ferramenta e modelo do subagent. Veja Invocar subagents explicitamente"code-reviewer"
forceLoginMethodUse claudeai para restringir login a contas Claude.ai, console para restringir login a contas Claude Console (faturamento de uso de API)claudeai
forceLoginOrgUUIDEspecificar o UUID de uma organização para selecioná-la automaticamente durante o login, contornando a etapa de seleção de organização. Requer que forceLoginMethod seja definido"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"
enableAllProjectMcpServersAprovar automaticamente todos os MCP servers definidos em arquivos .mcp.json do projetotrue
enabledMcpjsonServersLista de MCP servers específicos de arquivos .mcp.json para aprovar["memory", "github"]
disabledMcpjsonServersLista de MCP servers específicos de arquivos .mcp.json para rejeitar["filesystem"]
channelsEnabled(Apenas configurações gerenciadas) Permitir channels para usuários de Team e Enterprise. Indefinido ou false bloqueia entrega de mensagens de canal independentemente do que os usuários passam para --channelstrue
allowedChannelPlugins(Apenas configurações gerenciadas) Lista de permissões de plugins de canal que podem enviar mensagens. Substitui a lista de permissões padrão da Anthropic quando definido. Indefinido = voltar para o padrão, array vazio = bloquear todos os plugins de canal. Requer channelsEnabled: true. Veja Restringir quais plugins de canal podem executar[{ "marketplace": "claude-plugins-official", "plugin": "telegram" }]
allowedMcpServersQuando definido em managed-settings.json, lista de permissões de MCP servers que os usuários podem configurar. Indefinido = sem restrições, array vazio = bloqueio. Se aplica a todos os escopos. A lista de negação tem precedência. Veja Configuração MCP gerenciada[{ "serverName": "github" }]
deniedMcpServersQuando definido em managed-settings.json, lista de negação de MCP servers que são explicitamente bloqueados. Se aplica a todos os escopos incluindo servers gerenciados. A lista de negação tem precedência sobre a lista de permissões. Veja Configuração MCP gerenciada[{ "serverName": "filesystem" }]
strictKnownMarketplacesQuando definido em managed-settings.json, lista de permissões de marketplaces de plugin que os usuários podem adicionar. Indefinido = sem restrições, array vazio = bloqueio. Se aplica apenas a adições de marketplace. Veja Restrições de marketplace gerenciado[{ "source": "github", "repo": "acme-corp/plugins" }]
blockedMarketplaces(Apenas configurações gerenciadas) Lista de negação de fontes de marketplace. Fontes bloqueadas são verificadas antes do download, então nunca tocam o sistema de arquivos. Veja Restrições de marketplace gerenciado[{ "source": "github", "repo": "untrusted/plugins" }]
pluginTrustMessage(Apenas configurações gerenciadas) Mensagem personalizada anexada ao aviso de confiança de plugin mostrado antes da instalação. Use isto para adicionar contexto específico da organização, por exemplo para confirmar que plugins do seu marketplace interno são verificados."All plugins from our marketplace are approved by IT"
awsAuthRefreshScript personalizado que modifica o diretório .aws (veja configuração avançada de credenciais)aws sso login --profile myprofile
awsCredentialExportScript personalizado que produz JSON com credenciais AWS (veja configuração avançada de credenciais)/bin/generate_aws_grant.sh
alwaysThinkingEnabledAtivar pensamento estendido por padrão para todas as sessões. Tipicamente configurado via comando /config em vez de editar diretamentetrue
plansDirectoryPersonalizar onde os arquivos de plano são armazenados. O caminho é relativo à raiz do projeto. Padrão: ~/.claude/plans"./plans"
showClearContextOnPlanAcceptMostrar a opção “limpar contexto” na tela de aceitação do plano. Padrão: false. Defina como true para restaurar a opçãotrue
spinnerVerbsPersonalizar os verbos de ação mostrados no spinner e mensagens de duração de turno. Defina mode como "replace" para usar apenas seus verbos, ou "append" para adicioná-los aos padrões{"mode": "append", "verbs": ["Pondering", "Crafting"]}
languageConfigure o idioma de resposta preferido do Claude (por exemplo, "japanese", "spanish", "french"). Claude responderá neste idioma por padrão. Também define o idioma de ditado por voz"japanese"
voiceEnabledAtivar ditado por voz push-to-talk. Escrito automaticamente quando você executa /voice. Requer uma conta Claude.aitrue
autoUpdatesChannelCanal de lançamento a seguir para atualizações. Use "stable" para uma versão que é tipicamente cerca de uma semana antiga e pula versões com regressões maiores, ou "latest" (padrão) para o lançamento mais recente"stable"
spinnerTipsEnabledMostrar dicas no spinner enquanto Claude está trabalhando. Defina como false para desabilitar dicas (padrão: true)false
spinnerTipsOverrideSubstituir dicas do spinner com strings personalizadas. tips: array de strings de dica. excludeDefault: se true, mostrar apenas dicas personalizadas; se false ou ausente, dicas personalizadas são mescladas com dicas integradas{ "excludeDefault": true, "tips": ["Use our internal tool X"] }
prefersReducedMotionReduzir ou desabilitar animações de UI (spinners, shimmer, efeitos de flash) para acessibilidadetrue
fastModePerSessionOptInQuando true, o modo rápido não persiste entre sessões. Cada sessão começa com modo rápido desligado, exigindo que os usuários o habilitem com /fast. A preferência de modo rápido do usuário ainda é salva. Veja Exigir opt-in por sessãotrue
teammateModeComo colegas de equipe de agente são exibidos: auto (escolhe painéis divididos em tmux ou iTerm2, em processo caso contrário), in-process, ou tmux. Veja configurar equipes de agente"in-process"
feedbackSurveyRateProbabilidade (0–1) que a pesquisa de qualidade de sessão aparece quando elegível. Defina como 0 para suprimir completamente. Útil ao usar Bedrock, Vertex, ou Foundry onde a taxa de amostra padrão não se aplica0.05

Configurações de config global

Estas configurações são armazenadas em ~/.claude.json em vez de settings.json. Adicioná-las a settings.json acionará um erro de validação de esquema.
ChaveDescriçãoExemplo
autoConnectIdeConectar automaticamente a um IDE em execução quando Claude Code inicia de um terminal externo. Padrão: false. Aparece em /config como Auto-connect to IDE (external terminal) ao executar fora de um terminal VS Code ou JetBrainstrue
autoInstallIdeExtensionInstalar automaticamente a extensão IDE do Claude Code ao executar de um terminal VS Code. Padrão: true. Aparece em /config como Auto-install IDE extension ao executar dentro de um terminal VS Code ou JetBrains. Você também pode definir a variável de ambiente CLAUDE_CODE_IDE_SKIP_AUTO_INSTALLfalse
editorModeModo de atalho de teclado para o prompt de entrada: "normal" ou "vim". Padrão: "normal". Escrito automaticamente quando você executa /vim. Aparece em /config como Key binding mode"vim"
showTurnDurationMostrar mensagens de duração de turno após respostas, por exemplo “Cooked for 1m 6s”. Padrão: true. Aparece em /config como Show turn durationfalse
terminalProgressBarEnabledMostrar a barra de progresso do terminal em terminais suportados: ConEmu, Ghostty 1.2.0+, e iTerm2 3.6.6+. Padrão: true. Aparece em /config como Terminal progress barfalse

Configurações de worktrees

Configure como --worktree cria e gerencia git worktrees. Use estas configurações para reduzir uso de disco e tempo de inicialização em grandes monorepos.
ChaveDescriçãoExemplo
worktree.symlinkDirectoriesDiretórios para criar symlink do repositório principal em cada worktree para evitar duplicar grandes diretórios no disco. Nenhum diretório é criado symlink por padrão["node_modules", ".cache"]
worktree.sparsePathsDiretórios para fazer checkout em cada worktree via git sparse-checkout (modo cone). Apenas os caminhos listados são escritos no disco, o que é mais rápido em grandes monorepos["packages/my-app", "shared/utils"]

Configurações de permissão

ChavesDescriçãoExemplo
allowArray de regras de permissão para permitir uso de ferramenta. Veja Sintaxe de regra de permissão abaixo para detalhes de correspondência de padrão[ "Bash(git diff *)" ]
askArray de regras de permissão para pedir confirmação ao usar ferramenta. Veja Sintaxe de regra de permissão abaixo[ "Bash(git push *)" ]
denyArray de regras de permissão para negar uso de ferramenta. Use isto para excluir arquivos sensíveis do acesso do Claude Code. Veja Sintaxe de regra de permissão e Limitações de permissão Bash[ "WebFetch", "Bash(curl *)", "Read(./.env)", "Read(./secrets/**)" ]
additionalDirectoriesDiretórios de trabalho adicionais que Claude tem acesso[ "../docs/" ]
defaultModeModo de permissão padrão ao abrir Claude Code"acceptEdits"
disableBypassPermissionsModeDefina como "disable" para impedir que o modo bypassPermissions seja ativado. Isto desabilita a flag de linha de comando --dangerously-skip-permissions. Mais útil em configurações gerenciadas onde os usuários não podem substituir"disable"

Sintaxe de regra de permissão

Regras de permissão seguem o formato Tool ou Tool(specifier). Regras são avaliadas em ordem: regras de negação primeiro, depois ask, depois allow. A primeira regra correspondente vence. Exemplos rápidos:
RegraEfeito
BashCorresponde a todos os comandos Bash
Bash(npm run *)Corresponde a comandos começando com npm run
Read(./.env)Corresponde a leitura do arquivo .env
WebFetch(domain:example.com)Corresponde a solicitações de fetch para example.com
Para a referência completa de sintaxe de regra, incluindo comportamento de curinga, padrões específicos de ferramenta para Read, Edit, WebFetch, MCP, e regras de Agent, e limitações de segurança de padrões Bash, veja Sintaxe de regra de permissão.

Configurações de sandbox

Configure comportamento avançado de sandboxing. Sandboxing isola comandos bash do seu sistema de arquivos e rede. Veja Sandboxing para detalhes.
ChavesDescriçãoExemplo
enabledAtivar sandboxing bash (macOS, Linux, e WSL2). Padrão: falsetrue
failIfUnavailableSair com um erro na inicialização se sandbox.enabled é true mas o sandbox não pode iniciar (dependências faltantes, plataforma não suportada, ou restrições de plataforma). Quando false (padrão), um aviso é mostrado e comandos executam sem sandbox. Destinado para implantações de configurações gerenciadas que exigem sandboxing como um portão durotrue
autoAllowBashIfSandboxedAprovar automaticamente comandos bash quando sandboxed. Padrão: truetrue
excludedCommandsComandos que devem executar fora do sandbox["git", "docker"]
allowUnsandboxedCommandsPermitir que comandos executem fora do sandbox via parâmetro dangerouslyDisableSandbox. Quando definido como false, a saída de escape dangerouslyDisableSandbox é completamente desabilitada e todos os comandos devem executar sandboxed (ou estar em excludedCommands). Útil para políticas empresariais que exigem sandboxing rigoroso. Padrão: truefalse
filesystem.allowWriteCaminhos adicionais onde comandos sandboxed podem escrever. Arrays são mesclados em todos os escopos de configuração: caminhos de usuário, projeto e gerenciados são combinados, não substituídos. Também mesclado com caminhos de regras de permissão Edit(...) allow. Veja prefixos de caminho de sandbox abaixo.["/tmp/build", "~/.kube"]
filesystem.denyWriteCaminhos onde comandos sandboxed não podem escrever. Arrays são mesclados em todos os escopos de configuração. Também mesclado com caminhos de regras de permissão Edit(...) deny.["/etc", "/usr/local/bin"]
filesystem.denyReadCaminhos onde comandos sandboxed não podem ler. Arrays são mesclados em todos os escopos de configuração. Também mesclado com caminhos de regras de permissão Read(...) deny.["~/.aws/credentials"]
filesystem.allowReadCaminhos para re-permitir leitura dentro de regiões denyRead. Tem precedência sobre denyRead. Arrays são mesclados em todos os escopos de configuração. Use isto para criar padrões de acesso de leitura apenas para workspace.["."]
filesystem.allowManagedReadPathsOnly(Apenas configurações gerenciadas) Apenas caminhos allowRead de configurações gerenciadas são respeitados. Entradas allowRead de configurações de usuário, projeto e local são ignoradas. Padrão: falsetrue
network.allowUnixSocketsCaminhos de socket Unix acessíveis no sandbox (para agentes SSH, etc.)["~/.ssh/agent-socket"]
network.allowAllUnixSocketsPermitir todas as conexões de socket Unix no sandbox. Padrão: falsetrue
network.allowLocalBindingPermitir vinculação a portas localhost (apenas macOS). Padrão: falsetrue
network.allowedDomainsArray de domínios para permitir para tráfego de rede de saída. Suporta curingas (por exemplo, *.example.com).["github.com", "*.npmjs.org"]
network.allowManagedDomainsOnly(Apenas configurações gerenciadas) Apenas allowedDomains e regras allow WebFetch(domain:...) de configurações gerenciadas são respeitadas. Domínios de configurações de usuário, projeto e local são ignorados. Domínios não permitidos são bloqueados automaticamente sem solicitar o usuário. Domínios negados ainda são respeitados de todas as fontes. Padrão: falsetrue
network.httpProxyPortPorta de proxy HTTP usada se você deseja trazer seu próprio proxy. Se não especificado, Claude executará seu próprio proxy.8080
network.socksProxyPortPorta de proxy SOCKS5 usada se você deseja trazer seu próprio proxy. Se não especificado, Claude executará seu próprio proxy.8081
enableWeakerNestedSandboxAtivar sandbox mais fraco para ambientes Docker sem privilégios (apenas Linux e WSL2). Reduz segurança. Padrão: falsetrue
enableWeakerNetworkIsolation(Apenas macOS) Permitir acesso ao serviço de confiança TLS do sistema (com.apple.trustd.agent) no sandbox. Necessário para ferramentas baseadas em Go como gh, gcloud, e terraform verificarem certificados TLS ao usar httpProxyPort com um proxy MITM e CA personalizada. Reduz segurança abrindo um possível caminho de exfiltração de dados. Padrão: falsetrue

Prefixos de caminho de sandbox

Caminhos em filesystem.allowWrite, filesystem.denyWrite, filesystem.denyRead, e filesystem.allowRead suportam estes prefixos:
PrefixoSignificadoExemplo
/Caminho absoluto da raiz do sistema de arquivos/tmp/build permanece /tmp/build
~/Relativo ao diretório home~/.kube se torna $HOME/.kube
./ ou sem prefixoRelativo à raiz do projeto para configurações de projeto, ou a ~/.claude para configurações de usuário./output em .claude/settings.json resolve para <project-root>/output
O prefixo mais antigo //path para caminhos absolutos ainda funciona. Se você usou anteriormente /path esperando resolução relativa ao projeto, mude para ./path. Esta sintaxe difere de regras de permissão Read e Edit, que usam //path para absoluto e /path para relativo ao projeto. Caminhos de sistema de arquivos de sandbox usam convenções padrão: /tmp/build é um caminho absoluto. Exemplo de configuração:
{
  "sandbox": {
    "enabled": true,
    "autoAllowBashIfSandboxed": true,
    "excludedCommands": ["docker"],
    "filesystem": {
      "allowWrite": ["/tmp/build", "~/.kube"],
      "denyRead": ["~/.aws/credentials"]
    },
    "network": {
      "allowedDomains": ["github.com", "*.npmjs.org", "registry.yarnpkg.com"],
      "allowUnixSockets": [
        "/var/run/docker.sock"
      ],
      "allowLocalBinding": true
    }
  }
}
Restrições de sistema de arquivos e rede podem ser configuradas de duas formas que são mescladas juntas:
  • Configurações sandbox.filesystem (mostradas acima): Controlam caminhos no limite do sandbox de nível de SO. Estas restrições se aplicam a todos os comandos de subprocesso (por exemplo, kubectl, terraform, npm), não apenas às ferramentas de arquivo do Claude.
  • Regras de permissão: Use regras allow/deny Edit para controlar acesso à ferramenta de arquivo do Claude, regras deny Read para bloquear leituras, e regras allow/deny WebFetch para controlar domínios de rede. Caminhos destas regras também são mesclados na configuração do sandbox.

Configurações de atribuição

O Claude Code adiciona atribuição a commits git e pull requests. Estes são configurados separadamente:
  • Commits usam git trailers (como Co-Authored-By) por padrão, que podem ser personalizados ou desabilitados
  • Descrições de pull request são texto simples
ChavesDescrição
commitAtribuição para commits git, incluindo qualquer trailer. String vazia oculta atribuição de commit
prAtribuição para descrições de pull request. String vazia oculta atribuição de pull request
Atribuição de commit padrão:
🤖 Generated with [Claude Code](https://claude.com/claude-code)

   Co-Authored-By: Claude Sonnet 4.6 <[email protected]>
Atribuição de pull request padrão:
🤖 Generated with [Claude Code](https://claude.com/claude-code)
Exemplo:
{
  "attribution": {
    "commit": "Generated with AI\n\nCo-Authored-By: AI <[email protected]>",
    "pr": ""
  }
}
A configuração attribution tem precedência sobre a configuração descontinuada includeCoAuthoredBy. Para ocultar toda atribuição, defina commit e pr como strings vazias.

Configurações de sugestão de arquivo

Configure um comando personalizado para preenchimento automático de caminho de arquivo @. A sugestão de arquivo integrada usa travessia rápida do sistema de arquivos, mas grandes monorepos podem se beneficiar de indexação específica do projeto, como um índice de arquivo pré-construído ou ferramentas personalizadas.
{
  "fileSuggestion": {
    "type": "command",
    "command": "~/.claude/file-suggestion.sh"
  }
}
O comando executa com as mesmas variáveis de ambiente que hooks, incluindo CLAUDE_PROJECT_DIR. Recebe JSON via stdin com um campo query:
{"query": "src/comp"}
Produz caminhos de arquivo separados por nova linha para stdout (atualmente limitado a 15):
src/components/Button.tsx
src/components/Modal.tsx
src/components/Form.tsx
Exemplo:
#!/bin/bash
query=$(cat | jq -r '.query')
your-repo-file-index --query "$query" | head -20

Configuração de hooks

Estas configurações controlam quais hooks são permitidos executar e o que hooks HTTP podem acessar. A configuração allowManagedHooksOnly pode ser configurada apenas em configurações gerenciadas. As listas de permissões de URL e variável de ambiente podem ser definidas em qualquer nível de configuração e se mesclam entre fontes. Comportamento quando allowManagedHooksOnly é true:
  • Hooks gerenciados e hooks SDK são carregados
  • Hooks de usuário, hooks de projeto e hooks de plugin são bloqueados
Restringir URLs de hook HTTP: Limitar quais URLs hooks HTTP podem almejar. Suporta * como curinga para correspondência. Quando o array é definido, hooks HTTP almejando URLs não correspondentes são silenciosamente bloqueados.
{
  "allowedHttpHookUrls": ["https://hooks.example.com/*", "http://localhost:*"]
}
Restringir variáveis de ambiente de hook HTTP: Limitar quais nomes de variáveis de ambiente hooks HTTP podem interpolar em valores de cabeçalho. O allowedEnvVars efetivo de cada hook é a interseção de sua própria lista e esta configuração.
{
  "httpHookAllowedEnvVars": ["MY_TOKEN", "HOOK_SECRET"]
}

Precedência de configurações

Configurações se aplicam em ordem de precedência. De mais alta para mais baixa:
  1. Configurações gerenciadas (gerenciadas pelo servidor, políticas de nível MDM/SO, ou configurações gerenciadas)
    • Políticas implantadas por TI através de entrega de servidor, perfis de configuração MDM, políticas de registro, ou arquivos de configurações gerenciadas
    • Não podem ser substituídas por qualquer outro nível, incluindo argumentos de linha de comando
    • Dentro do nível gerenciado, a precedência é: gerenciadas pelo servidor > políticas de nível MDM/SO > baseadas em arquivo (managed-settings.d/*.json + managed-settings.json) > registro HKCU (apenas Windows). Apenas uma fonte gerenciada é usada; fontes não se mesclam entre camadas. Dentro da camada baseada em arquivo, arquivos drop-in e o arquivo base são mesclados juntos.
  2. Argumentos de linha de comando
    • Substituições temporárias para uma sessão específica
  3. Configurações de projeto local (.claude/settings.local.json)
    • Configurações pessoais específicas do projeto
  4. Configurações de projeto compartilhadas (.claude/settings.json)
    • Configurações de projeto compartilhadas pela equipe no controle de origem
  5. Configurações de usuário (~/.claude/settings.json)
    • Configurações globais pessoais
Esta hierarquia garante que políticas organizacionais sejam sempre aplicadas enquanto ainda permite que equipes e indivíduos personalizem sua experiência. A mesma precedência se aplica se você executar Claude Code a partir da CLI, da extensão VS Code, ou de um IDE JetBrains. Por exemplo, se suas configurações de usuário permitem Bash(npm run *) mas as configurações compartilhadas de um projeto negam, a configuração do projeto tem precedência e o comando é bloqueado.
Configurações de array se mesclam entre escopos. Quando a mesma configuração com valor de array (como sandbox.filesystem.allowWrite ou permissions.allow) aparece em múltiplos escopos, os arrays são concatenados e desduplicados, não substituídos. Isto significa que escopos de prioridade mais baixa podem adicionar entradas sem substituir aquelas definidas por escopos de prioridade mais alta, e vice-versa. Por exemplo, se configurações gerenciadas definem allowWrite como ["/opt/company-tools"] e um usuário adiciona ["~/.kube"], ambos os caminhos são incluídos na configuração final.

Verificar configurações ativas

Execute /status dentro do Claude Code para ver quais fontes de configuração estão ativas e de onde vêm. A saída mostra cada camada de configuração (gerenciada, usuário, projeto) junto com sua origem, como Enterprise managed settings (remote), Enterprise managed settings (plist), Enterprise managed settings (HKLM), ou Enterprise managed settings (file). Se um arquivo de configuração contém erros, /status relata o problema para que você possa corrigi-lo.

Pontos-chave sobre o sistema de configuração

  • Arquivos de memória (CLAUDE.md): Contêm instruções e contexto que Claude carrega na inicialização
  • Arquivos de configuração (JSON): Configurar permissões, variáveis de ambiente, e comportamento de ferramenta
  • Skills: Prompts personalizados que podem ser invocados com /skill-name ou carregados pelo Claude automaticamente
  • MCP servers: Estender Claude Code com ferramentas e integrações adicionais
  • Precedência: Configurações de nível mais alto (Managed) substituem as de nível mais baixo (User/Project)
  • Herança: Configurações são mescladas, com configurações mais específicas adicionando ou substituindo as mais amplas

Prompt do sistema

O prompt do sistema interno do Claude Code não é publicado. Para adicionar instruções personalizadas, use arquivos CLAUDE.md ou a flag --append-system-prompt.

Excluindo arquivos sensíveis

Para impedir que Claude Code acesse arquivos contendo informações sensíveis como chaves de API, segredos, e arquivos de ambiente, use a configuração permissions.deny no seu arquivo .claude/settings.json:
{
  "permissions": {
    "deny": [
      "Read(./.env)",
      "Read(./.env.*)",
      "Read(./secrets/**)",
      "Read(./config/credentials.json)",
      "Read(./build)"
    ]
  }
}
Isto substitui a configuração descontinuada ignorePatterns. Arquivos correspondentes a estes padrões são excluídos da descoberta de arquivo e resultados de busca, e operações de leitura nestes arquivos são negadas.

Configuração de subagent

O Claude Code suporta subagents de IA personalizados que podem ser configurados em níveis de usuário e projeto. Estes subagents são armazenados como arquivos Markdown com frontmatter YAML:
  • Subagents de usuário: ~/.claude/agents/ - Disponíveis em todos os seus projetos
  • Subagents de projeto: .claude/agents/ - Específicos ao seu projeto e podem ser compartilhados com sua equipe
Arquivos de subagent definem assistentes de IA especializados com prompts personalizados e permissões de ferramenta. Saiba mais sobre criação e uso de subagents na documentação de subagents.

Configuração de plugin

O Claude Code suporta um sistema de plugin que permite estender funcionalidade com skills, agents, hooks, e MCP servers. Plugins são distribuídos através de marketplaces e podem ser configurados em níveis de usuário e repositório.

Configurações de plugin

Configurações relacionadas a plugin em settings.json:
{
  "enabledPlugins": {
    "formatter@acme-tools": true,
    "deployer@acme-tools": true,
    "analyzer@security-plugins": false
  },
  "extraKnownMarketplaces": {
    "acme-tools": {
      "source": "github",
      "repo": "acme-corp/claude-plugins"
    }
  }
}

enabledPlugins

Controla quais plugins estão habilitados. Formato: "plugin-name@marketplace-name": true/false Escopos:
  • Configurações de usuário (~/.claude/settings.json): Preferências pessoais de plugin
  • Configurações de projeto (.claude/settings.json): Plugins específicos do projeto compartilhados com equipe
  • Configurações locais (.claude/settings.local.json): Substituições por máquina (não confirmadas)
Exemplo:
{
  "enabledPlugins": {
    "code-formatter@team-tools": true,
    "deployment-tools@team-tools": true,
    "experimental-features@personal": false
  }
}

extraKnownMarketplaces

Define marketplaces adicionais que devem ser disponibilizados para o repositório. Tipicamente usado em configurações em nível de repositório para garantir que membros da equipe tenham acesso a fontes de plugin necessárias. Quando um repositório inclui extraKnownMarketplaces:
  1. Membros da equipe são solicitados a instalar o marketplace quando confiam na pasta
  2. Membros da equipe são então solicitados a instalar plugins daquele marketplace
  3. Usuários podem pular marketplaces ou plugins indesejados (armazenados em configurações de usuário)
  4. Instalação respeita limites de confiança e requer consentimento explícito
Exemplo:
{
  "extraKnownMarketplaces": {
    "acme-tools": {
      "source": {
        "source": "github",
        "repo": "acme-corp/claude-plugins"
      }
    },
    "security-plugins": {
      "source": {
        "source": "git",
        "url": "https://git.example.com/security/plugins.git"
      }
    }
  }
}
Tipos de fonte de marketplace:
  • github: Repositório GitHub (usa repo)
  • git: Qualquer URL git (usa url)
  • directory: Caminho do sistema de arquivos local (usa path, apenas para desenvolvimento)
  • hostPattern: Padrão regex para corresponder hosts de marketplace (usa hostPattern)
  • settings: marketplace inline declarado diretamente em settings.json sem um repositório hospedado separado (usa name e plugins)
Use source: 'settings' para declarar um pequeno conjunto de plugins inline sem configurar um repositório de marketplace hospedado. Plugins listados aqui devem referenciar fontes externas como GitHub ou npm. Você ainda precisa habilitar cada plugin separadamente em enabledPlugins.
{
  "extraKnownMarketplaces": {
    "team-tools": {
      "source": {
        "source": "settings",
        "name": "team-tools",
        "plugins": [
          {
            "name": "code-formatter",
            "source": {
              "source": "github",
              "repo": "acme-corp/code-formatter"
            }
          }
        ]
      }
    }
  }
}

strictKnownMarketplaces

Apenas configurações gerenciadas: Controla quais marketplaces de plugin os usuários podem adicionar. Esta configuração pode ser configurada apenas em configurações gerenciadas e fornece aos administradores controle rigoroso sobre fontes de marketplace. Localizações de arquivo de configurações gerenciadas:
  • macOS: /Library/Application Support/ClaudeCode/managed-settings.json
  • Linux e WSL: /etc/claude-code/managed-settings.json
  • Windows: C:\Program Files\ClaudeCode\managed-settings.json
Características principais:
  • Apenas disponível em configurações gerenciadas (managed-settings.json)
  • Não pode ser substituída por configurações de usuário ou projeto (precedência mais alta)
  • Aplicada ANTES de operações de rede/sistema de arquivos (fontes bloqueadas nunca executam)
  • Usa correspondência exata para especificações de fonte (incluindo ref, path para fontes git), exceto hostPattern, que usa correspondência regex
Comportamento de lista de permissões:
  • undefined (padrão): Sem restrições - usuários podem adicionar qualquer marketplace
  • Array vazio []: Bloqueio completo - usuários não podem adicionar novos marketplaces
  • Lista de fontes: Usuários podem apenas adicionar marketplaces que correspondem exatamente
Todos os tipos de fonte suportados: A lista de permissões suporta múltiplos tipos de fonte de marketplace. A maioria das fontes usa correspondência exata, enquanto hostPattern usa correspondência regex contra o host do marketplace.
  1. Repositórios GitHub:
{ "source": "github", "repo": "acme-corp/approved-plugins" }
{ "source": "github", "repo": "acme-corp/security-tools", "ref": "v2.0" }
{ "source": "github", "repo": "acme-corp/plugins", "ref": "main", "path": "marketplace" }
Campos: repo (obrigatório), ref (opcional: branch/tag/SHA), path (opcional: subdiretório)
  1. Repositórios Git:
{ "source": "git", "url": "https://gitlab.example.com/tools/plugins.git" }
{ "source": "git", "url": "https://bitbucket.org/acme-corp/plugins.git", "ref": "production" }
{ "source": "git", "url": "ssh://[email protected]/plugins.git", "ref": "v3.1", "path": "approved" }
Campos: url (obrigatório), ref (opcional: branch/tag/SHA), path (opcional: subdiretório)
  1. Marketplaces baseados em URL:
{ "source": "url", "url": "https://plugins.example.com/marketplace.json" }
{ "source": "url", "url": "https://cdn.example.com/marketplace.json", "headers": { "Authorization": "Bearer ${TOKEN}" } }
Campos: url (obrigatório), headers (opcional: cabeçalhos HTTP para acesso autenticado)
Marketplaces baseados em URL apenas baixam o arquivo marketplace.json. Eles não baixam arquivos de plugin do servidor. Plugins em marketplaces baseados em URL devem usar fontes externas (URLs GitHub, npm, ou git) em vez de caminhos relativos. Para plugins com caminhos relativos, use um marketplace baseado em Git em vez disso. Veja Troubleshooting para detalhes.
  1. Pacotes NPM:
{ "source": "npm", "package": "@acme-corp/claude-plugins" }
{ "source": "npm", "package": "@acme-corp/approved-marketplace" }
Campos: package (obrigatório, suporta pacotes com escopo)
  1. Caminhos de arquivo:
{ "source": "file", "path": "/usr/local/share/claude/acme-marketplace.json" }
{ "source": "file", "path": "/opt/acme-corp/plugins/marketplace.json" }
Campos: path (obrigatório: caminho absoluto para arquivo marketplace.json)
  1. Caminhos de diretório:
{ "source": "directory", "path": "/usr/local/share/claude/acme-plugins" }
{ "source": "directory", "path": "/opt/acme-corp/approved-marketplaces" }
Campos: path (obrigatório: caminho absoluto para diretório contendo .claude-plugin/marketplace.json)
  1. Correspondência de padrão de host:
{ "source": "hostPattern", "hostPattern": "^github\\.example\\.com$" }
{ "source": "hostPattern", "hostPattern": "^gitlab\\.internal\\.example\\.com$" }
Campos: hostPattern (obrigatório: padrão regex para corresponder contra o host do marketplace) Use correspondência de padrão de host quando você deseja permitir todos os marketplaces de um host específico sem enumerar cada repositório individualmente. Isto é útil para organizações com GitHub Enterprise interno ou servidores GitLab onde desenvolvedores criam seus próprios marketplaces. Extração de host por tipo de fonte:
  • github: sempre corresponde contra github.com
  • git: extrai nome de host da URL (suporta formatos HTTPS e SSH)
  • url: extrai nome de host da URL
  • npm, file, directory: não suportado para correspondência de padrão de host
Exemplos de configuração: Exemplo: permitir apenas marketplaces específicos:
{
  "strictKnownMarketplaces": [
    {
      "source": "github",
      "repo": "acme-corp/approved-plugins"
    },
    {
      "source": "github",
      "repo": "acme-corp/security-tools",
      "ref": "v2.0"
    },
    {
      "source": "url",
      "url": "https://plugins.example.com/marketplace.json"
    },
    {
      "source": "npm",
      "package": "@acme-corp/compliance-plugins"
    }
  ]
}
Exemplo - Desabilitar todas as adições de marketplace:
{
  "strictKnownMarketplaces": []
}
Exemplo: permitir todos os marketplaces de um servidor git interno:
{
  "strictKnownMarketplaces": [
    {
      "source": "hostPattern",
      "hostPattern": "^github\\.example\\.com$"
    }
  ]
}
Requisitos de correspondência exata: Fontes de marketplace devem corresponder exatamente para que a adição de um usuário seja permitida. Para fontes baseadas em git (github e git), isto inclui todos os campos opcionais:
  • O repo ou url deve corresponder exatamente
  • O campo ref deve corresponder exatamente (ou ambos serem indefinidos)
  • O campo path deve corresponder exatamente (ou ambos serem indefinidos)
Exemplos de fontes que NÃO correspondem:
// Estas são DIFERENTES fontes:
{ "source": "github", "repo": "acme-corp/plugins" }
{ "source": "github", "repo": "acme-corp/plugins", "ref": "main" }

// Estas também são DIFERENTES:
{ "source": "github", "repo": "acme-corp/plugins", "path": "marketplace" }
{ "source": "github", "repo": "acme-corp/plugins" }
Comparação com extraKnownMarketplaces:
AspectostrictKnownMarketplacesextraKnownMarketplaces
PropósitoAplicação de política organizacionalConveniência da equipe
Arquivo de configuraçãoApenas managed-settings.jsonQualquer arquivo de configuração
ComportamentoBloqueia adições não permitidasAuto-instala marketplaces faltantes
Quando aplicadoAntes de operações de rede/sistema de arquivosApós prompt de confiança do usuário
Pode ser substituídoNão (precedência mais alta)Sim (por configurações de precedência mais alta)
Formato de fonteObjeto de fonte diretoMarketplace nomeado com fonte aninhada
Caso de usoConformidade, restrições de segurançaOnboarding, padronização
Diferença de formato: strictKnownMarketplaces usa objetos de fonte diretos:
{
  "strictKnownMarketplaces": [
    { "source": "github", "repo": "acme-corp/plugins" }
  ]
}
extraKnownMarketplaces requer marketplaces nomeados:
{
  "extraKnownMarketplaces": {
    "acme-tools": {
      "source": { "source": "github", "repo": "acme-corp/plugins" }
    }
  }
}
Usando ambos juntos: strictKnownMarketplaces é um portão de política: controla o que os usuários podem adicionar mas não registra nenhum marketplace. Para restringir e pré-registrar um marketplace para todos os usuários, defina ambos em managed-settings.json:
{
  "strictKnownMarketplaces": [
    { "source": "github", "repo": "acme-corp/plugins" }
  ],
  "extraKnownMarketplaces": {
    "acme-tools": {
      "source": { "source": "github", "repo": "acme-corp/plugins" }
    }
  }
}
Com apenas strictKnownMarketplaces definido, usuários ainda podem adicionar o marketplace permitido manualmente via /plugin marketplace add, mas não está disponível automaticamente. Notas importantes:
  • Restrições são verificadas ANTES de qualquer solicitação de rede ou operação de sistema de arquivos
  • Quando bloqueado, usuários veem mensagens de erro claras indicando que a fonte é bloqueada por política gerenciada
  • A restrição se aplica apenas a adição de NOVOS marketplaces; marketplaces previamente instalados permanecem acessíveis
  • Configurações gerenciadas têm a precedência mais alta e não podem ser substituídas
Veja Restrições de marketplace gerenciado para documentação voltada para o usuário.

Gerenciando plugins

Use o comando /plugin para gerenciar plugins interativamente:
  • Procurar plugins disponíveis de marketplaces
  • Instalar/desinstalar plugins
  • Habilitar/desabilitar plugins
  • Ver detalhes de plugin (comandos, agents, hooks fornecidos)
  • Adicionar/remover marketplaces
Saiba mais sobre o sistema de plugin na documentação de plugins.

Variáveis de ambiente

Variáveis de ambiente permitem controlar o comportamento do Claude Code sem editar arquivos de configuração. Qualquer variável também pode ser configurada em settings.json sob a chave env para aplicá-la a cada sessão ou implantá-la para sua equipe. Veja a referência de variáveis de ambiente para a lista completa.

Ferramentas disponíveis para Claude

O Claude Code tem acesso a um conjunto de ferramentas para leitura, edição, busca, execução de comandos, e orquestração de subagents. Nomes de ferramenta são as strings exatas que você usa em regras de permissão e correspondedores de hook. Veja a referência de ferramentas para a lista completa e detalhes de comportamento da ferramenta Bash.

Veja também

  • Permissões: sistema de permissões, sintaxe de regra, padrões específicos de ferramenta, e políticas gerenciadas
  • Autenticação: configurar acesso de usuário ao Claude Code
  • Troubleshooting: soluções para problemas comuns de configuração