SpyBara
Go Premium

plugins-reference.md 2026-09-08 20:00 UTC to 2026-09-09 22:58 UTC

This page contains 436 additions and 313 deletions.

2026
Wed 9 22:58 Thu 10 23:00 Sat 12 03:02 Fri 18 23:58 Tue 22 23:59 Wed 23 23:57 Fri 25 23:58

Plugins reference

Riferimento tecnico completo per il sistema di plugin di Claude Code, inclusi schemi, comandi CLI e specifiche dei componenti.

Un plugin è una directory autonoma di componenti che estende Claude Code con funzionalità personalizzate. I componenti del plugin includono skills, agents, hooks, server MCP, server LSP e monitor.

Riferimento dei componenti del plugin

Skills

I plugin aggiungono skills a Claude Code, creando scorciatoie /name che tu o Claude potete invocare.

Posizione: directory skills/ o commands/ nella radice del plugin, oppure un singolo file SKILL.md nella radice del plugin

Formato file: Gli skills sono directory con SKILL.md; i commands sono semplici file markdown

Struttura skill:

skills/
├── pdf-processor/
│   ├── SKILL.md
│   ├── reference.md (opzionale)
│   └── scripts/ (opzionale)
└── code-reviewer/
    └── SKILL.md

Gli skills e i commands vengono rilevati automaticamente quando il plugin viene installato.

Se un plugin non ha una directory skills/ e nessun campo manifest skills, un SKILL.md nella radice del plugin viene caricato come un singolo skill. Impostare il campo frontmatter name per controllare il nome di invocazione dello skill. Senza di esso, Claude Code ricade al nome della directory di installazione, che per i plugin installati dal marketplace è una stringa di versione che cambia ad ogni aggiornamento. Per i plugin che forniscono più di uno skill, utilizzare il layout della directory skills/ mostrato sopra.

Negli skills e nei commands del plugin, i campi frontmatter booleani come disable-model-invocation accettano yes, no, on, off, 1 e 0 in qualsiasi caso di lettera, oltre a true e false. Prima della v2.1.218, Claude Code riconosceva solo true e false.

Per i dettagli completi, vedere Skills.

Agents

I plugin possono fornire subagent specializzati per compiti specifici che Claude può invocare automaticamente quando appropriato.

Posizione: directory agents/ nella radice del plugin

Formato file: File markdown che descrivono le capacità dell'agent

Struttura agent:

---
name: agent-name
description: In cosa si specializza questo agent e quando Claude dovrebbe invocarlo
model: sonnet
effort: medium
maxTurns: 20
disallowedTools: Write, Edit
---

Prompt di sistema dettagliato per l'agent che descrive il suo ruolo, competenza e comportamento.

Gli agent del plugin supportano i campi frontmatter name, description, model, effort, maxTurns, tools, disallowedTools, skills, memory, background e isolation. L'unico valore isolation valido è "worktree". Per motivi di sicurezza, hooks, mcpServers e permissionMode non sono supportati per gli agent forniti dal plugin.

Claude Code carica un agent del plugin anche quando il suo frontmatter non ha name o non viene analizzato:

  • Nessun name: Claude Code nomina l'agent in base al file, quindi agents/reviewer.md in un plugin denominato my-plugin viene caricato come my-plugin:reviewer
  • Frontmatter che non viene analizzato: Claude Code nomina l'agent in base al file, utilizza Agent from my-plugin plugin come sua descrizione e ignora ogni campo nel file

Al contrario, Claude Code salta un file di progetto, utente o agent gestito il cui frontmatter non ha name o non viene analizzato.

Per trovare i file nella directory agents/ predefinita di un plugin il cui frontmatter non viene analizzato, eseguire claude plugin validate. Il percorso che passi dipende dal fatto che il plugin abbia un manifest, e entrambi gli esempi utilizzano ./my-plugin come directory del plugin:

  • Un plugin con un manifest: claude plugin validate ./my-plugin
  • Un plugin senza un manifest: claude plugin validate ./my-plugin/agents. Richiede Claude Code v2.1.233 o successivo.

Gli agent vengono visualizzati nella typeahead @-mention con il loro nome con scope, come my-plugin:code-reviewer, una volta che il plugin è abilitato.

Per i dettagli completi, vedere Subagent.

Hooks

I plugin possono fornire gestori di eventi che rispondono automaticamente agli eventi di Claude Code.

Posizione: hooks/hooks.json nella radice del plugin, oppure inline in plugin.json

Formato: Configurazione JSON con matcher di eventi e azioni

Configurazione hook:

{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Write|Edit",
        "hooks": [
          {
            "type": "command",
            "command": "\"${CLAUDE_PLUGIN_ROOT}\"/scripts/format-code.sh"
          }
        ]
      }
    ]
  }
}

Gli hook del plugin rispondono agli stessi eventi del ciclo di vita degli hook definiti dall'utente:

Event When it fires
SessionStart When a session begins or resumes
Setup When you start Claude Code with --init-only, or with --init or --maintenance in -p mode. For one-time preparation in CI or scripts
UserPromptSubmit When you submit a prompt, before Claude processes it
UserPromptExpansion When a user-typed command expands into a prompt, before it reaches Claude. Can block the expansion
PreToolUse Before a tool call executes. Can block it
PermissionRequest When a tool call needs a permission decision
PermissionDenied When auto mode denies a tool call, including denials without a classifier verdict. Use JSON hookSpecificOutput.retry: true to tell the model it may retry the denied tool call. Claude Code ignores retry when the classifier produced no verdict
PostToolUse After a tool call succeeds
PostToolUseFailure After a tool call fails
PostToolBatch After a full batch of parallel tool calls resolves, before the next model call
Notification When Claude Code sends a notification
MessageDisplay While assistant message text is displayed
SubagentStart When a subagent is spawned
SubagentStop When a subagent finishes
TaskCreated When a task is being created via TaskCreate
TaskCompleted When a task is being marked as completed
Stop When Claude finishes responding
StopFailure When the turn ends due to an API error
TeammateIdle When an agent team teammate is about to go idle
InstructionsLoaded When a CLAUDE.md or .claude/rules/*.md file is loaded into context. Fires at session start and when files are lazily loaded during a session
ConfigChange When a configuration file changes during a session
CwdChanged When the working directory changes, for example when Claude executes a cd command. Useful for reactive environment management with tools like direnv
DirectoryAdded When a working directory is added mid-session via /add-dir or the SDK register_repo_root control request
FileChanged When a watched file changes on disk. The matcher field specifies which filenames to watch
WorktreeCreate When a worktree is being created via --worktree, isolation: "worktree", or for a background session. Replaces default git behavior
WorktreeRemove When a worktree is being removed at session exit, when a subagent finishes, or when you delete a background session
PreCompact Before context compaction
PostCompact After context compaction completes
PreModelSwitch Before Claude Code applies a model switch that you or a client requested. Can block the switch
PostModelSwitch After the session's model changes, including changes Claude Code makes on its own, such as restoring the model when you resume a session
Elicitation When an MCP server requests user input during a tool call
ElicitationResult After a user responds to an MCP elicitation, before the response is sent back to the server
SessionEnd When a session terminates

Tipi di hook:

  • command: eseguire comandi shell o script
  • http: inviare l'evento JSON come richiesta POST a un URL
  • mcp_tool: chiamare uno strumento su un server MCP configurato
  • prompt: valutare un prompt con un LLM (utilizza il placeholder $ARGUMENTS per il contesto)
  • agent: eseguire un verificatore agentico con strumenti per compiti di verifica complessi

Gli hook che puntano al server MCP bundled del plugin devono utilizzare i suoi nomi con scope. I matcher di strumenti e i campi if prendono il nome dello strumento con scope mcp__plugin_<plugin-name>_<server-name>__<tool>, e il campo server di un hook mcp_tool prende plugin:<plugin-name>:<server-name>. Un matcher scritto contro la chiave del server nuda non si attiva mai. Vedere Match MCP tools e Plugin-provided MCP servers.

MCP servers

I plugin possono raggruppare server Model Context Protocol (MCP) per connettere Claude Code con strumenti e servizi esterni.

Posizione: .mcp.json nella radice del plugin, oppure inline in plugin.json

Formato: Configurazione standard del server MCP

Configurazione del server MCP:

{
  "mcpServers": {
    "plugin-database": {
      "command": "${CLAUDE_PLUGIN_ROOT}/servers/db-server",
      "args": ["--config", "${CLAUDE_PLUGIN_ROOT}/config.json"],
      "env": {
        "DB_PATH": "${CLAUDE_PLUGIN_ROOT}/data"
      }
    },
    "plugin-api-client": {
      "command": "npx",
      "args": ["@company/mcp-server", "--plugin-mode"]
    }
  }
}

Comportamento di integrazione:

  • I server MCP del plugin si avviano automaticamente quando il plugin è abilitato
  • I server vengono visualizzati come strumenti MCP standard nel toolkit di Claude
  • I server del plugin possono essere configurati indipendentemente dai server MCP dell'utente
  • Se esegui /reload-plugins a metà sessione, Claude Code mantiene le connessioni live dei server la cui configurazione è invariata

LSP servers

I plugin possono fornire server Language Server Protocol (LSP) per dare a Claude intelligenza del codice in tempo reale mentre lavori sulla tua codebase.

Posizione: .lsp.json nella radice del plugin, oppure inline in plugin.json

Formato: Configurazione JSON che mappa i nomi dei server di linguaggio alle loro configurazioni

Formato file .lsp.json:

{
  "go": {
    "command": "gopls",
    "args": ["serve"],
    "extensionToLanguage": {
      ".go": "go"
    }
  }
}

Inline in plugin.json:

{
  "name": "my-plugin",
  "lspServers": {
    "go": {
      "command": "gopls",
      "args": ["serve"],
      "extensionToLanguage": {
        ".go": "go"
      }
    }
  }
}

Campi obbligatori:

Field Description
command Il binario LSP da eseguire (deve essere in PATH)
extensionToLanguage Mappa le estensioni di file agli identificatori di linguaggio

Campi opzionali:

Field Description
args Argomenti della riga di comando per il server LSP
transport Trasporto di comunicazione: stdio (predefinito) o socket. Claude Code accetta socket ma esegue ogni server su stdio, quindi le regole del protocollo stdout si applicano a tutti i server
env Variabili di ambiente da impostare all'avvio del server
initializationOptions Opzioni passate al server durante l'inizializzazione
settings Impostazioni passate tramite workspace/didChangeConfiguration
workspaceFolder Percorso della cartella di lavoro per il server
startupTimeout Tempo massimo di attesa per l'avvio del server (millisecondi)
shutdownTimeout Tempo massimo di attesa per l'arresto graduale (millisecondi). Quando il timeout scade, Claude Code termina il processo del server. Se non impostato, non si applica alcun timeout
restartOnCrash Se riavviare il server dopo un crash. Predefinito su true. Impostare su false per lasciare un server bloccato fermo invece di riavviarlo
maxRestarts Numero massimo di tentativi di riavvio prima di rinunciare
diagnostics Se inserire la diagnostica nel contesto di Claude dopo le modifiche (predefinito true). Impostare su false per mantenere la navigazione del codice ma sopprimere l'iniezione automatica della diagnostica.

restartOnCrash e shutdownTimeout richiedono Claude Code v2.1.205 o successivo. Prima della v2.1.205, lo schema di configurazione accettava entrambe le opzioni ma l'impostazione di una di esse causava a Claude Code di saltare completamente quel server LSP all'avvio, con il motivo visibile solo nell'output di claude --debug.

Più server per la stessa estensione: quando più di un server LSP abilitato dichiara la stessa estensione di file in extensionToLanguage, indipendentemente dal fatto che i server provengano da un plugin o da plugin diversi, il primo server registrato gestisce i file con quell'estensione e gli altri non si avviano mai. L'interfaccia /plugin mostra un avviso che nomina il plugin il cui server è attivo.

Server che non riescono a inizializzare: Claude Code salta un server la cui configurazione non è valida, ad esempio uno che manca command o extensionToLanguage, e gli altri server configurati si avviano comunque. Eseguire claude --debug per vedere perché un server è stato saltato.

Un server saltato non rivendica le sue estensioni di file, quindi un altro server valido che dichiara la stessa estensione, dallo stesso plugin o da un plugin diverso, gestisce comunque quei file.

Invia l'output del log a stderr, non a stdout: Claude Code legge lo stdout di un server solo come messaggi di protocollo e accetta intestazioni di messaggi fino a 64 KiB e un corpo di messaggio fino a 32 MiB. Claude Code disconnette un server che supera uno dei due limiti o scrive output non-protocollo a stdout, e conta la disconnessione come un crash per restartOnCrash e maxRestarts. Quando esegui con --debug, Claude Code scrive un errore che nomina la causa nel log di debug.

Plugin LSP disponibili:

Plugin Language server Install command
pyright-lsp Pyright (Python) pip install pyright o npm install -g pyright
typescript-lsp TypeScript Language Server npm install -g typescript-language-server typescript
rust-analyzer-lsp rust-analyzer Vedi rust-analyzer installation

Installa il server di linguaggio per primo, quindi installa il plugin dal marketplace.

Monitors

I plugin possono dichiarare monitor in background che Claude Code avvia automaticamente quando il plugin è attivo. Ogni monitor esegue un comando shell per la durata della sessione e fornisce ogni riga stdout a Claude come notifica, in modo che Claude possa reagire alle voci di log, ai cambiamenti di stato o agli eventi sondati senza essere chiesto di avviare il watch stesso.

I monitor del plugin utilizzano lo stesso meccanismo dello strumento Monitor e condividono i suoi vincoli di disponibilità. Vengono eseguiti solo in sessioni CLI interattive, vengono eseguiti senza sandbox allo stesso livello di fiducia degli hook e vengono saltati su host dove lo strumento Monitor non è disponibile.

Posizione: monitors/monitors.json nella radice del plugin, oppure inline in plugin.json

Formato: Array JSON di voci di monitor

Il seguente monitors/monitors.json osserva un endpoint di stato di distribuzione e un log di errore locale:

[
  {
    "name": "deploy-status",
    "command": "\"${CLAUDE_PLUGIN_ROOT}\"/scripts/poll-deploy.sh",
    "description": "Deployment status changes"
  },
  {
    "name": "error-log",
    "command": "tail -F ./logs/error.log",
    "description": "Application error log",
    "when": "on-skill-invoke:debug"
  }
]

Per dichiarare monitor inline, impostare experimental.monitors in plugin.json sullo stesso array. Per caricare da un percorso non predefinito, impostare experimental.monitors su una stringa di percorso relativo come "./config/monitors.json". I monitor sono un componente sperimentale.

Campi obbligatori:

Field Description
name Identificatore univoco all'interno del plugin. Previene processi duplicati quando il plugin si ricarica o uno skill viene invocato di nuovo
command Comando shell eseguito come processo in background persistente nella directory di lavoro della sessione
description Breve riepilogo di ciò che viene osservato. Mostrato nel pannello attività e nei riepiloghi delle notifiche

Campi opzionali:

Field Description
when Controlla quando il monitor si avvia. "always" lo avvia all'avvio della sessione e al ricaricamento del plugin, ed è il predefinito. "on-skill-invoke:<skill-name>" lo avvia la prima volta che lo skill denominato in questo plugin viene inviato

Il valore command supporta le sostituzioni di percorso ${CLAUDE_PLUGIN_ROOT}, ${CLAUDE_PLUGIN_DATA} e ${CLAUDE_PROJECT_DIR}, più qualsiasi ${ENV_VAR} dall'ambiente. Prefisso il comando con cd "${CLAUDE_PLUGIN_ROOT}" && se lo script deve essere eseguito dalla directory del plugin stesso.

Un command di monitor non può fare riferimento ai valori ${user_config.*}. Il comando viene eseguito attraverso una shell, quindi Claude Code rifiuta il monitor con un errore invece di sostituire il valore. I processi di monitor non ricevono variabili di ambiente CLAUDE_PLUGIN_OPTION_<KEY>, quindi fai in modo che lo script di monitor legga il valore da un file di configurazione che possiede.

Se disabiliti un plugin a metà sessione, Claude Code non interrompe i monitor che sono già in esecuzione; si fermano quando la sessione termina.

Themes

I plugin possono fornire temi di colore che vengono visualizzati in /theme insieme ai preset integrati e ai temi locali dell'utente. Un tema è un file JSON in themes/ con un preset base e una mappa sparsa overrides di token di colore. I temi sono un componente sperimentale.

{
  "name": "Dracula",
  "base": "dark",
  "overrides": {
    "claude": "#bd93f9",
    "error": "#ff5555",
    "success": "#50fa7b"
  }
}

Quando un utente seleziona un tema del plugin, Claude Code salva custom:<plugin-name>:<slug> nella sua configurazione. I temi del plugin sono di sola lettura: quando un utente preme Ctrl+E su uno in /theme, Claude Code lo copia in ~/.claude/themes/ in modo che possano modificare la copia.

Ambiti di installazione dei plugin

Quando installi un plugin, scegli un ambito che determina dove il plugin è disponibile e chi altro può utilizzarlo:

Ambito File di configurazione Caso d'uso
user ~/.claude/settings.json Plugin personali disponibili in tutti i progetti (predefinito)
project .claude/settings.json Plugin del team condivisi tramite controllo versione
local .claude/settings.local.json Plugin specifici del progetto, ignorati da git quando Claude Code salva un'impostazione in esso
managed Managed settings Plugin gestiti (sola lettura, solo aggiornamento)

I plugin utilizzano lo stesso sistema di ambiti di altre configurazioni di Claude Code. Per le istruzioni di installazione e i flag di ambito, vedi Install plugins. Per una spiegazione completa degli ambiti, vedi Configuration scopes.

Plugin della directory skills

Qualsiasi cartella sotto una directory skills che contiene un manifest .claude-plugin/plugin.json viene caricata come plugin denominato <name>@skills-dir nella sessione successiva, senza marketplace e senza passaggio di installazione. Creane uno con plugin init. A differenza di un'installazione marketplace copiata, il plugin viene scoperto sul posto piuttosto che copiato nella cache dei plugin.

Un albero di directory skills supporta tre cose distinte:

Quello che hai Che cosa è
<skills-dir>/foo/SKILL.md senza manifest Una semplice skill denominata foo
<skills-dir>/foo/.claude-plugin/plugin.json Un plugin foo@skills-dir, che può raggruppare le proprie skills, agenti, hooks e altro
<plugin>/skills/bar/SKILL.md Una skill bar inclusa in un plugin

Scegli da dove il plugin viene caricato

Directory skills Ambito Carica
~/.claude/skills/ personale In ogni progetto, poiché la posizione è solo tua
<cwd>/.claude/skills/ progetto Solo dopo che accetti la finestra di dialogo di trust per quella cartella

Un plugin con ambito progetto viene archiviato nel repository e raggiunge ogni collaboratore che lo clona. Poiché quel contenuto proviene dal repository piuttosto che da te, viene caricato solo dopo lo stesso gate di trust che governa le regole di autorizzazione del progetto in .claude/settings.json, quindi fidarsi di una cartella padre o eseguire con -p non è sufficiente, e i componenti che eseguono codice sono ulteriormente limitati:

I plugin con ambito personale non hanno nessuna di queste restrizioni.

Modifica, ricarica e disabilita un plugin della directory skills

Le modifiche che apporti al SKILL.md di una skill hanno effetto immediato nella sessione corrente. Le modifiche agli altri componenti del plugin, come hooks/, .mcp.json, agents/ e output-styles/, non lo fanno. Esegui /reload-plugins o riavvia Claude Code per caricarli. Vedi Live change detection.

Per smettere di caricare un plugin della directory skills, elimina la sua cartella o disabilitalo per nome. Non c'è un passaggio uninstall perché nulla è stato installato da un marketplace.

claude plugin disable my-tool@skills-dir

Plugin sincronizzati da claude.ai

In Cowork e sessioni cloud, Claude Code scarica i plugin abilitati per il vostro account claude.ai in ~/.claude/plugins/synced/ nell'ambiente della sessione stessa e carica ciascuno come <name>@synced, senza marketplace e senza record di installazione. Claude Code non li carica nelle sessioni che avviate nel vostro terminale. All'interno di quell'ambiente Cowork o cloud, claude plugin list mostra le copie scaricate sotto un'intestazione Synced from claude.ai. Prima della v2.1.239, Claude Code caricava questi plugin come <name>@inline, l'identità che i plugin --plugin-dir utilizzano.

Gestite un plugin sincronizzato tramite l'ID <name>@synced che claude plugin list stampa:

  • Disabilitarne uno: nella sessione sincronizzata, eseguite claude plugin disable <name>@synced, oppure chiedete a Claude di eseguirlo. Claude Code salva la scelta come "<name>@synced": false nel enabledPlugins a livello di utente di quell'ambiente. Per riabilitare il plugin, eseguite claude plugin enable <name>@synced nella stessa sessione. Per escludere un plugin da ogni sessione sincronizzata, disabilitatelo per il vostro account claude.ai. Per escluderlo dalle sessioni sincronizzate di un progetto in ogni ambiente, impostate "<name>@synced": false sotto enabledPlugins nel .claude/settings.json committato del progetto.
  • Gestite il plugin stesso su claude.ai: claude plugin install, update e uninstall non si applicano a un plugin sincronizzato. Per rimuoverne uno, disabilitate il plugin per il vostro account claude.ai; la prossima sessione sincronizzata inizierà senza di esso.

Quando un plugin abilitato da qualsiasi altra fonte, come un'installazione da marketplace, un plugin skills-directory, o un plugin --plugin-dir, corrisponde al nome di un plugin sincronizzato, Claude Code carica quel plugin e segnala la copia sincronizzata come non caricata. Per utilizzare la copia da claude.ai, disabilitate la vostra copia. Prima della v2.1.239, Claude Code caricava la copia sincronizzata al posto di un'installazione da marketplace con lo stesso nome.

Schema del manifest del plugin

Il file .claude-plugin/plugin.json definisce i metadati e la configurazione del plugin.

Il manifest è facoltativo. Se omesso, Claude Code scopre automaticamente i componenti nelle posizioni predefinite e deriva il nome del plugin dal nome della directory. Utilizzare un manifest quando è necessario fornire metadati o percorsi di componenti personalizzati.

Schema completo 

{
  "name": "plugin-name",
  "displayName": "Plugin Name",
  "version": "1.2.0",
  "description": "Brief plugin description",
  "author": {
    "name": "Author Name",
    "email": "author@example.com",
    "url": "https://github.com/author"
  },
  "homepage": "https://docs.example.com/plugin",
  "repository": "https://github.com/author/plugin",
  "license": "MIT",
  "keywords": ["keyword1", "keyword2"],
  "metadata": { "catalogId": "cat-123", "tier": "pro" },
  "skills": "./custom/skills/",
  "commands": ["./custom/commands/special.md"],
  "agents": ["./custom/agents/reviewer.md"],
  "hooks": "./config/hooks.json",
  "mcpServers": "./mcp-config.json",
  "outputStyles": "./styles/",
  "lspServers": "./.lsp.json",
  "experimental": {
    "themes": "./themes/",
    "monitors": "./monitors.json"
  },
  "dependencies": [
    "helper-lib",
    { "name": "secrets-vault", "version": "~2.1.0" }
  ]
}

Campi obbligatori

Se si include un manifest, name è l'unico campo obbligatorio.

Campo Tipo Descrizione Esempio
name string Identificatore univoco in kebab-case, senza spazi, caratteri di controllo o caratteri di formattazione bidirezionali. Quando una voce del marketplace elenca il plugin con un nome diverso, il nome della voce del marketplace è quello utilizzato da enabledPlugins e /plugin "deployment-tools"

Questo nome viene utilizzato per lo spazio dei nomi dei componenti. Ad esempio, nell'interfaccia utente, l'agente agent-creator per il plugin con nome plugin-dev apparirà come plugin-dev:agent-creator.

Campi non riconosciuti

Claude Code ignora i campi di primo livello che non riconosce. È possibile mantenere i metadati da un altro ecosistema in plugin.json e il plugin si carica comunque. Questo rende pratico mantenere un unico manifest che funziona sia come manifest di VS Code o Cursor, come package.json npm, o come manifest di bundle MCPB/DXT.

claude plugin validate segnala i campi non riconosciuti come avvisi, non come errori. Se un campo è uno o due caratteri diverso da uno riconosciuto, l'avviso suggerisce il nome probabilmente inteso. Un plugin con solo avvisi di campi non riconosciuti passa comunque la convalida e si carica al runtime.

Il modo in cui Claude Code gestisce un campo riconosciuto il cui valore ha il tipo sbagliato dipende dal campo:

  • La maggior parte dei campi: il plugin non si carica. Ad esempio, un valore keywords che è una stringa invece di un array è un errore di caricamento, e claude plugin validate lo segnala come tale.
  • experimental e metadata: Claude Code ignora un valore non-oggetto, e claude plugin validate segnala un avviso.

Passare --strict per trattare gli avvisi come errori. Utilizzarlo in CI per rilevare un nome di campo scritto male o un campo rimasto da un manifest di un altro strumento prima della pubblicazione, anche se il plugin si caricherà al runtime.

claude plugin validate ./my-plugin --strict

Campi di metadati

Campo Tipo Descrizione Esempio
$schema string URL dello schema JSON per l'autocompletamento e la convalida dell'editor. Claude Code ignora questo campo al momento del caricamento. "https://json.schemastore.org/claude-code-plugin-manifest.json"
displayName string Nome leggibile mostrato nel selettore /plugin e in altre superfici dell'interfaccia utente. Ritorna a name quando omesso. A differenza di name, può contenere spazi e qualsiasi maiuscola/minuscola. Non utilizzato per lo spazio dei nomi o la ricerca. "Deployment Tools"
version string Facoltativo. Versione semantica. L'impostazione di questa opzione fissa il plugin a quella stringa di versione, quindi gli utenti ricevono aggiornamenti solo quando la si incrementa, ad eccezione di una command source; vedere Gestione delle versioni. Se impostato anche nella voce del marketplace, plugin.json vince. Se omesso, la versione proviene dalla prossima fonte in Gestione delle versioni. "2.1.0"
description string Breve spiegazione dello scopo del plugin "Deployment automation tools"
author object Informazioni sull'autore {"name": "Dev Team", "email": "dev@company.com"}
homepage string URL della documentazione "https://docs.example.com"
repository string URL del codice sorgente "https://github.com/user/plugin"
license string Identificatore della licenza "MIT", "Apache-2.0"
keywords array Tag di scoperta ["deployment", "ci-cd"]
metadata object Oggetto in formato libero per i propri dati, come campi di diritto o catalogo. Claude Code non lo legge, quindi i valori non influiscono mai sul comportamento del plugin. Claude Code ignora un valore non-oggetto, e claude plugin validate lo segnala come avviso. Prima della v2.1.222, Claude Code trattava la chiave come un campo non riconosciuto. {"catalogId": "cat-123"}
defaultEnabled boolean Se il plugin inizia in uno stato abilitato quando l'utente non ne ha impostato uno. Predefinito a true. Vedere Abilitazione predefinita. false

Abilitazione predefinita

Impostare defaultEnabled: false in plugin.json per distribuire un plugin che si installa disabilitato. L'utente lo attiva con claude plugin enable <plugin> o l'interfaccia /plugin. Utilizzare questa opzione per i plugin che aggiungono costi o ambito a cui un utente dovrebbe acconsentire esplicitamente, come uno che si connette a un servizio esterno.

defaultEnabled è il fallback quando nient'altro ha deciso lo stato del plugin. Due cose hanno la precedenza su di esso:

  • L'impostazione dell'utente: una voce per il plugin in enabledPlugins in qualsiasi ambito di impostazioni. Una volta scritta, persiste tra gli aggiornamenti e le reinstallazioni del plugin, quindi modificare defaultEnabled in una versione successiva non capovolge un utente esistente.
  • Un requisito di dipendenza: quando un plugin è richiesto da un altro che è attivo, Claude Code scrive true per esso al momento dell'installazione o dell'abilitazione. Questo gli dà un'impostazione esplicita, quindi il suo valore predefinito non si applica più. Vedere Abilitare o disabilitare un plugin con dipendenze.

Lo stesso campo può apparire nella voce del marketplace di un plugin, dove ha la precedenza sul valore in plugin.json. Vedere Campi plugin facoltativi.

Campi del percorso del componente

Campo Tipo Descrizione Esempio
skills string|array Directory di skill personalizzate contenenti <name>/SKILL.md. Si aggiunge alla scansione predefinita skills/. Vedere Regole di comportamento del percorso per l'eccezione della radice del marketplace "./custom/skills/"
commands string|array File di skill .md flat personalizzati o directory (sostituisce il valore predefinito commands/) "./custom/cmd.md" o ["./cmd1.md"]
agents string|array File di agenti personalizzati (sostituisce il valore predefinito agents/) "./custom/agents/reviewer.md"
workflows string|array File di script workflow personalizzati o directory (sostituisce il valore predefinito workflows/) "./custom/workflows/"
hooks string|array|object Percorsi di configurazione hook o configurazione inline "./my-extra-hooks.json"
mcpServers string|array|object Percorsi di configurazione MCP o configurazione inline "./my-extra-mcp-config.json"
outputStyles string|array File/directory di stili di output personalizzati (sostituisce il valore predefinito output-styles/) "./styles/"
lspServers string|array|object Configurazioni Language Server Protocol per l'intelligenza del codice (vai a definizione, trova riferimenti, ecc.) "./.lsp.json"
experimental.themes string|array File/directory di temi colore (sostituisce il valore predefinito themes/). Vedere Temi "./themes/"
experimental.monitors string|array Configurazioni di Monitor in background che si avviano automaticamente quando il plugin è attivo. Vedere Monitor "./monitors.json"
userConfig object Valori configurabili dall'utente richiesti al momento dell'abilitazione. Vedere Configurazione utente Vedere di seguito
channels array Dichiarazioni di canale per l'iniezione di messaggi (stile Telegram, Slack, Discord). Vedere Canali Vedere di seguito
dependencies array Altri plugin richiesti da questo plugin, facoltativamente con vincoli di versione semver. Vedere Vincolare le versioni delle dipendenze del plugin [{ "name": "secrets-vault", "version": "~2.1.0" }]

Componenti sperimentali

I componenti sotto la chiave experimental, themes e monitors, hanno uno schema di manifest che potrebbe cambiare tra le versioni mentre si stabilizzano. Dove li si dichiara è una migrazione separata: il livello superiore funziona ancora, claude plugin validate avverte, e una versione futura richiederà experimental.*.

Configurazione utente

Il campo userConfig dichiara i valori per i quali Claude Code richiede all'utente quando il plugin è abilitato. Utilizzare questa opzione invece di richiedere agli utenti di modificare manualmente settings.json.

{
  "userConfig": {
    "api_endpoint": {
      "type": "string",
      "title": "API endpoint",
      "description": "Your team's API endpoint"
    },
    "api_token": {
      "type": "string",
      "title": "API token",
      "description": "API authentication token",
      "sensitive": true
    }
  }
}

Le chiavi devono essere identificatori validi. Ogni opzione supporta questi campi:

Campo Obbligatorio Descrizione
type Sì Uno di string, number, boolean, directory, o file
title Sì Etichetta mostrata nella finestra di dialogo di configurazione
description Sì Testo di aiuto mostrato sotto il campo
sensitive No Se true, maschera l'input e memorizza il valore nell'archiviazione sicura invece di settings.json
required No Se true, la convalida fallisce quando il campo è vuoto
default No Valore utilizzato quando l'utente non fornisce nulla
multiple No Per il tipo string, consenti un array di stringhe
min / max No Limiti per il tipo number

Ogni valore è disponibile per la sostituzione come ${user_config.KEY} nelle configurazioni del server MCP e LSP e nei comandi hook. I valori non sensibili possono anche essere sostituiti nel contenuto di skill e agenti. Tutti i valori vengono esportati ai processi hook come variabili di ambiente CLAUDE_PLUGIN_OPTION_<KEY>, dove <KEY> è la chiave dell'opzione in maiuscolo.

I campi che vengono eseguiti in una shell rifiutano ${user_config.*}: sostituire un valore configurato in un comando shell consentirebbe alla shell di eseguire qualsiasi cosa contenga quel valore, quindi il componente fallisce con un errore invece. Ogni campo rifiutato ha un modo alternativo per passare il valore:

Campo rifiutato Come passare il valore
Comandi hook in forma shell Utilizzare forma exec con args, o leggere CLAUDE_PLUGIN_OPTION_<KEY> dall'ambiente del hook
Comandi Monitor Leggere il valore da un file di configurazione nello script
MCP headersHelper Leggere il valore da un file di configurazione nello script

Prima della v2.1.207, questi campi sostituivano i valori ${user_config.KEY}; aggiornare i plugin che si basavano su questo.

I valori non sensibili vengono memorizzati sotto la chiave pluginConfigs nel file settings.json dell'utente come pluginConfigs[<plugin-id>].options.

Su macOS, Claude Code memorizza i valori sensibili nel Portachiavi di macOS, ricadendo su ~/.claude/.credentials.json quando il Portachiavi rifiuta la scrittura. Su piattaforme senza un portachiavi supportato, li memorizza in ~/.claude/.credentials.json. L'archiviazione del Portachiavi è condivisa con i token OAuth e ha un limite totale approssimativo di 2 KB, quindi mantenere i valori sensibili piccoli.

Claude Code legge tutti i valori pluginConfigs da solo tre fonti di impostazioni:

  • Impostazioni utente: ~/.claude/settings.json, il file in cui la richiesta al momento dell'abilitazione scrive
  • --settings: il flag CLI o le impostazioni inline SDK
  • Impostazioni gestite: politica controllata dall'organizzazione

Quando più di una fonte imposta la stessa chiave, le impostazioni gestite hanno la precedenza, quindi --settings, quindi le impostazioni utente. L'unica fonte che è possibile rimuovere da questo elenco è le impostazioni utente: passare --setting-sources senza user e Claude Code le salta. Le impostazioni gestite e --settings rimangono qualsiasi cosa si passi. L'opzione settingSources dell'SDK imposta lo stesso elenco.

Le voci nel file .claude/settings.json o .claude/settings.local.json di un progetto vengono ignorate. Entrambi i file si trovano nell'area di lavoro, quindi un repository clonato potrebbe fornire valori lì, e quei valori fluirebbero nei comandi hook del plugin, nelle configurazioni del server MCP, nei comandi LSP e nei comandi monitor. Prima della v2.1.207, queste voci venivano lette. La restrizione è specifica per pluginConfigs: enabledPlugins onora ancora le impostazioni del progetto e locali.

Canali

Il campo channels consente a un plugin di dichiarare uno o più canali di messaggi che iniettano contenuto nella conversazione. Ogni canale si associa a un server MCP fornito dal plugin.

{
  "channels": [
    {
      "server": "telegram",
      "userConfig": {
        "bot_token": {
          "type": "string",
          "title": "Bot token",
          "description": "Telegram bot token",
          "sensitive": true
        },
        "owner_id": {
          "type": "string",
          "title": "Owner ID",
          "description": "Your Telegram user ID"
        }
      }
    }
  ]
}

Il campo server è obbligatorio e deve corrispondere a una chiave in mcpServers del plugin. L'opzionale userConfig per canale utilizza lo stesso schema del campo di primo livello, consentendo al plugin di richiedere token bot o ID proprietario quando il plugin è abilitato.

Regole di comportamento del percorso

Se un percorso personalizzato sostituisce o estende la directory predefinita del plugin dipende dal campo:

  • Sostituisce il valore predefinito: commands, agents, workflows, outputStyles, experimental.themes, experimental.monitors. Ad esempio, quando il manifest specifica commands, la directory predefinita commands/ non viene scansionata. Per mantenere il valore predefinito e aggiungerne altri, elencarli esplicitamente: "commands": ["./commands/", "./extras/"]
  • Si aggiunge al valore predefinito: skills. La directory predefinita skills/ viene sempre scansionata, e le directory elencate in skills vengono caricate insieme ad essa. Eccezione: per una voce del marketplace la cui source si risolve nella radice del marketplace, dichiarare sottodirectory specifiche sostituisce la scansione predefinita skills/
  • Regole di merge proprie: hooks, server MCP, e server LSP. Vedere ogni sezione per come più fonti si combinano

Quando un plugin ha sia una cartella predefinita che la chiave manifest corrispondente, Claude Code avverte sulla cartella ignorata in claude plugin list e nella vista dei dettagli /plugin. Il plugin si carica comunque utilizzando i percorsi del manifest. Claude Code non avverte quando la chiave manifest punta nella cartella predefinita, ad esempio "commands": ["./commands/deploy.md"], perché quel percorso nomina la cartella esplicitamente.

Per tutti i campi del percorso:

  • Tutti i percorsi devono essere relativi alla radice del plugin e iniziare con ./, tranne che il campo skills accetta anche "."
    • Sia "." che "./" denotano la radice del plugin stesso
    • Prima della v2.1.221, "." falliva la convalida del manifest e il plugin non si caricava, quindi utilizzare "./" per supportare versioni precedenti
  • I componenti da percorsi personalizzati utilizzano le stesse regole di denominazione e spazio dei nomi
  • Più percorsi possono essere specificati come array
  • Un percorso di skill può puntare a una directory che contiene direttamente un SKILL.md, ad esempio "skills": ["."] per la radice del plugin
    • Claude Code prende il nome di invocazione della skill dal campo frontmatter name in SKILL.md, quindi il nome rimane stabile indipendentemente da come viene denominata la directory di installazione
    • Se name non è impostato nel frontmatter, Claude Code ritorna al nome della directory di base

Un plugin che ha un SKILL.md alla sua radice, nessuna sottodirectory skills/, e nessun campo manifest skills viene caricato automaticamente come plugin a skill singola. Non è necessario impostare "skills": ["./"] in plugin.json per questo layout.

Esempi di percorso:

{
  "commands": [
    "./specialized/deploy.md",
    "./utilities/batch-process.md"
  ],
  "agents": [
    "./custom-agents/reviewer.md",
    "./custom-agents/tester.md"
  ]
}

Variabili di ambiente

Claude Code fornisce tre variabili per fare riferimento ai percorsi:

Variabile Si risolve in Utilizzarla per
${CLAUDE_PLUGIN_ROOT} Percorso assoluto della directory di installazione del plugin Script, binari e file di configurazione forniti con il plugin
${CLAUDE_PLUGIN_DATA} Directory persistente che sopravvive agli aggiornamenti del plugin, creata al primo riferimento Dipendenze installate come node_modules o ambienti virtuali Python, codice generato e cache
${CLAUDE_PROJECT_DIR} La radice del progetto Script e file di configurazione locali del progetto

Tutti e tre vengono esportati come variabili di ambiente ai processi hook e ai sottoprocessi del server MCP e LSP. Quali campi sostituiscono inline dipende dal componente del plugin:

Componente del plugin Campi dove i placeholder si risolvono
Contenuto di skill e agenti Ovunque appaia il placeholder
Comandi hook e monitor Ovunque appaia il placeholder
Server MCP stdio command, args, env
Server MCP http, sse, ws url, headers, headersHelper
Server LSP command, args, env, workspaceFolder

Nei comandi hook, utilizzare forma exec con args in modo che ogni percorso venga passato come un argomento senza virgolette. Negli hook in forma shell e nei comandi monitor, racchiudere le variabili tra virgolette doppie, come in "${CLAUDE_PROJECT_DIR}/scripts/server.sh". Questo hook in forma shell esegue uno script fornito con un plugin:

{
  "hooks": {
    "PostToolUse": [
      {
        "hooks": [
          {
            "type": "command",
            "command": "\"${CLAUDE_PLUGIN_ROOT}\"/scripts/process.sh"
          }
        ]
      }
    ]
  }
}

${CLAUDE_PLUGIN_ROOT} cambia quando il plugin si aggiorna. La directory della versione precedente rimane su disco per un periodo di grazia dopo un aggiornamento, ma trattarla come effimera e non scrivere stato lì. Vedere plugin caching per la semantica di pulizia.

Quando un plugin si aggiorna a metà sessione, i comandi hook, i monitor, i server MCP e i server LSP continuano a utilizzare il percorso della versione precedente. Eseguire /reload-plugins per passare i hook, i server MCP e i server LSP al nuovo percorso; i monitor richiedono un riavvio della sessione. In una sessione senza un terminale interattivo, il ricaricamento lascia i server MCP del plugin sul percorso precedente fino alla sessione successiva.

Per un plugin con una command source, Claude Code può ricaricare il plugin stesso.

I server MCP possono anche chiamare la richiesta roots/list per leggere le directory di lavoro della sessione al runtime. Vedere cosa restituisce roots/list e quando Claude Code notifica al server i cambiamenti.

Directory di dati persistenti

La directory ${CLAUDE_PLUGIN_DATA} si risolve in ~/.claude/plugins/data/{id}/, dove {id} è l'identificatore del plugin con caratteri al di fuori di a-z, A-Z, 0-9, _, e - sostituiti da -. Per un plugin installato come formatter@my-marketplace, la directory è ~/.claude/plugins/data/formatter-my-marketplace/.

Un uso comune è installare le dipendenze del linguaggio una volta e riutilizzarle tra sessioni e aggiornamenti del plugin. Utilizzarla per le dipendenze Python, le dipendenze bloccate con Yarn o pnpm, e i pacchetti i cui script del ciclo di vita devono essere eseguiti. Per un plugin installato dal marketplace, potrebbe non essere necessario affatto: Claude Code installa automaticamente le dipendenze del pacchetto Node.js idonee quando memorizza il plugin nella cache.

Poiché la directory di dati sopravvive a qualsiasi singola versione del plugin, un controllo per l'esistenza della directory da solo non può rilevare quando un aggiornamento cambia il manifest delle dipendenze del plugin. Il modello consigliato confronta il manifest fornito con una copia nella directory di dati e reinstalla quando differiscono.

Questo hook SessionStart installa node_modules alla prima esecuzione e di nuovo ogni volta che un aggiornamento del plugin include un package.json modificato:

{
  "hooks": {
    "SessionStart": [
      {
        "hooks": [
          {
            "type": "command",
            "command": "diff -q \"${CLAUDE_PLUGIN_ROOT}/package.json\" \"${CLAUDE_PLUGIN_DATA}/package.json\" >/dev/null 2>&1 || (cd \"${CLAUDE_PLUGIN_DATA}\" && cp \"${CLAUDE_PLUGIN_ROOT}/package.json\" . && npm install) || rm -f \"${CLAUDE_PLUGIN_DATA}/package.json\""
          }
        ]
      }
    ]
  }
}

Il diff esce con codice diverso da zero quando la copia memorizzata è mancante o differisce da quella fornita, coprendo sia la prima esecuzione che gli aggiornamenti che cambiano le dipendenze. Se npm install fallisce, il trailing rm rimuove il manifest copiato in modo che la sessione successiva riprovi.

Gli script forniti in ${CLAUDE_PLUGIN_ROOT} possono quindi essere eseguiti contro il node_modules persistente:

{
  "mcpServers": {
    "routines": {
      "command": "node",
      "args": ["${CLAUDE_PLUGIN_ROOT}/server.js"],
      "env": {
        "NODE_PATH": "${CLAUDE_PLUGIN_DATA}/node_modules"
      }
    }
  }
}

La directory di dati viene eliminata automaticamente quando si disinstalla il plugin dall'ultimo ambito in cui è installato. L'interfaccia /plugin mostra la dimensione della directory e richiede conferma prima di eliminare. La CLI elimina per impostazione predefinita; passare --keep-data per preservarla.

Caching dei plugin e risoluzione dei file

I plugin vengono specificati in uno di due modi:

  • Tramite claude --plugin-dir o claude --plugin-url, per la durata di una sessione.
  • Tramite un marketplace, installato per sessioni future.

Per motivi di sicurezza e verifica, Claude Code copia i plugin del marketplace nella cache dei plugin locale dell'utente (~/.claude/plugins/cache) piuttosto che utilizzarli sul posto, ad eccezione delle command sources in link mode, che Claude Code utilizza sul posto tramite link nella voce della cache.

Per i plugin copiati, ogni versione installata è una directory separata nella cache, raggruppata per marketplace e plugin e denominata per la versione risolta, con la propria copia dei file del plugin e delle dipendenze dei pacchetti Node.js. Una dipendenza risolta da un release tag ottiene un nome di directory con un suffisso commit-SHA.

Quando aggiornate o disinstallate un plugin, Claude Code contrassegna la directory della versione precedente come orfana e la rimuove in una scansione in background approssimativamente 14 giorni dopo. Il periodo di grazia consente alle sessioni di Claude Code concorrenti che hanno già caricato la versione precedente di continuare a funzionare senza errori. Claude Code esegue la scansione solo mentre è installato almeno un plugin; dopo aver disinstallato l'ultimo plugin, le directory orfane rimangono su disco fino a quando non installate di nuovo un plugin.

Claude Code rimuove una cartella di plugin o marketplace dalla cache solo quando non contiene più alcuna directory o symlink. Se create un symlink di uno sviluppo locale nella cache come voce di versione di un plugin, Claude Code non contrassegna mai il link come orfano e non lo rimuove mai né le cartelle che lo contengono. Claude Code inoltre non scrive mai i suoi file di tracciamento delle versioni all'interno del checkout collegato.

Gli strumenti Glob e Grep di Claude saltano le directory delle versioni orfane durante le ricerche, quindi i risultati dei file non includono codice di plugin obsoleto.

Dipendenze dei pacchetti Node.js

Quando Claude Code copia un plugin nella cache, installa anche le dipendenze dei pacchetti Node.js del plugin lì, in modo che gli hook e i server MCP del plugin possano caricarli. Questa sezione copre i pacchetti npm e Bun che un plugin dichiara nel suo package.json. Per i plugin che dipendono da altri plugin, vedere versioni delle dipendenze dei plugin.

Claude Code esegue l'installazione all'interno della directory della versione copiata ogni volta che ne crea una: quando installate un plugin, quando Claude Code aggiorna un plugin a una nuova versione, e all'inizio della sessione quando un plugin abilitato non è ancora memorizzato nella cache, ad esempio su una nuova macchina. L'installazione viene eseguita solo quando la directory root del plugin contiene sia un package.json che un lockfile supportato:

Lockfile Comando
bun.lock o bun.lockb bun install --frozen-lockfile --ignore-scripts
npm-shrinkwrap.json o package-lock.json npm ci --ignore-scripts

Se un plugin contiene più di uno di questi lockfile, Claude Code utilizza la prima corrispondenza, controllando in ordine: bun.lock, bun.lockb, npm-shrinkwrap.json, package-lock.json. Claude Code salta yarn.lock e pnpm-lock.yaml perché Yarn e pnpm supportano hook di configurazione in fase di risoluzione che bypassano --ignore-scripts.

Fornite un lockfile npm per la portata più ampia. Claude Code esegue il gestore di pacchetti del lockfile corrispondente dal PATH dell'utente e non esegue il fallback all'altro lockfile se manca. Per un plugin distribuito tramite una fonte npm, utilizzate npm-shrinkwrap.json; npm esclude package-lock.json dai pacchetti pubblicati.

Claude Code vincola questa installazione di dipendenze in modo che nessun codice dal plugin o dai suoi pacchetti venga eseguito durante essa, e limita quanto tempo può durare:

  • Risoluzione congelata: Bun e npm installano esattamente ciò che il lockfile fissa, e falliscono piuttosto che ri-risolvere le versioni quando package.json e il lockfile non concordano.
  • Nessuno script del ciclo di vita: --ignore-scripts impedisce l'esecuzione degli script preinstall, install e postinstall, in modo che le dipendenze che compilano moduli nativi in questi script scarichino ma non compilino durante questa installazione.
  • Timeout di 60 secondi: Claude Code interrompe un'installazione che dura più a lungo e la tratta come non riuscita.

Il recupero di un plugin da fonte npm stesso esegue npm install con script del ciclo di vita abilitati, prima che questa installazione di dipendenze venga eseguita.

Un'installazione non riuscita o saltata non blocca mai il plugin. Quando l'installazione fallisce, o Claude Code salta un lockfile yarn o pnpm, registra il motivo come avviso nell'output di debug. Un plugin con un package.json e nessun lockfile viene saltato senza una voce di log. Un'installazione scaduta può lasciare un albero node_modules parziale nella copia memorizzata nella cache.

Non potete disattivare l'installazione automatica; nessuna impostazione o variabile di ambiente la disabilita. In reti ristrette, vedere i requisiti di accesso alla rete per gli host da consentire.

Per le dipendenze che l'installazione automatica non può fornire, come pacchetti che necessitano dei loro script del ciclo di vita per compilare, dipendenze Python, o un plugin bloccato con Yarn o pnpm, installatele da un hook nella directory dei dati persistenti.

Limitazioni dell'attraversamento dei percorsi

Claude Code non consente a un plugin di fare riferimento a file al di fuori della sua stessa directory. Rifiuta un percorso di componente che si risolve al di fuori della root del plugin, indipendentemente dal fatto che il percorso sia dichiarato in plugin.json o in una voce del marketplace. Ciò copre un percorso che punta al di fuori del plugin come scritto, come ../shared-utils, e un symlink che porta al di fuori del plugin, ad eccezione dei link all'interno di un marketplace.

Quando Claude Code rifiuta un percorso, segnala un errore path escapes plugin directory e carica il plugin senza quel componente.

Claude Code inoltre non copia i file al di fuori della directory del plugin nella cache quando installa il plugin, quindi quando uno script all'interno di un plugin copiato legge un percorso sopra la root del plugin, non trova nemmeno quei file.

Se il vostro plugin ha bisogno di condividere file con altre parti dello stesso marketplace, potete creare link simbolici all'interno della directory del vostro plugin. Il modo in cui un symlink viene gestito quando il plugin viene copiato nella cache dipende da dove si risolve il suo target:

  • All'interno della directory del plugin: il symlink viene preservato come symlink relativo nella cache, in modo che continui a risolvere il target copiato in fase di esecuzione.
  • Altrove all'interno dello stesso marketplace: il symlink viene dereferenziato. Il contenuto del target viene copiato nella cache al suo posto. Ciò consente alla directory skills/ di un meta-plugin di collegarsi alle skill definite da altri plugin nel marketplace.
  • Al di fuori del marketplace: il symlink viene saltato per motivi di sicurezza. Ciò impedisce ai plugin di estrarre file host arbitrari come percorsi di sistema nella cache.

Per i plugin installati con --plugin-dir, da un percorso locale, o da una command source in copy mode, solo i symlink che si risolvono all'interno della directory del plugin stesso vengono preservati. Tutti gli altri vengono saltati.

Il seguente comando crea un link dall'interno di un plugin del marketplace a una skill condivisa definita da un plugin sibling. Su Windows, utilizzate mklink /D da un Command Prompt elevato o abilitate Developer Mode:

ln -s ../../shared-plugin/skills/foo ./skills/foo

Struttura della directory dei plugin

Layout standard dei plugin

Un plugin completo segue questa struttura:

enterprise-plugin/
├── .claude-plugin/           # Directory dei metadati (opzionale)
│   └── plugin.json             # plugin manifest
├── skills/                   # Skills
│   ├── code-reviewer/
│   │   └── SKILL.md
│   └── pdf-processor/
│       ├── SKILL.md
│       └── scripts/
├── commands/                 # Skills come file .md flat
│   ├── status.md
│   └── logs.md
├── agents/                   # Definizioni dei subagent
│   ├── security-reviewer.md
│   ├── performance-tester.md
│   └── compliance-checker.md
├── workflows/                # Script dei workflow
│   └── release-audit.js
├── output-styles/            # Definizioni dello stile di output
│   └── terse.md
├── themes/                   # Definizioni dei temi colore
│   └── dracula.json
├── monitors/                 # Configurazioni dei monitor in background
│   └── monitors.json
├── hooks/                    # Configurazioni degli hook
│   ├── hooks.json           # Configurazione principale degli hook
│   └── security-hooks.json  # Hook aggiuntivi
├── bin/                      # Eseguibili del plugin aggiunti a PATH
│   └── my-tool               # Invocabile come comando bare in Bash tool
├── settings.json            # Impostazioni predefinite per il plugin
├── .mcp.json                # Definizioni dei server MCP
├── .lsp.json                # Configurazioni dei server LSP
├── scripts/                 # Script degli hook e script di utilità
│   ├── security-scan.sh
│   ├── format-code.py
│   └── deploy.js
├── LICENSE                  # File di licenza
└── CHANGELOG.md             # Cronologia delle versioni

Un file CLAUDE.md nella radice del plugin non viene caricato come contesto del progetto. I plugin contribuiscono al contesto attraverso skills, agents e hooks piuttosto che tramite CLAUDE.md. Per fornire istruzioni che si carichino nel contesto di Claude, inseritele in una skill.

Riferimento delle posizioni dei file

Componente Posizione predefinita Scopo
Manifest .claude-plugin/plugin.json Metadati e configurazione del plugin (opzionale)
Skills skills/ Skills con struttura <name>/SKILL.md
Commands commands/ Skills come file Markdown flat. Utilizzare skills/ per i nuovi plugin
Agents agents/ File Markdown dei subagent
Workflows workflows/ File script dei Workflow
Output styles output-styles/ Definizioni dello stile di output
Themes themes/ Definizioni dei temi colore
Hooks hooks/hooks.json Configurazione degli hook
Server MCP .mcp.json Definizioni dei server MCP
Server LSP .lsp.json Configurazioni dei language server
Monitors monitors/monitors.json Configurazioni dei monitor in background
Eseguibili bin/ Eseguibili aggiunti al PATH del Bash tool e invocabili come comandi bare mentre il plugin è abilitato. Non è possibile includere questa directory in un plugin che distribuite attraverso le impostazioni dell'organizzazione claude.ai
Impostazioni settings.json Configurazione predefinita applicata quando il plugin è abilitato. Sono supportate solo le chiavi agent e subagentStatusLine

Riferimento dei comandi CLI

Claude Code fornisce comandi CLI per la gestione non interattiva dei plugin, utili per scripting e automazione.

plugin init

Crea lo scaffolding di un nuovo plugin in ~/.claude/skills/<name>/. Nella prossima sessione di Claude Code si carica automaticamente come <name>@skills-dir e appare in /plugin e claude plugin list senza alcun passaggio di installazione.

Vedi Skills-directory plugins per i requisiti di ambito e fiducia.

claude plugin init <name> [options]

Argomenti:

  • <name>: Nome del plugin. Diventa lo spazio dei nomi della skill e il nome della directory sotto ~/.claude/skills/, quindi non può contenere spazi o separatori di percorso.

Opzioni:

Opzione Descrizione Predefinito
--description <text> Descrizione del manifest
--author <name> Nome dell'autore git config user.name
--author-email <email> Email dell'autore git config user.email
--with <components...> Crea anche lo scaffolding delle cartelle dei componenti. Valori validi: skills, agents, hooks, mcp, lsp, output-style, channel
-f, --force Sovrascrivi un .claude-plugin/ esistente nel target
-h, --help Visualizza la guida per il comando

Alias: new

Ogni valore --with aggiunge un file di avvio per quel componente, pronto per essere modificato:

Componente Cosa crea lo scaffolding
skills Una skill aggiuntiva con spazio dei nomi <name>:example insieme a quella predefinita
agents Una definizione di subagent in agents/
hooks Un hooks/hooks.json con un gestore di eventi di esempio
mcp Un .mcp.json con esempi di server HTTP e stdio
lsp Un esempio di language-server .lsp.json
output-style Un output-styles/<name>.md che si applica automaticamente mentre il plugin è abilitato
channel Un channel basato su MCP: un server stdio (server.ts), il suo .mcp.json e un package.json

Il plugin creato con lo scaffolding utilizza la fonte @skills-dir piuttosto che un marketplace. Gli amministratori possono bloccare questa fonte con strictKnownMarketplaces o aggiungendo {"source": "skills-dir"} a blockedMarketplaces nelle impostazioni gestite. Quando bloccato, plugin init fallisce prima di scrivere.

Esempi:

# Crea lo scaffolding di un plugin minimo
claude plugin init my-helper

# Crea lo scaffolding con cartelle skill e hook
claude plugin init my-helper --with skills hooks

# Sovrascrivi uno scaffolding esistente
claude plugin init my-helper --force

plugin install

Installa un plugin dai marketplace disponibili.

claude plugin install <plugin> [options]

Argomenti:

  • <plugin>: Nome del plugin o plugin-name@marketplace-name per un marketplace specifico

Opzioni:

Opzione Descrizione Predefinito
-s, --scope <scope> Ambito di installazione: user, project o local user
--config <key=value> Imposta un'opzione userConfig dichiarata nel manifest del plugin. Ripeti il flag per impostare più opzioni
-y, --yes Accetta un comando che il marketplace del plugin dichiara, senza il prompt di conferma: il comando che produce un plugin con una command source, o l'headersHelper che autentica un download di archivio. Accettare un headersHelper richiede Claude Code v2.1.238 o successivo. Claude Code stampa comunque il comando per primo. Obbligatorio quando stdin o stdout non è un TTY. Non ha effetto all'interno di una sessione di Claude Code, quindi esegui il comando dal tuo terminale
-h, --help Visualizza la guida per il comando

L'ambito determina quale file di impostazioni il plugin installato viene aggiunto. Ad esempio, --scope project scrive in enabledPlugins in .claude/settings.json, rendendo il plugin disponibile a chiunque cloni il repository del progetto.

Esempi:

# Installa nell'ambito utente (predefinito)
claude plugin install formatter@my-marketplace

# Installa nell'ambito progetto (condiviso con il team)
claude plugin install formatter@my-marketplace --scope project

# Installa nell'ambito locale (non condiviso con il team)
claude plugin install formatter@my-marketplace --scope local

plugin uninstall

Rimuovi un plugin installato.

claude plugin uninstall <plugin> [options]

Argomenti:

  • <plugin>: Nome del plugin o plugin-name@marketplace-name

Opzioni:

Opzione Descrizione Predefinito
-s, --scope <scope> Disinstalla dall'ambito: user, project o local user
--keep-data Preserva la persistent data directory del plugin
--prune Rimuovi anche le dipendenze auto-installate che nessun altro plugin richiede. Vedi plugin prune
-y, --yes Salta il prompt di conferma --prune. Obbligatorio quando stdin o stdout non è un TTY
-h, --help Visualizza la guida per il comando

Alias: remove, rm

Per impostazione predefinita, la disinstallazione dall'ultimo ambito rimanente elimina anche la directory ${CLAUDE_PLUGIN_DATA} del plugin. Usa --keep-data per preservarla, ad esempio quando reinstalli dopo aver testato una nuova versione.

plugin prune

Rimuovi le dipendenze dei plugin auto-installate che non sono più richieste da alcun plugin installato. Le dipendenze che Claude Code ha inserito per soddisfare il campo dependencies di un altro plugin vengono rimosse; i plugin che hai installato direttamente non vengono mai toccati.

claude plugin prune [options]

Opzioni:

Opzione Descrizione Predefinito
-s, --scope <scope> Prune all'ambito: user, project o local user
--dry-run Elenca cosa verrebbe rimosso senza rimuovere nulla
-y, --yes Salta il prompt di conferma. Obbligatorio quando stdin o stdout non è un TTY
-h, --help Visualizza la guida per il comando

Alias: autoremove

Il comando elenca le dipendenze orfane e chiede conferma prima di rimuoverle. Per rimuovere un plugin e pulire le sue dipendenze in un unico passaggio, esegui claude plugin uninstall <plugin> --prune.

plugin enable

Abilita un plugin disabilitato. Quando il target è installato da un marketplace e dichiara dependencies, Claude Code li abilita transitivamente nello stesso ambito. Il comando fallisce nelle condizioni che Enable or disable a plugin with dependencies elenca.

claude plugin enable <plugin> [options]

Argomenti:

  • <plugin>: Nome del plugin o plugin-name@marketplace-name

Opzioni:

Opzione Descrizione Predefinito
-s, --scope <scope> Ambito da abilitare: user, project o local. Quando omesso, Claude Code rileva l'ambito in cui il plugin è installato Auto-detect
-h, --help Visualizza la guida per il comando

plugin disable

Disabilita un plugin senza disinstallarlo. Quando il target è installato da un marketplace, il comando fallisce se un altro plugin abilitato dipende da esso. Il messaggio di errore include un comando concatenato che disabilita prima ogni dipendente.

claude plugin disable [plugin] [options]

Argomenti:

  • [plugin]: Nome del plugin o plugin-name@marketplace-name. Facoltativo quando si usa --all

Opzioni:

Opzione Descrizione Predefinito
-a, --all Disabilita tutti i plugin abilitati. Non può essere combinato con --scope
-s, --scope <scope> Ambito da disabilitare: user, project o local. Quando omesso, Claude Code rileva l'ambito in cui il plugin è installato Auto-detect
-h, --help Visualizza la guida per il comando

plugin update

Aggiorna un plugin all'ultima versione.

claude plugin update <plugin> [options]

Argomenti:

  • <plugin>: Nome del plugin o plugin-name@marketplace-name

Opzioni:

Opzione Descrizione Predefinito
-s, --scope <scope> Ambito da aggiornare: user, project, local o managed user
-y, --yes Accetta un comando che il marketplace del plugin dichiara, senza il prompt di conferma: il comando che produce un plugin con una command source, o l'headersHelper che autentica un download di archivio. Accettare un headersHelper richiede Claude Code v2.1.238 o successivo. Claude Code stampa comunque il comando per primo. Obbligatorio quando stdin o stdout non è un TTY. Non ha effetto all'interno di una sessione di Claude Code, quindi esegui il comando dal tuo terminale
-h, --help Visualizza la guida per il comando

plugin list

Elenca i plugin installati con la loro versione, il marketplace di origine e lo stato di abilitazione.

claude plugin list [options]

Opzioni:

Opzione Descrizione Predefinito
--json Output come JSON
--available Includi i plugin disponibili dai marketplace. Richiede --json
-h, --help Visualizza la guida per il comando

All'interno di una sessione interattiva, /plugin list stampa un elenco simile inline, ma copre solo i plugin installati dal marketplace:

  • I plugin caricati dalle directory delle skill appaiono nell'interfaccia /plugin e in claude plugin list, ma non nell'output inline /plugin list.
  • Su Claude Code v2.1.239 o successivo, i plugin sincronizzati da claude.ai appaiono in claude plugin list quando lo esegui nell'ambiente in cui una sessione sincronizzata li ha scaricati. Non appaiono nell'output inline /plugin list.
  • I plugin caricati per la sessione con --plugin-dir o --plugin-url appaiono nell'interfaccia /plugin e in claude plugin list solo quando lo stesso flag precede il sottocomando, come in claude --plugin-dir <dir> plugin list. Solo il nome del flag identifica la loro posizione, quindi un semplice claude plugin list non può trovarli, a differenza dei plugin sincronizzati e dei plugin della directory delle skill, le cui directory fisse Claude Code scansiona.

Il modulo interattivo accetta --enabled o --disabled per mostrare solo i plugin in quello stato, e ls come abbreviazione per list.

plugin details

Mostra l'inventario dei componenti di un plugin e il costo del token previsto. L'output elenca tutti i componenti che il plugin contribuisce, raggruppati come Skills, Agents, Hooks, server MCP e server LSP, insieme a una stima di quanti token aggiunge a ogni sessione. Il gruppo Skills include sia le voci skills/ che commands/.

claude plugin details <name>

Argomenti:

  • <name>: Nome del plugin o plugin-name@marketplace-name

Opzioni:

Opzione Descrizione Predefinito
-h, --help Visualizza la guida per il comando

L'output mostra due cifre di costo per ogni componente:

  • Always-on: token aggiunti a ogni sessione dal testo dell'elenco del plugin, come descrizioni delle skill, descrizioni degli agent e nomi dei comandi, indipendentemente dal fatto che un componente si attivi.
  • On-invoke: token che un componente costa quando si attiva. Mostrato per componente, non come totale del plugin, perché una sessione tipica invoca solo un sottoinsieme di componenti.

Questo esempio mostra come appare l'output per un plugin con due skill:

dependency-guard 1.2.0
  Dependency analysis for Claude Code sessions
  Source: dependency-guard@example-marketplace

Component inventory
  Skills (2)  scan-dependencies, review-changes
  Agents (0)
  Hooks (1)  SessionStart  (harness-only — no model context cost)
  MCP servers (0)
  LSP servers (0)

Projected token cost
  Always-on:   ~180 tok   added to every session

Per-component (rounded)
  component            always-on  on-invoke
  scan-dependencies        ~100      ~2400
  review-changes            ~80      ~1800

  On-invoke cost is paid each time a skill or agent fires.
  Token counts are estimates and may differ from actual usage.

Il totale always-on viene calcolato tramite l'API count_tokens per il tuo modello attivo. I numeri per componente sono proporzionalmente scalati da quel totale. Se l'API non è raggiungibile, il comando ricade su una stima basata su caratteri.

plugin validate

Controlla un plugin o un marketplace per errori di sintassi e schema prima della pubblicazione.

Il comando esce con 0 quando la convalida passa, 1 quando fallisce e 2 quando l'esecuzione della convalida stessa fallisce, ad esempio quando il percorso che passi non è leggibile.

claude plugin validate <path> [options]

Argomenti:

Opzioni:

Opzione Descrizione Predefinito
--strict Tratta gli avvisi come errori ed esce con 1 su di essi. Usa in CI per catturare problemi che il runtime tollera, come unrecognized fields
--json Output il rapporto di convalida come un oggetto JSON con gli stessi codici di uscita. Richiede Claude Code v2.1.259 o successivo
-h, --help Visualizza la guida per il comando

Con --json, Claude Code scrive il rapporto su stdout come un oggetto JSON con questi campi di livello superiore:

  • success: lo stesso verdetto che il codice di uscita fornisce
  • strict: se l'esecuzione ha trattato gli avvisi come errori
  • target: il percorso risolto che Claude Code ha convalidato
  • manifest: il risultato del manifest stesso, o null per un'esecuzione senza manifest
  • contents: risultati per file, ognuno nominando il suo file e portando array errors, warnings e notes

All'uscita 2, il comando non scrive nulla su stdout; il messaggio di errore va su stderr.

All'interno di una sessione interattiva, /plugin validate <path> esegue gli stessi controlli inline.

plugin tag

Crea un tag git di rilascio per un plugin. Per impostazione predefinita il comando etichetta il plugin nella directory corrente; passa un percorso per etichettare un plugin altrove. Vedi Tag plugin releases.

claude plugin tag [path] [options]

Argomenti:

  • [path]: Percorso alla directory del plugin. Predefinito è la directory corrente.

Opzioni:

Opzione Descrizione Predefinito
--push Spinge il tag al remote dopo averlo creato
--dry-run Stampa cosa verrebbe etichettato senza creare il tag
-f, --force Crea il tag anche se l'albero di lavoro è sporco o il tag esiste già
-m, --message <msg> Messaggio di annotazione del tag. Usa %s come segnaposto per la versione
--remote <name> Remote a cui spingere con --push origin
-h, --help Visualizza la guida per il comando

Strumenti di debug e sviluppo

Comandi di debug

Utilizzare claude --debug per visualizzare i dettagli del caricamento dei plugin:

Questo mostra:

  • Quali plugin vengono caricati
  • Eventuali errori nei manifest dei plugin
  • Registrazione di skill, agent e hook
  • Inizializzazione del server MCP

Problemi comuni

Problema Causa Soluzione
Plugin non caricato plugin.json non valido Eseguire claude plugin validate ./my-plugin o /plugin validate ./my-plugin, dove ./my-plugin è la directory del plugin, per controllare plugin.json, hooks/hooks.json e il frontmatter delle skill, degli agent e dei comandi nelle directory predefinite del plugin per errori di sintassi e schema. Vedere Validate a plugin or a directory without a manifest per informazioni su cosa copre un'esecuzione
Skill non visualizzate Struttura di directory errata Assicurarsi che skills/ o commands/ sia nella radice del plugin, non dentro .claude-plugin/
Hook non attivati Script non eseguibile Eseguire chmod +x script.sh
Server MCP non funziona ${CLAUDE_PLUGIN_ROOT} mancante Utilizzare la variabile per tutti i percorsi dei plugin
Errori di percorso Percorsi assoluti utilizzati Rendere i percorsi relativi, iniziando con ./; vedere Path behavior rules, che coprono l'eccezione "." del campo skills
LSP Executable not found in $PATH Language server non installato Installare il binario (ad es., npm install -g typescript-language-server typescript)

Messaggi di errore di esempio

Errori di convalida del manifest:

  • Invalid JSON syntax: Unexpected token } in JSON at position 142: controllare la presenza di virgole mancanti, virgole extra o stringhe non quotate
  • Plugin <name> has an invalid manifest file at .claude-plugin/plugin.json. Validation errors: name: Invalid input: expected string, received undefined: un campo obbligatorio è mancante
  • Plugin <name> has a corrupt manifest file at .claude-plugin/plugin.json. JSON parse error: ...: errore di sintassi JSON. Prima della versione 2.1.246, Claude Code produceva anche questo errore per un plugin.json salvato come UTF-8 con un byte order mark (BOM) iniziale, anche quando il JSON era altrimenti valido.

Errori di caricamento del plugin:

  • Warning: No commands found in plugin my-plugin custom directory: ./cmds. Expected .md files or SKILL.md in subdirectories.: il percorso del comando esiste ma non contiene file di comando validi
  • Plugin directory not found at path: ./plugins/my-plugin. Check that the marketplace entry has the correct path.: il percorso source in marketplace.json punta a una directory inesistente
  • Plugin my-plugin has conflicting manifests: both plugin.json and marketplace entry specify components.: rimuovere le definizioni di componenti duplicate o rimuovere strict: false nella voce del marketplace

Risoluzione dei problemi degli hook

Script hook non in esecuzione:

  1. Verificare che lo script sia eseguibile: chmod +x ./scripts/your-script.sh
  2. Verificare la riga shebang: La prima riga deve essere #!/bin/bash o #!/usr/bin/env bash
  3. Verificare che il percorso utilizzi ${CLAUDE_PLUGIN_ROOT}: "command": "\"${CLAUDE_PLUGIN_ROOT}\"/scripts/your-script.sh"
  4. Testare lo script manualmente: ./scripts/your-script.sh

Hook non attivato su eventi previsti:

  1. Verificare che il nome dell'evento sia corretto (sensibile alle maiuscole): PostToolUse, non postToolUse
  2. Verificare che il pattern del matcher corrisponda ai vostri strumenti: "matcher": "Write|Edit" per le operazioni su file
  3. Confermare che il tipo di hook sia valido: command, http, mcp_tool, prompt o agent

Risoluzione dei problemi del server MCP

Server non avviato:

  1. Verificare che il comando esista e sia eseguibile
  2. Verificare che tutti i percorsi utilizzino la variabile ${CLAUDE_PLUGIN_ROOT}
  3. Controllare i log del server MCP: claude --debug mostra gli errori di inizializzazione
  4. Testare il server manualmente al di fuori di Claude Code

Strumenti del server non visualizzati:

  1. Assicurarsi che il server sia configurato correttamente in .mcp.json o plugin.json
  2. Verificare che il server implementi correttamente il protocollo MCP
  3. Controllare i timeout di connessione nell'output di debug

Errori di struttura della directory

Sintomi: Il plugin viene caricato ma i componenti (skill, agent, hook) sono mancanti.

Struttura corretta: I componenti devono essere nella radice del plugin, non dentro .claude-plugin/. Solo plugin.json appartiene a .claude-plugin/.

Elenco di controllo del debug:

  1. Eseguire claude --debug e cercare i messaggi "loading plugin"
  2. Verificare che ogni directory di componenti sia elencata nell'output di debug
  3. Verificare che i permessi dei file consentano la lettura dei file del plugin

Riferimento di distribuzione e versioning

Gestione delle versioni

Claude Code utilizza la versione del plugin come chiave di cache che determina se un aggiornamento è disponibile. Quando esegui /plugin update o l'aggiornamento automatico si attiva, Claude Code calcola la versione corrente e salta l'aggiornamento se corrisponde a quella già installata.

Per ogni tipo di sorgente eccetto command, Claude Code risolve la versione dal primo di questi che è impostato:

  1. Il campo version nel plugin.json del plugin
  2. Il campo version nella voce del plugin nel marketplace in marketplace.json
  3. Lo SHA del commit git della sorgente del plugin, per le sorgenti github, url, git-subdir e relative-path in un marketplace ospitato su git
  4. Il digest SHA-256, per le sorgenti archive: il pin sha256 nella voce del marketplace, o il digest del file scaricato quando non imposti alcun pin. Claude Code lo accorcia ai primi 12 caratteri
  5. unknown, per le sorgenti npm o le directory locali non all'interno di un repository git

Per una sorgente command, Claude Code deriva sempre la versione da ciò che il comando ha prodotto: un hash di contenuto di 12 caratteri da solo, o aggiunto alla versione plugin.json come <version>-<hash> quando uno è impostato. Claude Code ignora il campo version della voce del marketplace per le sorgenti command. Un comando il cui output con hash cambia produce quindi una nuova versione, anche quando la stringa di versione creata rimane la stessa. In link mode, l'hash copre il percorso reale della directory stampata e le sue voci di primo livello piuttosto che i contenuti dei file.

Per questi tipi di sorgente, questo ti dà tre modi per versioning di un plugin:

Approccio Come Comportamento dell'aggiornamento Migliore per
Versione esplicita Imposta "version": "2.1.0" in plugin.json Gli utenti ricevono aggiornamenti solo quando aumenti questo campo. Spingere nuovi commit senza aumentarlo non ha effetto, e /plugin update segnala "already at the latest version". Plugin pubblicati con cicli di rilascio stabili
Versione Commit-SHA Ometti version sia da plugin.json che dalla voce del marketplace Gli utenti ricevono aggiornamenti ogni volta che il commit risolto della sorgente cambia Plugin interni o di team in sviluppo attivo
Versione Digest Utilizza una sorgente archive e ometti version sia da plugin.json che dalla voce del marketplace Con un pin sha256, gli utenti ricevono aggiornamenti quando cambi il pin. Senza uno, gli utenti ricevono aggiornamenti ogni volta che i byte del file zip ospitato cambiano Plugin pubblicati come file zip su un server statico o repository di artefatti

Se utilizzi versioni esplicite, segui il semantic versioning (MAJOR.MINOR.PATCH): aumenta MAJOR per i cambiamenti che rompono la compatibilità, MINOR per le nuove funzionalità, PATCH per le correzioni di bug. Documenta i cambiamenti in un CHANGELOG.md.

Vedi anche

  • Plugin - Tutorial e utilizzo pratico
  • Marketplace dei plugin - Creazione e gestione dei marketplace
  • Skills - Dettagli dello sviluppo delle skill
  • Subagents - Configurazione e capacità dell'agent
  • Hooks - Gestione degli eventi e automazione
  • MCP - Integrazione di strumenti esterni
  • Impostazioni - Opzioni di configurazione per i plugin