Go Premium Account

plugins-reference.md 2026-09-24 22:57 UTC to 2026-09-25 23:58 UTC

This page contains 0 additions and 1645 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

This document has no rendered page for this history range.

plugins-reference.md +0 −1645 deleted

File Deleted View Diff

~~1> ## Documentation Index~~

~~2> Fetch the complete documentation index at: https://code.claude.com/docs/llms.txt~~

~~3> Use this file to discover all available pages before exploring further.~~

~~5# Plugins reference~~

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

~~9<Tip>~~

10 Stai cercando di installare plugin? Vedi [Scopri e installa plugin](/docs/it/discover-plugins). Per creare plugin, vedi [Plugin](/docs/it/plugins). Per distribuire plugin, vedi [Plugin marketplaces](/docs/it/plugin-marketplaces).

~~11</Tip>~~

13Un **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.

~~15<h2 id="plugin-components-reference">~~

~~16 Riferimento dei componenti del plugin~~

~~17</h2>~~

~~19<h3 id="skills">~~

~~20 Skills~~

~~21</h3>~~

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

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

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

~~29**Struttura skill**:~~

~~31```text theme={null}~~

~~32skills/~~

~~33├── pdf-processor/~~

~~34│ ├── SKILL.md~~

~~35│ ├── reference.md (opzionale)~~

~~36│ └── scripts/ (opzionale)~~

~~37└── code-reviewer/~~

~~38 └── SKILL.md~~

~~39```~~

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

43Se 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. Per un plugin [copiato nella cache](#plugin-caching-and-file-resolution), quel nome è 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.

45Negli 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`.

~~47Per i dettagli completi, vedere [Skills](/docs/it/skills).~~

~~49<h3 id="agents">~~

~~50 Agents~~

~~51</h3>~~

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

~~55**Posizione**: directory `agents/` nella radice del plugin~~

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

~~59**Struttura agent**:~~

~~61```markdown theme={null}~~

~~62name: agent-name~~

~~63description: In cosa si specializza questo agent e quando Claude dovrebbe invocarlo~~

~~64model: sonnet~~

~~65effort: medium~~

~~66maxTurns: 20~~

~~67disallowedTools: Write, Edit~~

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

~~70```~~

~~72<h4 id="plugin-agent-frontmatter">~~

~~73 Frontmatter dell'agent del plugin~~

~~74</h4>~~

76Un file agent del plugin utilizza gli stessi [campi frontmatter di un file subagent](/docs/it/sub-agents#supported-frontmatter-fields), tranne che Claude Code onora solo alcuni di essi quando l'agent proviene da un plugin:

78* **Supportati**: `name`, `description`, `model`, `effort`, `maxTurns`, `tools`, `disallowedTools`, `skills`, `memory`, `background`, `omitClaudeMd`, `isolation`, `color` e `experimental`. L'unico valore `isolation` valido è `"worktree"`.

79* **Non supportati, per motivi di sicurezza**: `hooks`, `mcpServers` e `permissionMode`. Claude Code ignora questi quando carica un agent da un plugin. Per utilizzarli, copia il file agent in `.claude/agents/` o `~/.claude/agents/`.

~~80* **Non supportati**: `initialPrompt`.~~

82Puoi mettere i file degli agent del plugin in sottocartelle di `agents/`. Claude Code [li carica ricorsivamente](/docs/it/sub-agents#choose-the-subagent-scope) e unisce il nome del plugin, ogni nome di sottocartella e il nome del file con i due punti per formare il nome con scope dell'agent. Ad esempio, `agents/review/security.md` in un plugin denominato `my-plugin` viene caricato come `my-plugin:review:security`. Due impostazioni cambiano quel nome:

~~84* Frontmatter `name`: sostituisce solo il nome del file, quindi `name: audit` in `agents/review/security.md` viene caricato come `my-plugin:review:audit`~~

85* Campo manifest [`agents`](#component-path-fields): un file che elenchi lì viene caricato senza nomi di sottocartella, quindi `"agents": "./custom/review/security.md"` viene caricato come `my-plugin:security`

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

~~89* 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`~~

~~90* 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~~

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

94Per 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:

~~96* Un plugin con un manifest: `claude plugin validate ./my-plugin`~~

~~97* Un plugin senza un manifest: `claude plugin validate ./my-plugin/agents`. Richiede Claude Code v2.1.233 o successivo.~~

99Gli agent vengono visualizzati nella [typeahead @-mention](/docs/it/sub-agents#invoke-subagents-explicitly) con il loro nome con scope, come `my-plugin:code-reviewer`, una volta che il plugin è abilitato.

~~100~~

101Per i dettagli completi, vedere [Subagent](/docs/it/sub-agents).

~~102~~

103<h3 id="hooks">

104 Hooks

105</h3>

~~106~~

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

~~108~~

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

~~110~~

111**Formato**: Configurazione JSON con matcher di eventi e azioni

~~112~~

113`hooks/hooks.json` può contenere una chiave `$schema` di livello superiore che nomina un URL JSON Schema per l'autocompletamento dell'editor e la convalida. Claude Code ignora la chiave al momento del caricamento.

~~114~~

115**Configurazione hook**:

~~116~~

117```json theme={null}

118{

119 "hooks": {

120 "PostToolUse": [

121 {

122 "matcher": "Write|Edit",

123 "hooks": [

124 {

125 "type": "command",

126 "command": "\"${CLAUDE_PLUGIN_ROOT}\"/scripts/format-code.sh"

127 }

128 ]

129 }

130 ]

131 }

132}

133```

~~134~~

135Gli hook del plugin rispondono agli stessi eventi del ciclo di vita degli [hook definiti dall'utente](/docs/it/hooks):

~~136~~

137| Evento | Quando si attiva |

138| :-------------------- | :-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |

139| `SessionStart` | Quando una sessione inizia o riprende |

140| `Setup` | Quando avvii Claude Code con `--init-only`, o con `--init` o `--maintenance` in modalità `-p`. Per la preparazione una tantum in CI o script |

141| `UserPromptSubmit` | Quando invii un prompt, prima che Claude lo elabori |

142| `UserPromptExpansion` | Quando un comando digitato dall'utente si espande in un prompt, prima che raggiunga Claude. Può bloccare l'espansione |

143| `PreToolUse` | Prima che una chiamata a uno strumento si esegua. Può bloccarla |

144| `PermissionRequest` | Quando una chiamata a uno strumento necessita di una decisione di autorizzazione |

145| `PermissionDenied` | Quando la modalità automatica nega una chiamata a uno strumento, inclusi i rifiuti senza un verdetto del classificatore. Utilizza JSON `hookSpecificOutput.retry: true` per indicare al modello che può riprovare la chiamata allo strumento negata. Claude Code ignora `retry` quando il classificatore non ha prodotto alcun verdetto |

146| `PostToolUse` | Dopo che una chiamata a uno strumento ha successo |

147| `PostToolUseFailure` | Dopo che una chiamata a uno strumento fallisce |

148| `PostToolBatch` | Dopo che un intero batch di chiamate a strumenti paralleli si risolve, prima della prossima chiamata al modello |

149| `Notification` | Quando Claude Code invia una notifica |

150| `MessageDisplay` | Mentre il testo del messaggio dell'assistente viene visualizzato |

151| `SubagentStart` | Quando un subagente viene generato |

152| `SubagentStop` | Quando un subagente termina |

153| `TaskCreated` | Quando un'attività viene creata tramite `TaskCreate` |

154| `TaskCompleted` | Quando un'attività viene contrassegnata come completata |

155| `Stop` | Quando Claude finisce di rispondere |

156| `StopFailure` | Quando il turno termina a causa di un errore API |

157| `TeammateIdle` | Quando un compagno di squadra di un [team di agenti](/docs/it/agent-teams) sta per diventare inattivo |

158| `InstructionsLoaded` | Quando un file CLAUDE.md o `.claude/rules/*.md` viene caricato nel contesto. Si attiva all'inizio della sessione e quando i file vengono caricati in modo pigro durante una sessione |

159| `ConfigChange` | Quando un file di configurazione cambia durante una sessione |

160| `CwdChanged` | Quando la directory di lavoro cambia, ad esempio quando Claude esegue un comando `cd`. Utile per la gestione reattiva dell'ambiente con strumenti come direnv |

161| `DirectoryAdded` | Quando una directory di lavoro viene aggiunta a metà sessione tramite `/add-dir` o la richiesta di controllo SDK `register_repo_root` |

162| `FileChanged` | Quando un file osservato cambia su disco. Il campo `matcher` specifica quali nomi di file osservare |

163| `WorktreeCreate` | Quando un worktree viene creato tramite `--worktree`, `isolation: "worktree"`, o per una sessione in background. Sostituisce il comportamento git predefinito |

164| `WorktreeRemove` | Quando un worktree viene rimosso all'uscita della sessione, quando un subagente termina, o quando elimini una sessione in background |

165| `PreCompact` | Prima della compattazione del contesto |

166| `PostCompact` | Dopo che la compattazione del contesto è completata |

167| `PreModelSwitch` | Prima che Claude Code applichi un cambio di modello che hai richiesto tu o un client. Può bloccare il cambio |

168| `PostModelSwitch` | Dopo che il modello della sessione cambia, inclusi i cambiamenti che Claude Code effettua autonomamente, come il ripristino del modello quando riprendi una sessione |

169| `Elicitation` | Quando un server MCP richiede input dell'utente durante una chiamata a uno strumento |

170| `ElicitationResult` | Dopo che un utente risponde a un'elicitazione MCP, prima che la risposta venga inviata al server |

171| `SessionEnd` | Quando una sessione termina |

~~172~~

173**Tipi di hook**:

~~174~~

175* `command`: eseguire comandi shell o script

176* `http`: inviare l'evento JSON come richiesta POST a un URL

177* `mcp_tool`: chiamare uno strumento su un [server MCP](/docs/it/mcp) configurato

178* `prompt`: valutare un prompt con un LLM (utilizza il placeholder `$ARGUMENTS` per il contesto)

179* `agent`: eseguire un verificatore agentico con strumenti per compiti di verifica complessi

~~180~~

181Gli hook che puntano al [server MCP bundled](#mcp-servers) 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](/docs/it/hooks#match-mcp-tools) e [Plugin-provided MCP servers](/docs/it/mcp#plugin-provided-mcp-servers).

~~182~~

183<h3 id="mcp-servers">

184 MCP servers

185</h3>

~~186~~

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

~~188~~

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

~~190~~

191**Formato**: Configurazione standard del server MCP

~~192~~

193**Configurazione del server MCP**:

~~194~~

195```json theme={null}

196{

197 "mcpServers": {

198 "plugin-database": {

199 "command": "${CLAUDE_PLUGIN_ROOT}/servers/db-server",

200 "args": ["--config", "${CLAUDE_PLUGIN_ROOT}/config.json"],

201 "env": {

202 "DB_PATH": "${CLAUDE_PLUGIN_ROOT}/data"

203 }

204 },

205 "plugin-api-client": {

206 "command": "npx",

207 "args": ["@company/mcp-server", "--plugin-mode"]

208 }

209 }

210}

211```

~~212~~

213**Comportamento di integrazione**:

~~214~~

215* I server MCP del plugin si avviano automaticamente quando il plugin è abilitato

216* I server vengono visualizzati come strumenti MCP standard nel toolkit di Claude

217* I server del plugin possono essere configurati indipendentemente dai server MCP dell'utente

218* Se esegui [`/reload-plugins`](/docs/it/discover-plugins#apply-plugin-changes-without-restarting) a metà sessione, Claude Code mantiene le connessioni live dei server la cui configurazione è invariata

~~219~~

220<h3 id="lsp-servers">

221 LSP servers

222</h3>

~~223~~

224<Tip>

225 Stai cercando di utilizzare plugin LSP? Installali dal marketplace ufficiale: cerca "lsp" nella scheda Discover `/plugin`. Questa sezione documenta come creare plugin LSP per linguaggi non coperti dal marketplace ufficiale.

226</Tip>

~~227~~

228I plugin possono fornire server [Language Server Protocol](https://microsoft.github.io/language-server-protocol/) (LSP) per dare a Claude [intelligenza del codice in tempo reale](/docs/it/discover-plugins#code-intelligence) mentre lavori sulla tua codebase.

~~229~~

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

~~231~~

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

~~233~~

234**Formato file `.lsp.json`**:

~~235~~

236```json theme={null}

237{

238 "go": {

239 "command": "gopls",

240 "args": ["serve"],

241 "extensionToLanguage": {

242 ".go": "go"

243 }

244 }

245}

246```

~~247~~

248**Inline in `plugin.json`**:

~~249~~

250```json theme={null}

251{

252 "name": "my-plugin",

253 "lspServers": {

254 "go": {

255 "command": "gopls",

256 "args": ["serve"],

257 "extensionToLanguage": {

258 ".go": "go"

259 }

260 }

261 }

262}

263```

~~264~~

265**Campi obbligatori:**

~~266~~

267| Field | Description |

268| :-------------------- | :------------------------------------------------------------ |

269| `command` | Il binario LSP da eseguire (deve essere in PATH) |

270| `extensionToLanguage` | Mappa le estensioni di file agli identificatori di linguaggio |

~~271~~

272**Campi opzionali:**

~~273~~

274| Field | Description |

275| :---------------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |

276| `args` | Argomenti della riga di comando per il server LSP |

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

278| `env` | Variabili di ambiente da impostare all'avvio del server |

279| `initializationOptions` | Opzioni passate al server durante l'inizializzazione |

280| `settings` | Impostazioni passate tramite `workspace/didChangeConfiguration` |

281| `workspaceFolder` | Percorso della cartella di lavoro per il server |

282| `startupTimeout` | Tempo massimo di attesa per l'avvio del server (millisecondi) |

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

284| `restartOnCrash` | Se riavviare il server dopo un crash. Predefinito su `true`. Impostare su `false` per lasciare un server bloccato fermo invece di riavviarlo |

285| `maxRestarts` | Numero massimo di tentativi di riavvio prima di rinunciare |

286| `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. |

~~287~~

288`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`.

~~289~~

290**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.

~~291~~

292**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.

~~293~~

294Un 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.

~~295~~

296**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.

~~297~~

298<Warning>

299 **Devi installare il binario del server di linguaggio separatamente.** I plugin LSP configurano come Claude Code si connette a un server di linguaggio, ma non includono il server stesso. Se vedi `Executable not found in $PATH` nella scheda Errors `/plugin`, installa il binario richiesto per il tuo linguaggio.

300</Warning>

~~301~~

302**Plugin LSP disponibili:**

~~303~~

304| Plugin | Language server | Install command |

305| :------------------ | :------------------------- | :------------------------------------------------------------------------------------------ |

306| `pyright-lsp` | Pyright (Python) | `pip install pyright` o `npm install -g pyright` |

307| `typescript-lsp` | TypeScript Language Server | `npm install -g typescript-language-server typescript` |

308| `rust-analyzer-lsp` | rust-analyzer | [Vedi rust-analyzer installation](https://rust-analyzer.github.io/manual.html#installation) |

~~309~~

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

~~311~~

312<h3 id="monitors">

313 Monitors

314</h3>

~~315~~

316I 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.

~~317~~

318I monitor del plugin utilizzano lo stesso meccanismo dello [strumento Monitor](/docs/it/tools-reference#monitor-tool) 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](#hooks) e vengono saltati su host dove lo strumento Monitor non è disponibile.

~~319~~

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

~~321~~

322**Formato**: Array JSON di voci di monitor

~~323~~

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

~~325~~

326```json theme={null}

327[

328 {

329 "name": "deploy-status",

330 "command": "\"${CLAUDE_PLUGIN_ROOT}\"/scripts/poll-deploy.sh",

331 "description": "Deployment status changes"

332 },

333 {

334 "name": "error-log",

335 "command": "tail -F ./logs/error.log",

336 "description": "Application error log",

337 "when": "on-skill-invoke:debug"

338 }

339]

340```

~~341~~

342Per 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](#experimental-components).

~~343~~

344**Campi obbligatori:**

~~345~~

346| Field | Description |

347| :------------ | :------------------------------------------------------------------------------------------------------------------------------------------ |

348| `name` | Identificatore univoco all'interno del plugin. Previene processi duplicati quando il plugin si ricarica o uno skill viene invocato di nuovo |

349| `command` | Comando shell eseguito come processo in background persistente nella directory di lavoro della sessione |

350| `description` | Breve riepilogo di ciò che viene osservato. Mostrato nel pannello attività e nei riepiloghi delle notifiche |

~~351~~

352**Campi opzionali:**

~~353~~

354| Field | Description |

355| :----- | :----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |

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

~~357~~

358Il valore `command` supporta le [sostituzioni di percorso](#environment-variables) `${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.

~~359~~

360Un `command` di monitor non può fare riferimento ai valori [`${user_config.*}`](#user-configuration). Il comando viene eseguito attraverso una shell, quindi Claude Code rifiuta il monitor con un [errore](/docs/it/errors#plugin-command-references-user-config) 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.

~~361~~

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

~~363~~

364<h3 id="themes">

365 Themes

366</h3>

~~367~~

368I 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](#experimental-components).

~~369~~

370```json theme={null}

371{

372 "name": "Dracula",

373 "base": "dark",

374 "overrides": {

375 "claude": "#bd93f9",

376 "error": "#ff5555",

377 "success": "#50fa7b"

378 }

379}

380```

~~381~~

382Quando 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.

~~383~~

384***

~~385~~

386<h2 id="plugin-installation-scopes">

387 Ambiti di installazione dei plugin

388</h2>

~~389~~

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

~~391~~

392| Ambito | File di configurazione | Caso d'uso |

393| :-------- | :--------------------------------------- | :---------------------------------------------------------------------------------------------- |

394| `user` | `~/.claude/settings.json` | Plugin personali disponibili in tutti i progetti (predefinito) |

395| `project` | `.claude/settings.json` | Plugin del team condivisi tramite controllo versione |

396| `local` | `.claude/settings.local.json` | Plugin specifici del progetto, ignorati da git quando Claude Code salva un'impostazione in esso |

397| `managed` | [Managed settings](/docs/it/managed-settings) | Plugin gestiti (sola lettura, solo aggiornamento) |

~~398~~

399I 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](/docs/it/discover-plugins#install-plugins). Per una spiegazione completa degli ambiti, vedi [Configuration scopes](/docs/it/settings#where-settings-live).

~~400~~

401***

~~402~~

403<h2 id="skills-directory-plugins">

404 Plugin della directory skills

405</h2>

~~406~~

407Qualsiasi 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`](#plugin-init). A differenza di un'installazione marketplace copiata, il plugin viene scoperto sul posto piuttosto che copiato nella cache dei plugin.

~~408~~

409Un albero di directory skills supporta tre cose distinte:

~~410~~

411| Quello che hai | Che cosa è |

412| :-------------------------------------------- | :--------------------------------------------------------------------------------------- |

413| `<skills-dir>/foo/SKILL.md` senza manifest | Una semplice [skill](/docs/it/skills) denominata `foo` |

414| `<skills-dir>/foo/.claude-plugin/plugin.json` | Un plugin `foo@skills-dir`, che può raggruppare le proprie skills, agenti, hooks e altro |

415| `<plugin>/skills/bar/SKILL.md` | Una skill `bar` inclusa in un plugin |

~~416~~

417<h3 id="choose-where-the-plugin-loads-from">

418 Scegli da dove il plugin viene caricato

419</h3>

~~420~~

421| Directory skills | Ambito | Carica |

422| :---------------------- | :-------- | :------------------------------------------------------------------------------------------------------------------------------- |

423| `~/.claude/skills/` | personale | In ogni progetto, poiché la posizione è solo tua |

424| `<cwd>/.claude/skills/` | progetto | Solo dopo che accetti la [finestra di dialogo di trust](/docs/it/permissions#what-runs-before-you-trust-a-folder) per quella cartella |

~~425~~

426Un 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:

~~427~~

428* I server MCP che dichiara passano attraverso la [stessa approvazione per server](/docs/it/mcp) di un `.mcp.json` del progetto

429* I server LSP si avviano solo dopo che hai fiducia nell'area di lavoro

430* I [monitor in background](#monitors) non vengono caricati

~~431~~

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

~~433~~

434<Warning>

435 I plugin `@skills-dir` con ambito progetto vengono caricati solo da `.claude/skills/` della [directory di lavoro primaria](/docs/it/permissions#working-directories) della sessione. Non [risalgono alla radice del repository](/docs/it/skills#discovery-from-parent-and-nested-directories) come fanno le skill e i comandi semplici, quindi l'avvio da una sottodirectory non trova un plugin che si trova alla radice del repository. Avvia dalla radice del repository, o [sposta la sessione lì con `/cd`](/docs/it/permissions#move-the-session-to-another-directory) su v2.1.246 o successivo.

436</Warning>

~~437~~

438<h3 id="edit-reload-and-disable-a-skills-directory-plugin">

439 Modifica, ricarica e disabilita un plugin della directory skills

440</h3>

~~441~~

442Le 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](/docs/it/skills#live-change-detection).

~~443~~

444Per 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.

~~445~~

446```bash theme={null}

447claude plugin disable my-tool@skills-dir

448```

~~449~~

450***

~~451~~

452<h2 id="synced-plugins">

453 Plugin sincronizzati da claude.ai

454</h2>

~~455~~

456Claude Code carica i plugin abilitati per il vostro account claude.ai, inclusi i plugin che la vostra organizzazione attiva per i suoi membri, insieme ai plugin che installate dai marketplace. Li scarica in `~/.claude/plugins/synced/` e carica ciascuno come `<name>@synced`, senza marketplace e senza record di installazione. Un plugin sincronizzato viene eseguito con la stessa fiducia di un plugin marketplace che avete installato: le sue skills, gli agenti, gli hooks, i server MCP e i server LSP si caricano tutti.

~~457~~

458Il luogo in cui Claude Code sincronizza questi plugin dipende dalla sessione:

~~459~~

460* In [Cowork](https://claude.com/product/cowork) e [sessioni cloud](/docs/it/cloud-environments#what-carries-over-from-your-setup), Claude Code li scarica nell'ambiente della sessione stessa quando la sessione inizia. Prima della v2.1.239, Claude Code caricava questi plugin come `<name>@inline`, l'identità che i plugin `--plugin-dir` utilizzano.

461* Nelle sessioni di terminale in cui vi accedete con il vostro account claude.ai, Claude Code controlla il vostro account una volta ogni volta che si avvia, quindi scarica i plugin nuovi e aggiornati e rimuove quelli che voi o la vostra organizzazione avete disabilitato, il tutto in background. La sincronizzazione nelle sessioni di terminale richiede Claude Code v2.1.273 o successivo.

~~462~~

463Il controllo di avvio viene eseguito in background, quindi può terminare dopo che la vostra sessione è iniziata. Quando aggiunge, aggiorna o rimuove un plugin sincronizzato in una sessione interattiva, Claude Code mostra `Plugins changed. Run /reload-plugins to activate.` Eseguite [`/reload-plugins`](/docs/it/discover-plugins#apply-plugin-changes-without-restarting) per caricare la modifica in quella sessione, oppure lasciatela per la prossima volta che avviate Claude Code. Se abilitate un plugin su claude.ai mentre una sessione è in esecuzione, Claude Code lo scarica la prossima volta che si avvia.

~~464~~

465La sincronizzazione dei plugin nelle sessioni di terminale viene eseguita nelle stesse condizioni di accesso delle [skills sincronizzate da claude.ai](/docs/it/skills#where-synced-skills-load). Richiede anche un accesso che conceda a Claude Code l'accesso ai plugin del vostro account.

~~466~~

467Un accesso da una versione precedente di Claude Code acquisisce l'accesso ai plugin la prossima volta che Claude Code rinnova quell'accesso in background, entro poche ore, o subito se eseguite di nuovo `/login`. La sincronizzazione dei plugin inizia la prossima volta che avviate Claude Code dopo di ciò.

~~468~~

469`claude plugin list` mostra i plugin sincronizzati sotto un'intestazione `Synced from claude.ai`, e la scheda **Installed** di `/plugin` li elenca con `synced` come loro fonte. Gestite un plugin sincronizzato tramite l'ID `<name>@synced` che `claude plugin list` stampa:

~~470~~

471* **Disabilitarne uno**: eseguite `claude plugin disable <name>@synced`, oppure disabilitatelo dalla scheda **Installed** di `/plugin`. Claude Code salva la scelta come `"<name>@synced": false` nel vostro [`enabledPlugins`](/docs/it/settings-reference#enabledplugins) a livello di utente. Per riabilitare il plugin, eseguite `claude plugin enable <name>@synced`.

472* **Mantenerlo fuori ovunque**: [disabilitate il plugin per il vostro account claude.ai](/docs/it/desktop#extend-claude-code). Per mantenerlo fuori da un progetto in ogni ambiente, impostate `"<name>@synced": false` sotto `enabledPlugins` nel `.claude/settings.json` committato di quel progetto.

473* **Gestite il plugin stesso su claude.ai**: `claude plugin install`, `update` e `uninstall` non si applicano a un plugin sincronizzato. Claude Code scarica gli aggiornamenti di un plugin alla prossima sincronizzazione. Per rimuoverne uno, disabilitate il plugin per il vostro account claude.ai, e Claude Code lo rimuove alla prossima sincronizzazione.

474* **Interrompere la sincronizzazione su una macchina**: impostate [`syncClaudeAiPlugins`](/docs/it/settings-reference#syncclaudeaiplugins) a `false` nelle vostre impostazioni utente. Claude Code smette di scaricare, e la prossima volta che si avvia sposta i plugin che ha già sincronizzato in `~/.claude/plugins/.trash/` e non li carica più. La vostra organizzazione può impostare la stessa chiave nelle [impostazioni gestite](/docs/it/managed-settings), oppure disabilitare Skills su claude.ai, il che interrompe anche la sincronizzazione dei plugin.

~~475~~

476Non potete disabilitare un plugin che la vostra organizzazione contrassegna come obbligatorio su claude.ai. Claude Code lo carica anche se lo avete disabilitato in precedenza, e `claude plugin disable` rifiuta con `Plugin "<name>@synced" is required by your organization and can't be disabled here. Contact your admin to change it.` In `claude plugin list`, questi plugin sono contrassegnati `required by your org`.

~~477~~

478Quando un plugin abilitato da qualsiasi altra fonte corrisponde al nome di un plugin sincronizzato, Claude Code carica quel plugin e segnala la copia sincronizzata come non caricata. Le altre fonti includono installazioni da marketplace, plugin [skills-directory](#skills-directory-plugins), plugin `--plugin-dir` e plugin integrati in Claude Code. 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.

~~479~~

480***

~~481~~

482<h2 id="plugin-manifest-schema">

483 Schema del manifest del plugin

484</h2>

~~485~~

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

~~487~~

488Il manifest è facoltativo. Se omesso, Claude Code scopre automaticamente i componenti nelle [posizioni predefinite](#file-locations-reference) e deriva il nome del plugin dal nome della directory. Utilizza un manifest quando hai bisogno di fornire metadati o percorsi di componenti personalizzati.

~~489~~

490<h3 id="complete-schema">

491 Schema completo

492</h3>

~~493~~

494```json theme={null}

495{

496 "name": "plugin-name",

497 "displayName": "Plugin Name",

498 "version": "1.2.0",

499 "description": "Brief plugin description",

500 "author": {

501 "name": "Author Name",

502 "email": "author@example.com",

503 "url": "https://github.com/author"

504 },

505 "homepage": "https://docs.example.com/plugin",

506 "repository": "https://github.com/author/plugin",

507 "license": "MIT",

508 "keywords": ["keyword1", "keyword2"],

509 "metadata": { "catalogId": "cat-123", "tier": "pro" },

510 "skills": "./custom/skills/",

511 "commands": ["./custom/commands/special.md"],

512 "agents": ["./custom/agents/reviewer.md"],

513 "hooks": "./config/hooks.json",

514 "mcpServers": "./mcp-config.json",

515 "outputStyles": "./styles/",

516 "lspServers": "./.lsp.json",

517 "experimental": {

518 "themes": "./themes/",

519 "monitors": "./monitors.json",

520 "evals": "quality/evals"

521 },

522 "dependencies": [

523 "helper-lib",

524 { "name": "secrets-vault", "version": "~2.1.0" }

525 ]

526}

527```

~~528~~

529<h3 id="required-fields">

530 Campi obbligatori

531</h3>

~~532~~

533Se includi un manifest, `name` è l'unico campo obbligatorio.

~~534~~

536| :----- | :----- | :---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :------------------- |

537| `name` | string | Identificatore univoco in kebab-case, senza spazi, caratteri di controllo o caratteri di formattazione bidirezionali. Quando una [voce del marketplace](/docs/it/plugin-marketplaces#plugin-entries) elenca il plugin con un nome diverso, il nome della voce del marketplace è quello che `enabledPlugins` e `/plugin` utilizzano | `"deployment-tools"` |

~~538~~

539Questo 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`.

~~540~~

541<h3 id="unrecognized-fields">

542 Campi non riconosciuti

543</h3>

~~544~~

545Claude Code ignora i campi di primo livello che non riconosce. Puoi mantenere i metadati da un altro ecosistema in `plugin.json` e il plugin si carica comunque. Questo rende pratico mantenere un manifest che funge anche da manifest di estensione VS Code o Cursor, da `package.json` npm, o da manifest bundle MCPB/DXT.

~~546~~

547`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.

~~548~~

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

~~550~~

551* **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.

552* **`experimental` e `metadata`**: Claude Code ignora un valore non-oggetto, e `claude plugin validate` segnala un avviso.

~~553~~

554Passa `--strict` per trattare gli avvisi come errori. Usalo 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.

~~555~~

556```bash theme={null}

557claude plugin validate ./my-plugin --strict

558```

~~559~~

560<h3 id="metadata-fields">

561 Campi di metadati

562</h3>

~~563~~

565| :--------------- | :------ | :----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :---------------------------------------------------------------- |

566| `$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"` |

567| `displayName` | string | Nome leggibile mostrato nel selettore `/plugin` e in altre superfici dell'interfaccia utente. Per un plugin installato dal marketplace, un `displayName` sulla [voce del marketplace](/docs/it/plugin-marketplaces#optional-plugin-fields) ha la precedenza su questo valore. Quando nessun nome visualizzato è impostato in nessuno dei due posti, gli utenti vedono `name`. A differenza di `name`, può contenere spazi e qualsiasi maiuscola/minuscola. Non utilizzato per lo spazio dei nomi o la ricerca. | `"Deployment Tools"` |

568| `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 aumenti, tranne per una [`command` source](/docs/it/plugin-marketplaces#command-sources) o un plugin [caricato in place](#plugin-caching-and-file-resolution); vedi [Gestione delle versioni](#version-management). Se impostato anche nella voce del marketplace, `plugin.json` vince. Se omesso, la versione proviene dalla prossima fonte in [Gestione delle versioni](#version-management). | `"2.1.0"` |

570| `author` | object | Informazioni sull'autore | `{"name": "Dev Team", "email": "dev@company.com"}` |

575| `metadata` | object | Oggetto in forma libera per i tuoi dati, come campi di diritto o catalogo. Claude Code non lo legge, quindi i valori non influenzano mai il 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](#unrecognized-fields). | `{"catalogId": "cat-123"}` |

~~577~~

578<h3 id="default-enablement">

579 Abilitazione predefinita

580</h3>

~~581~~

582Imposta `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`. Usalo per i plugin che aggiungono costi o ambito a cui un utente dovrebbe acconsentire, come uno che si connette a un servizio esterno.

~~583~~

584`defaultEnabled` è il fallback quando nient'altro ha deciso lo stato del plugin. L'impostazione dell'utente e un requisito di dipendenza hanno la precedenza su di esso:

~~585~~

586* **L'impostazione dell'utente**: una voce per il plugin in `enabledPlugins` a qualsiasi ambito di impostazioni. Una volta scritta, persiste negli aggiornamenti e reinstallazioni del plugin, quindi modificare `defaultEnabled` in una versione successiva non capovolge un utente esistente.

587* **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 default non si applica più. Vedi [Abilitare o disabilitare un plugin con dipendenze](/docs/it/plugin-dependencies#enable-or-disable-a-plugin-with-dependencies).

~~588~~

589Lo stesso campo può apparire nella voce del marketplace di un plugin, dove ha la precedenza sul valore in `plugin.json`. Vedi [Campi plugin facoltativi](/docs/it/plugin-marketplaces#optional-plugin-fields).

~~590~~

591<h3 id="component-path-fields">

592 Campi del percorso del componente

593</h3>

~~594~~

596| :---------------------- | :-------------------- | :-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :--------------------------------------------------- |

597| `skills` | string\|array | Directory di skill personalizzate contenenti `<name>/SKILL.md`. Si aggiunge alla scansione predefinita `skills/`. Vedi [Regole del comportamento del percorso](#path-behavior-rules) per l'eccezione della radice del marketplace | `"./custom/skills/"` |

607| `experimental.evals` | string\|array | Directory sotto la radice del plugin che contiene i [casi eval](/docs/it/plugin-evals#use-a-different-eval-directory) del plugin, quando non è il valore predefinito `evals/`. `claude plugin eval --eval-dir` lo sostituisce | `"quality/evals"` |

610| `dependencies` | array | Altri plugin richiesti da questo plugin, facoltativamente con vincoli di versione semver. Vedi [Vincolare le versioni di dipendenza del plugin](/docs/it/plugin-dependencies) | `[{ "name": "secrets-vault", "version": "~2.1.0" }]` |

~~611~~

612<h3 id="experimental-components">

613 Componenti sperimentali

614</h3>

~~615~~

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

~~617~~

618<h3 id="user-configuration">

619 Configurazione utente

620</h3>

~~621~~

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

~~623~~

624```json theme={null}

625{

626 "userConfig": {

627 "api_endpoint": {

628 "type": "string",

629 "title": "API endpoint",

630 "description": "Your team's API endpoint"

631 },

632 "api_token": {

633 "type": "string",

634 "title": "API token",

635 "description": "API authentication token",

636 "sensitive": true

637 }

638 }

639}

640```

~~641~~

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

~~643~~

644| Campo | Obbligatorio | Descrizione |

645| :------------ | :----------- | :----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |

646| `type` | Sì | Uno di `string`, `number`, `boolean`, `directory`, o `file` |

647| `title` | Sì | Etichetta mostrata nella finestra di dialogo di configurazione |

648| `description` | Sì | Testo di aiuto mostrato sotto il campo |

649| `sensitive` | No | Se `true`, maschera l'input e memorizza il valore nell'archiviazione sicura invece di `settings.json` |

650| `required` | No | Se `true`, la convalida fallisce quando il campo è vuoto |

651| `default` | No | Valore utilizzato quando l'utente non fornisce nulla |

652| `options` | No | Per il tipo `string`, i valori che il campo accetta, mostrati in `/config` come un selettore su di essi. Vedi [Limitare un campo a opzioni fisse](#limit-a-field-to-fixed-options). Richiede Claude Code v2.1.271 o successivo |

653| `multiple` | No | Per il tipo `string`, consenti un array di stringhe |

654| `min` / `max` | No | Limiti per il tipo `number` |

~~655~~

656Tranne i campi `sensitive` e gli elenchi `multiple`, ogni campo di ogni plugin abilitato appare anche come una riga nel pannello `/config`. Le righe richiedono Claude Code v2.1.269 o successivo.

~~657~~

658Ogni 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 agente. Tutti i valori vengono esportati ai processi hook come variabili di ambiente `CLAUDE_PLUGIN_OPTION_<KEY>`, dove `<KEY>` è la chiave dell'opzione in maiuscolo.

~~659~~

660I 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](/docs/it/errors#plugin-command-references-user-config) invece. Ogni campo rifiutato ha un modo alternativo per passare il valore:

~~661~~

662| Campo rifiutato | Come passare il valore |

663| :--------------------------------------------------------------------------- | :--------------------------------------------------------------------------------------------------------------------------- |

664| Comandi hook in forma shell | Usa [forma exec](/docs/it/hooks#exec-form-and-shell-form) con `args`, o leggi `CLAUDE_PLUGIN_OPTION_<KEY>` dall'ambiente del hook |

665| Comandi [Monitor](#monitors) | Leggi il valore da un file di configurazione nello script |

666| MCP [`headersHelper`](/docs/it/mcp#use-dynamic-headers-for-custom-authentication) | Leggi il valore da un file di configurazione nello script |

~~667~~

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

~~669~~

670I valori non sensibili vengono memorizzati sotto la chiave [`pluginConfigs`](/docs/it/settings-reference#pluginconfigs) nel tuo `settings.json` utente come `pluginConfigs[<plugin-id>].options`.

~~671~~

672Su macOS, Claude Code memorizza i valori sensibili nel Portachiavi 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 mantieni i valori sensibili piccoli.

~~673~~

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

~~675~~

676* **Impostazioni utente**: `~/.claude/settings.json`, il file che il prompt al momento dell'abilitazione scrive

677* **`--settings`**: il flag CLI o le impostazioni inline SDK

678* **Impostazioni gestite**: [politica controllata dall'organizzazione](/docs/it/permissions#managed-settings)

~~679~~

680Quando più di una fonte imposta la stessa chiave, le impostazioni gestite hanno la precedenza, quindi `--settings`, quindi le impostazioni utente. L'unica fonte che puoi rimuovere da questo elenco è le impostazioni utente: passa [`--setting-sources`](/docs/it/cli-reference#cli-flags) senza `user` e Claude Code le salta. Le impostazioni gestite e `--settings` rimangono qualsiasi cosa tu passi. L'opzione [`settingSources`](/docs/it/agent-sdk/claude-code-features#what-settingsources-does-not-control) dell'SDK imposta lo stesso elenco.

~~681~~

682Le voci nel `.claude/settings.json` o `.claude/settings.local.json` di un progetto vengono ignorate. Entrambi i file vivono 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`](/docs/it/settings-reference#enabledplugins) onora ancora le impostazioni del progetto e locali.

~~683~~

684<h4 id="limit-a-field-to-fixed-options">

685 Limitare un campo a opzioni fisse

686</h4>

~~687~~

688Imposta `options` su un campo `userConfig` per fare in modo che gli utenti scelgano il suo valore da un elenco fisso.

~~689~~

690Per limitare un campo `tone` a tre opzioni, elencale in `options` e imposta `default` su una di esse:

~~691~~

692```json theme={null}

693{

694 "userConfig": {

695 "tone": {

696 "type": "string",

697 "title": "Tone",

698 "description": "Voice for generated replies",

699 "options": ["neutral", "warm", "formal"],

700 "default": "neutral"

701 }

702 }

703}

704```

~~705~~

706Se dichiari `options` su qualsiasi campo, gli utenti su versioni di Claude Code precedenti alla v2.1.271 non possono caricare il plugin.

~~707~~

708Quando imposti `options` su un campo, segui queste regole:

~~709~~

710* Imposta `type` su `string`

711* Non impostare `multiple` o `sensitive` su `true`

712* Imposta `default` su una delle opzioni

713* Se lasci `default` non impostato, imposta `required` su `true`

714* Elenca almeno un'opzione, ognuna da 1 a 64 caratteri

715* Non iniziare o terminare un'opzione con uno spazio

716* Non usare caratteri di controllo, caratteri invisibili, caratteri che cambiano la direzione del testo, o spazi diversi da uno spazio regolare in un'opzione

717* Non elencare la stessa opzione due volte, nemmeno in una diversa maiuscola/minuscola

~~718~~

719Se infrangi una di queste regole, il plugin non si carica. Esegui `claude plugin validate` per vedere quale campo infrange quale regola.

~~720~~

721<h3 id="channels">

722 Canali

723</h3>

~~724~~

725Il 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.

~~726~~

727```json theme={null}

728{

729 "channels": [

730 {

731 "server": "telegram",

732 "userConfig": {

733 "bot_token": {

734 "type": "string",

735 "title": "Bot token",

736 "description": "Telegram bot token",

737 "sensitive": true

738 },

739 "owner_id": {

740 "type": "string",

741 "title": "Owner ID",

742 "description": "Your Telegram user ID"

743 }

744 }

745 }

746 ]

747}

748```

~~749~~

750Il campo `server` è obbligatorio e deve corrispondere a una chiave in `mcpServers` del plugin. Il `userConfig` facoltativo 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.

~~751~~

752<h3 id="path-behavior-rules">

753 Regole del comportamento del percorso

754</h3>

~~755~~

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

~~757~~

758* **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, elencalo esplicitamente: `"commands": ["./commands/", "./extras/"]`

759* **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](/docs/it/plugin-marketplaces#advanced-plugin-entries), dichiarare sottodirectory specifiche sostituisce la scansione predefinita `skills/`

760* **Regole di merge proprie**: [hooks](#hooks), [server MCP](#mcp-servers), e [server LSP](#lsp-servers). Vedi ogni sezione per come più fonti si combinano

~~761~~

762Quando 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.

~~763~~

764Per tutti i campi del percorso:

~~765~~

766* Tutti i percorsi devono essere relativi alla radice del plugin e iniziare con `./`, tranne che il campo `skills` accetta anche `"."`

767 * Sia `"."` che `"./"` denotano la radice del plugin stesso

768 * Prima della v2.1.221, `"."` falliva la convalida del manifest e il plugin non si caricava, quindi usa `"./"` per supportare versioni precedenti

769* I componenti da percorsi personalizzati utilizzano le stesse regole di denominazione e spazio dei nomi, tranne i file agente. Vedi [Agenti](#agents) per come funzionano i nomi degli agenti

770* Più percorsi possono essere specificati come array

771* Un percorso di skill può puntare a una directory che contiene direttamente un `SKILL.md`, ad esempio `"skills": ["."]` per la radice del plugin

772 * Claude Code prende il nome di invocazione della skill dal campo frontmatter `name` in `SKILL.md`, quindi il nome rimane stabile qualunque sia il nome della directory di installazione

773 * Se `name` non è impostato nel frontmatter, Claude Code ricade sul basename della directory

~~774~~

775Un 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 hai bisogno di impostare `"skills": ["./"]` in `plugin.json` per questo layout.

~~776~~

777**Esempi di percorso**:

~~778~~

779```json theme={null}

780{

781 "commands": [

782 "./specialized/deploy.md",

783 "./utilities/batch-process.md"

784 ],

785 "agents": [

786 "./custom-agents/reviewer.md",

787 "./custom-agents/tester.md"

788 ]

789}

790```

~~791~~

792<h3 id="environment-variables">

793 Variabili di ambiente

794</h3>

~~795~~

796Claude Code fornisce tre variabili per fare riferimento ai percorsi:

~~797~~

798| Variabile | Si risolve in | Usala per |

799| :---------------------- | :---------------------------------------------------------------------------------------------------------------------------- | :-------------------------------------------------------------------------------------------- |

800| `${CLAUDE_PLUGIN_ROOT}` | Percorso assoluto della directory di installazione del plugin | Script, binari e file di configurazione forniti con il plugin |

801| `${CLAUDE_PLUGIN_DATA}` | [Directory persistente](#persistent-data-directory) che sopravvive agli aggiornamenti del plugin, creata al primo riferimento | Dipendenze installate come `node_modules` o ambienti virtuali Python, codice generato e cache |

802| `${CLAUDE_PROJECT_DIR}` | La radice del progetto | Script e file di configurazione locali del progetto |

~~803~~

804Tutti e tre vengono esportati come variabili di ambiente ai processi hook e ai sottoprocessi del server MCP e LSP. Non sono presenti nell'ambiente dei comandi che Claude esegue attraverso lo strumento Bash, nella sessione principale o in un subagente. Nel contenuto del plugin, scrivi il placeholder invece, e Claude Code sostituisce il percorso inline quando carica il contenuto. Quali campi sostituiscono inline dipende dal componente del plugin:

~~805~~

806| Componente del plugin | Campi dove i placeholder si risolvono |

807| :----------------------------- | :------------------------------------------ |

808| Contenuto di skill e agente | Ovunque appaia il placeholder |

809| Comandi hook e monitor | Ovunque appaia il placeholder |

810| Server MCP `stdio` | `command`, `args`, `env` |

811| Server MCP `http`, `sse`, `ws` | `url`, `headers`, `headersHelper` |

812| Server LSP | `command`, `args`, `env`, `workspaceFolder` |

~~813~~

814Nei comandi hook, usa [forma exec](/docs/it/hooks#exec-form-and-shell-form) con `args` in modo che ogni percorso venga passato come un argomento senza virgolette. Negli hook in forma shell e nei comandi monitor, avvolgi 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:

~~815~~

816```json theme={null}

817{

818 "hooks": {

819 "PostToolUse": [

820 {

821 "hooks": [

822 {

823 "type": "command",

824 "command": "\"${CLAUDE_PLUGIN_ROOT}\"/scripts/process.sh"

825 }

826 ]

827 }

828 ]

829 }

830}

831```

~~832~~

833Per un plugin copiato, `${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 trattala come effimera e non scrivere stato lì. Per un plugin caricato in place da un marketplace di directory locale, la variabile punta alla directory sorgente stabile. Vedi [plugin caching](#plugin-caching-and-file-resolution) per quali plugin vengono copiati e per la semantica di pulizia.

~~834~~

835Quando un plugin copiato 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. Esegui `/reload-plugins` per passare hook, server MCP e 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 vecchio percorso fino alla sessione successiva.

~~836~~

837Per un plugin con una `command` source, Claude Code [può ricaricare il plugin stesso](/docs/it/plugin-marketplaces#when-claude-code-re-runs-the-command).

~~838~~

839I server MCP possono anche chiamare la richiesta `roots/list` per leggere le directory di lavoro della sessione al runtime. Vedi [cosa restituisce `roots/list` e quando Claude Code notifica al server i cambiamenti](/docs/it/mcp#option-3-add-a-local-stdio-server).

~~840~~

841<h4 id="persistent-data-directory">

842 Directory di dati persistenti

843</h4>

~~844~~

845La 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/`.

~~846~~

847Un uso comune è installare dipendenze di linguaggio una volta e riutilizzarle tra sessioni e aggiornamenti di plugin. Usala per dipendenze Python, dipendenze bloccate con Yarn o pnpm, e pacchetti i cui script del ciclo di vita devono essere eseguiti. Per un plugin installato dal marketplace, potresti non averne bisogno affatto: Claude Code installa automaticamente le [dipendenze del pacchetto Node.js](#node-js-package-dependencies) idonee quando memorizza il plugin nella cache.

~~848~~

849Poiché 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 di dipendenza del plugin. Il modello consigliato confronta il manifest fornito rispetto a una copia nella directory di dati e reinstalla quando differiscono.

~~850~~

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

~~852~~

853```json theme={null}

854{

855 "hooks": {

856 "SessionStart": [

857 {

858 "hooks": [

859 {

860 "type": "command",

861 "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\""

862 }

863 ]

864 }

865 ]

866 }

867}

868```

~~869~~

870Il `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.

~~871~~

872Gli script forniti in `${CLAUDE_PLUGIN_ROOT}` possono quindi essere eseguiti rispetto ai `node_modules` persistiti:

~~873~~

874```json theme={null}

875{

876 "mcpServers": {

877 "routines": {

878 "command": "node",

879 "args": ["${CLAUDE_PLUGIN_ROOT}/server.js"],

880 "env": {

881 "NODE_PATH": "${CLAUDE_PLUGIN_DATA}/node_modules"

882 }

883 }

884 }

885}

886```

~~887~~

888La directory di dati viene eliminata automaticamente quando disinstalli 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; passa [`--keep-data`](#plugin-uninstall) per preservarla.

~~889~~

890***

~~891~~

892<h2 id="plugin-caching-and-file-resolution">

893 Caching dei plugin e risoluzione dei file

894</h2>

~~895~~

896I plugin vengono specificati in uno di tre modi:

~~897~~

898* Tramite `claude --plugin-dir` o `claude --plugin-url`, per la durata di una sessione.

899* Tramite un marketplace, installato per sessioni future.

900* Tramite il vostro account claude.ai, [sincronizzato](#synced-plugins) in `~/.claude/plugins/synced/`.

~~901~~

902Per motivi di sicurezza e verifica, Claude Code copia i plugin del *marketplace* nella **cache dei plugin** locale dell'utente (`~/.claude/plugins/cache`), a meno che il plugin non si carichi sul posto. Una [`command` source in link mode](/docs/it/plugin-marketplaces#copy-mode-and-link-mode) si carica sul posto tramite link nella voce della cache. Una [relative path source](/docs/it/plugin-marketplaces#relative-paths) in un marketplace aggiunto da una directory locale si carica sul posto dalla cartella del marketplace.

~~903~~

904Per un plugin caricato sul posto da un marketplace di directory locale, le vostre modifiche alla directory di origine hanno effetto all'avvio della sessione successiva o `/reload-plugins`. Non avete bisogno di un bump di versione. I processi hook del plugin e i server MCP e LSP ricevono un `CLAUDE_PLUGIN_ROOT` che punta alla directory di origine. Claude Code non installa le [dipendenze dei pacchetti Node.js](#node-js-package-dependencies) del plugin nella directory di origine. Installatele lì voi stessi, o da un hook nella [directory dei dati persistenti](#persistent-data-directory).

~~905~~

906Per 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](#node-js-package-dependencies). Una dipendenza risolta da un [release tag](/docs/it/plugin-dependencies#tag-plugin-releases-for-version-resolution) ottiene un nome di directory con un suffisso commit-SHA.

~~907~~

908Quando 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.

~~909~~

910Claude 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.

~~911~~

912Gli 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.

~~913~~

914<h3 id="node-js-package-dependencies">

915 Dipendenze dei pacchetti Node.js

916</h3>

~~917~~

918Quando 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](/docs/it/plugin-dependencies).

~~919~~

920Claude 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:

~~921~~

922| Lockfile | Comando |

923| :------------------------------------------ | :----------------------------------------------- |

924| `bun.lock` o `bun.lockb` | `bun install --frozen-lockfile --ignore-scripts` |

925| `npm-shrinkwrap.json` o `package-lock.json` | `npm ci --ignore-scripts` |

~~926~~

927Se 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`.

~~928~~

929Claude Code salta l'installazione in due casi, ognuno con la propria soluzione:

~~930~~

931* Se il vostro plugin contiene solo un `yarn.lock` o `pnpm-lock.yaml`, sostituiscilo con un lockfile npm.

932* Se un `bunfig.toml` si trova accanto al lockfile bun, rimuovete il `bunfig.toml`, o sostituite il lockfile bun con un lockfile npm.

~~933~~

934Fornite 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.

~~935~~

936Claude 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:

~~937~~

938* **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.

939* **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.

940* **Timeout di 60 secondi:** Claude Code interrompe un'installazione che dura più a lungo e la tratta come non riuscita.

~~941~~

942Claude Code recupera un plugin da fonte npm prima di questa installazione di dipendenze, e nessuno degli script di installazione del pacchetto stesso viene eseguito durante il recupero. Vedere [pacchetti npm](/docs/it/plugin-marketplaces#npm-packages).

~~943~~

944Un'installazione non riuscita o saltata non blocca mai il plugin. Quando l'installazione fallisce, o Claude Code salta un lockfile yarn o pnpm o un `bunfig.toml`, registra il motivo come avviso nell'[output di debug](#debugging-commands). 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.

~~945~~

946Non potete disattivare l'installazione automatica; nessuna impostazione o variabile di ambiente la disabilita. In reti ristrette, vedere i [requisiti di accesso alla rete](/docs/it/network-config#network-access-requirements) per gli host da consentire.

~~947~~

948Per 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](#persistent-data-directory).

~~949~~

950<h3 id="path-traversal-limitations">

951 Limitazioni dell'attraversamento dei percorsi

952</h3>

~~953~~

954Claude 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](/docs/it/plugin-marketplaces#plugin-entries). 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](#share-files-within-a-marketplace-with-symlinks).

~~955~~

956Su macOS e Linux, Claude Code rifiuta anche un percorso di componente che contiene una barra rovesciata in qualsiasi punto, anche quando il percorso rimane all'interno del plugin. I componenti dichiarati con percorsi con barra rovesciata quindi si caricano solo su Windows. Scrivete i percorsi dei componenti con barre oblique, come `./commands/deploy.md`.

~~957~~

958Quando Claude Code rifiuta un percorso, segnala un errore [`path escapes plugin directory`](/docs/it/errors#path-escapes-plugin-directory) e carica il plugin senza quel componente.

~~959~~

960Claude 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.

~~961~~

962<h3 id="share-files-within-a-marketplace-with-symlinks">

963 Condividere file all'interno di un marketplace con symlink

964</h3>

~~965~~

966Se 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:

~~967~~

968* **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.

969* **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.

970* **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.

~~971~~

972Per i plugin installati con `--plugin-dir`, da un percorso locale, o da una [`command` source](/docs/it/plugin-marketplaces#copy-mode-and-link-mode) in copy mode, solo i symlink che si risolvono all'interno della directory del plugin stesso vengono preservati. Tutti gli altri vengono saltati.

~~973~~

974Il 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:

~~975~~

976```bash theme={null}

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

978```

~~979~~

980***

~~981~~

982<h2 id="plugin-directory-structure">

983 Struttura della directory dei plugin

984</h2>

~~985~~

986<h3 id="standard-plugin-layout">

987 Layout standard dei plugin

988</h3>

~~989~~

990Un plugin completo segue questa struttura:

~~991~~

992```text theme={null}

993enterprise-plugin/

994├── .claude-plugin/ # Directory dei metadati (opzionale)

995│ └── plugin.json # plugin manifest

996├── skills/ # Skills

997│ ├── code-reviewer/

998│ │ └── SKILL.md

999│ └── pdf-processor/

1000│ ├── SKILL.md

1001│ └── scripts/

1002├── commands/ # Skills come file .md flat

1003│ ├── status.md

1004│ └── logs.md

1005├── agents/ # Definizioni dei subagent

1006│ ├── security-reviewer.md

1007│ ├── performance-tester.md

1008│ ├── compliance-checker.md

1009│ └── review/ # Gli agent qui si caricano come enterprise-plugin:review:<name>

1010│ └── accessibility.md

1011├── workflows/ # Script dei workflow

1012│ └── release-audit.js

1013├── output-styles/ # Definizioni dello stile di output

1014│ └── terse.md

1015├── themes/ # Definizioni dei temi colore

1016│ └── dracula.json

1017├── monitors/ # Configurazioni dei monitor in background

1018│ └── monitors.json

1019├── hooks/ # Configurazioni degli hook

1020│ ├── hooks.json # Configurazione principale degli hook

1021│ └── security-hooks.json # Hook aggiuntivi

1022├── bin/ # Eseguibili del plugin aggiunti a PATH

1023│ └── my-tool # Invocabile come comando bare in Bash tool

1024├── settings.json # Impostazioni predefinite per il plugin

1025├── .mcp.json # Definizioni dei server MCP

1026├── .lsp.json # Configurazioni dei server LSP

1027├── scripts/ # Script degli hook e script di utilità

1028│ ├── security-scan.sh

1029│ ├── format-code.py

1030│ └── deploy.js

1031├── LICENSE # File di licenza

1032└── CHANGELOG.md # Cronologia delle versioni

1033```

~~1034~~

1035<Warning>

1036 La directory `.claude-plugin/` contiene il file `plugin.json`. Tutte le altre directory (commands/, agents/, skills/, workflows/, output-styles/, themes/, monitors/, hooks/) devono trovarsi nella radice del plugin, non all'interno di `.claude-plugin/`.

1037</Warning>

~~1038~~

1039Un 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](#skills).

~~1040~~

1041<h3 id="file-locations-reference">

1042 Riferimento delle posizioni dei file

1043</h3>

~~1044~~

1045| Componente | Posizione predefinita | Scopo |

1046| :---------------- | :--------------------------- | :----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |

1047| **Manifest** | `.claude-plugin/plugin.json` | Metadati e configurazione del plugin (opzionale) |

1048| **Skills** | `skills/` | Skills con struttura `<name>/SKILL.md` |

1049| **Commands** | `commands/` | Skills come file Markdown flat. Utilizzare `skills/` per i nuovi plugin |

1050| **Agents** | `agents/` | File Markdown dei subagent. Le sottocartelle fanno parte del [nome dell'agent](#agents) |

1051| **Workflows** | `workflows/` | File script dei [Workflow](/docs/it/workflows) |

1052| **Output styles** | `output-styles/` | Definizioni dello stile di output |

1053| **Themes** | `themes/` | Definizioni dei temi colore |

1054| **Hooks** | `hooks/hooks.json` | Configurazione degli hook |

1055| **Server MCP** | `.mcp.json` | Definizioni dei server MCP |

1056| **Server LSP** | `.lsp.json` | Configurazioni dei language server |

1057| **Monitors** | `monitors/monitors.json` | Configurazioni dei monitor in background |

1058| **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](/docs/it/plugin-marketplaces#keep-executables-out-of-the-top-level-bin-directory) |

1059| **Impostazioni** | `settings.json` | Configurazione predefinita applicata quando il plugin è abilitato. Sono supportate solo le chiavi [`agent`](/docs/it/sub-agents) e [`subagentStatusLine`](/docs/it/statusline#subagent-status-lines) |

~~1060~~

1061***

~~1062~~

1063<h2 id="cli-commands-reference">

1064 Riferimento dei comandi CLI

1065</h2>

~~1066~~

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

~~1068~~

1069<h3 id="plugin-init">

1070 plugin init

1071</h3>

~~1072~~

1073Crea 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.

~~1074~~

1075Vedi [Skills-directory plugins](#skills-directory-plugins) per i requisiti di ambito e fiducia.

~~1076~~

1077```bash theme={null}

1078claude plugin init <name> [options]

1079```

~~1080~~

1081Il comando accetta questi argomenti:

~~1082~~

1083* `<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.

~~1084~~

1085Il comando accetta queste opzioni:

~~1086~~

1087| Opzione | Descrizione | Predefinito |

1088| :----------------------- | :------------------------------------------------------------------------------------------------------------------------------------------- | :---------------------- |

1089| `--description <text>` | Descrizione del manifest | |

1090| `--author <name>` | Nome dell'autore | `git config user.name` |

1091| `--author-email <email>` | Email dell'autore | `git config user.email` |

1092| `--with <components...>` | Crea anche lo scaffolding delle cartelle dei componenti. Valori validi: `skills`, `agents`, `hooks`, `mcp`, `lsp`, `output-style`, `channel` | |

1093| `-f, --force` | Sovrascrivi un `.claude-plugin/` esistente nel target | |

1094| `-h, --help` | Visualizza la guida per il comando | |

~~1095~~

1096`claude plugin new` è un alias per questo comando.

~~1097~~

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

~~1099~~

1100| Componente | Cosa crea lo scaffolding |

1101| :------------- | :-------------------------------------------------------------------------------------------------------------- |

1102| `skills` | Una skill aggiuntiva con spazio dei nomi `<name>:example` insieme a quella predefinita |

1103| `agents` | Una definizione di subagent in `agents/` |

1104| `hooks` | Un `hooks/hooks.json` con un gestore di eventi di esempio |

1105| `mcp` | Un `.mcp.json` con esempi di server HTTP e stdio |

1106| `lsp` | Un esempio di language-server `.lsp.json` |

1107| `output-style` | Un `output-styles/<name>.md` che si applica automaticamente mentre il plugin è abilitato |

1108| `channel` | Un [channel](/docs/it/channels) basato su MCP: un server stdio (`server.ts`), il suo `.mcp.json` e un `package.json` |

~~1109~~

1110Il 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](/docs/it/plugin-marketplaces#managed-marketplace-restrictions). Quando bloccato, `plugin init` fallisce prima di scrivere.

~~1111~~

1112Questi esempi mostrano invocazioni comuni:

~~1113~~

1114```bash theme={null}

1115# Crea lo scaffolding di un plugin minimo

1116claude plugin init my-helper

~~1117~~

1118# Crea lo scaffolding con cartelle skill e hook

1119claude plugin init my-helper --with skills hooks

~~1120~~

1121# Sovrascrivi uno scaffolding esistente

1122claude plugin init my-helper --force

1123```

~~1124~~

1125<h3 id="plugin-install">

1126 plugin install

1127</h3>

~~1128~~

1129Installa un plugin dai marketplace disponibili.

~~1130~~

1131```bash theme={null}

1132claude plugin install <plugin> [options]

1133```

~~1134~~

1135Il comando accetta questi argomenti:

~~1136~~

1137* `<plugin>`: Nome del plugin o `plugin-name@marketplace-name` per un marketplace specifico

~~1138~~

1139Il comando accetta queste opzioni:

~~1140~~

1141| Opzione | Descrizione | Predefinito |

1142| :-------------------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | :---------- |

1143| `-s, --scope <scope>` | Ambito di installazione: `user`, `project` o `local` | `user` |

1144| `--config <key=value>` | Imposta un'opzione [`userConfig`](#user-configuration) dichiarata nel manifest del plugin. Ripeti il flag per impostare più opzioni | |

1145| `-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](/docs/it/plugin-marketplaces#command-sources), o l'[`headersHelper`](/docs/it/plugin-marketplaces#authenticate-archive-downloads) 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, a meno che non passi `--accept-command`. Non ha effetto all'interno di una sessione di Claude Code, quindi esegui il comando dal tuo terminale | |

1146| `--accept-command <sha256>` | Accetta il comando dichiarato dal marketplace il cui `sha256` una precedente esecuzione [`--json`](#plugin-json-result) ha segnalato in `shownCommand`, al posto di `-y`. L'accettazione conta esattamente per quel comando, plugin e catalogo del marketplace. Se uno qualsiasi di essi è cambiato da quando il comando è stato visualizzato, incluso attraverso l'aggiornamento del marketplace della stessa esecuzione, Claude Code non accetta il digest e mostra di nuovo il comando. Non può essere combinato con `-y`. Non ha effetto all'interno di una sessione di Claude Code, quindi esegui il comando dal tuo terminale. Richiede Claude Code v2.1.271 o successivo | |

1147| `--json` | Stampa il risultato come un oggetto JSON sulla ultima riga di stdout invece del messaggio leggibile, per l'uso negli script. Vedi [Formato del risultato JSON](#plugin-json-result). Richiede Claude Code v2.1.268 o successivo | |

1148| `-h, --help` | Visualizza la guida per il comando | |

~~1149~~

1150L'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.

~~1151~~

1152<span id="plugin-json-result" />Con `--json`, l'ultima riga di stdout è un oggetto JSON. Analizza solo quella riga, perché Claude Code stampa qualsiasi comando che il marketplace dichiara prima di essa. Tre campi sono sempre presenti:

~~1153~~

1154* `command`: il sottocomando che è stato eseguito, come `install`

1155* `outcome`: `ok` o `failed`

1156* `message`: una descrizione leggibile del risultato

~~1157~~

1158Altri campi, come `pluginId`, `scope` e `failureCode`, appaiono solo quando applicabili. L'opzione `--json` su `plugin uninstall`, `plugin update`, `plugin enable` e `plugin disable` stampa lo stesso oggetto con i campi propri di quel sottocomando. Un errore di utilizzo, come uno `--scope` non valido, non stampa alcuna riga di risultato ed esce con 1 con il motivo su stderr.

~~1159~~

1160Quando un'esecuzione visualizza un comando dichiarato dal marketplace e non lo esegue, il risultato `failed` porta anche un oggetto `shownCommand` i cui campi includono il comando come visualizzato, il plugin a cui appartiene e lo `sha256` del comando. Per accettare esattamente quel comando, esegui di nuovo con quello `sha256` come `--accept-command`. Richiede Claude Code v2.1.271 o successivo.

~~1161~~

1162Se `shownCommand.acceptCommandMatched` è `false`, il digest che hai passato non corrisponde al comando ora visualizzato. Mostra quel comando a una persona prima di passare il suo `sha256`.

~~1163~~

1164Questi esempi mostrano invocazioni comuni:

~~1165~~

1166```bash theme={null}

1167# Installa nell'ambito utente (predefinito)

1168claude plugin install formatter@my-marketplace

~~1169~~

1170# Installa nell'ambito progetto (condiviso con il team)

1171claude plugin install formatter@my-marketplace --scope project

~~1172~~

1173# Installa nell'ambito locale (non condiviso con il team)

1174claude plugin install formatter@my-marketplace --scope local

1175```

~~1176~~

1177<h3 id="plugin-uninstall">

1178 plugin uninstall

1179</h3>

~~1180~~

1181Rimuovi un plugin installato.

~~1182~~

1183```bash theme={null}

1184claude plugin uninstall <plugin> [options]

1185```

~~1186~~

1187Il comando accetta questi argomenti:

~~1188~~

1189* `<plugin>`: Nome del plugin o `plugin-name@marketplace-name`

~~1190~~

1191Il comando accetta queste opzioni:

~~1192~~

1193| Opzione | Descrizione | Predefinito |

1194| :-------------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :---------- |

1195| `-s, --scope <scope>` | Disinstalla dall'ambito: `user`, `project` o `local` | `user` |

1196| `--keep-data` | Preserva la [persistent data directory](#persistent-data-directory) del plugin | |

1197| `--prune` | Rimuovi anche le dipendenze auto-installate che nessun altro plugin richiede. Vedi [plugin prune](#plugin-prune) | |

1198| `-y, --yes` | Salta il prompt di conferma `--prune`. Obbligatorio quando stdin o stdout non è un TTY | |

1199| `--json` | Stampa il risultato come un oggetto JSON sulla ultima riga di stdout, nello [stesso formato di `plugin install --json`](#plugin-json-result). Non può essere combinato con `--prune`. Richiede Claude Code v2.1.268 o successivo | |

1200| `-h, --help` | Visualizza la guida per il comando | |

~~1201~~

1202`claude plugin remove` e `claude plugin rm` sono alias per questo comando.

~~1203~~

1204Per 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.

~~1205~~

1206<Note>

1207 Quando i plugin installati da diversi marketplace condividono un nome, il modulo `plugin-name@marketplace-name` disinstalla solo il plugin dal marketplace denominato. Prima della v2.1.212, il modulo qualificato potrebbe corrispondere e disinstallare lo stesso plugin denominato da un marketplace diverso.

1208</Note>

~~1209~~

1210<h3 id="plugin-prune">

1211 plugin prune

1212</h3>

~~1213~~

1214Rimuovi 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`](/docs/it/plugin-dependencies) di un altro plugin vengono rimosse; i plugin che hai installato direttamente non vengono mai toccati.

~~1215~~

1216```bash theme={null}

1217claude plugin prune [options]

1218```

~~1219~~

1220Il comando accetta queste opzioni:

~~1221~~

1222| Opzione | Descrizione | Predefinito |

1223| :-------------------- | :--------------------------------------------------------------------------- | :---------- |

1224| `-s, --scope <scope>` | Prune all'ambito: `user`, `project` o `local` | `user` |

1225| `--dry-run` | Elenca cosa verrebbe rimosso senza rimuovere nulla | |

1226| `-y, --yes` | Salta il prompt di conferma. Obbligatorio quando stdin o stdout non è un TTY | |

1227| `-h, --help` | Visualizza la guida per il comando | |

~~1228~~

1229`claude plugin autoremove` è un alias per questo comando.

~~1230~~

1231Il 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`.

~~1232~~

1233<h3 id="plugin-enable">

1234 plugin enable

1235</h3>

~~1236~~

1237Abilita un plugin disabilitato. Quando il target è installato da un marketplace e dichiara [dependencies](/docs/it/plugin-dependencies), Claude Code li abilita transitivamente nello stesso ambito. Il comando fallisce nelle condizioni che [Enable or disable a plugin with dependencies](/docs/it/plugin-dependencies#enable-or-disable-a-plugin-with-dependencies) elenca.

~~1238~~

1239```bash theme={null}

1240claude plugin enable <plugin> [options]

1241```

~~1242~~

1243Il comando accetta questi argomenti:

~~1244~~

1245* `<plugin>`: Nome del plugin, `plugin-name@marketplace-name` o `plugin-name@synced` per un [plugin sincronizzato da claude.ai](#synced-plugins)

~~1246~~

1247Il comando accetta queste opzioni:

~~1248~~

1249| Opzione | Descrizione | Predefinito |

1250| :-------------------- | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :---------- |

1251| `-s, --scope <scope>` | Ambito da abilitare: `user`, `project` o `local`. Quando omesso, Claude Code rileva l'ambito in cui il plugin è installato | Auto-detect |

1252| `--json` | Stampa il risultato come un oggetto JSON sulla ultima riga di stdout, nello [stesso formato di `plugin install --json`](#plugin-json-result). Richiede Claude Code v2.1.268 o successivo | |

1253| `-h, --help` | Visualizza la guida per il comando | |

~~1254~~

1255<h3 id="plugin-disable">

1256 plugin disable

1257</h3>

~~1258~~

1259Disabilita un plugin senza disinstallarlo.

~~1260~~

1261Quando il target è installato da un marketplace, il comando fallisce se un altro plugin abilitato [dipende da](/docs/it/plugin-dependencies#enable-or-disable-a-plugin-with-dependencies) esso. Il messaggio di errore include un comando concatenato che disabilita prima ogni dipendente.

~~1262~~

1263Per un [synced plugin](#synced-plugins) che la tua organizzazione richiede, il comando fallisce e non salva nulla.

~~1264~~

1265```bash theme={null}

1266claude plugin disable [plugin] [options]

1267```

~~1268~~

1269Il comando accetta questi argomenti:

~~1270~~

1271* `[plugin]`: Nome del plugin, `plugin-name@marketplace-name` o `plugin-name@synced` per un [plugin sincronizzato da claude.ai](#synced-plugins). Facoltativo quando si usa `--all`

~~1272~~

1273Il comando accetta queste opzioni:

~~1274~~

1275| Opzione | Descrizione | Predefinito |

1276| :-------------------- | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :---------- |

1277| `-a, --all` | Disabilita tutti i plugin abilitati. Non può essere combinato con `--scope` | |

1278| `-s, --scope <scope>` | Ambito da disabilitare: `user`, `project` o `local`. Quando omesso, Claude Code rileva l'ambito in cui il plugin è installato | Auto-detect |

1279| `--json` | Stampa il risultato come un oggetto JSON sulla ultima riga di stdout, nello [stesso formato di `plugin install --json`](#plugin-json-result). Richiede Claude Code v2.1.268 o successivo | |

1280| `-h, --help` | Visualizza la guida per il comando | |

~~1281~~

1282<h3 id="plugin-update">

1283 plugin update

1284</h3>

~~1285~~

1286Aggiorna un plugin all'ultima versione.

~~1287~~

1288```bash theme={null}

1289claude plugin update <plugin> [options]

1290```

~~1291~~

1292Il comando accetta questi argomenti:

~~1293~~

1294* `<plugin>`: Nome del plugin o `plugin-name@marketplace-name`

~~1295~~

1296Il comando accetta queste opzioni:

~~1297~~

1298| Opzione | Descrizione | Predefinito |

1299| :-------------------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | :---------- |

1300| `-s, --scope <scope>` | Ambito da aggiornare: `user`, `project`, `local` o `managed` | `user` |

1301| `-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](/docs/it/plugin-marketplaces#command-sources), o l'[`headersHelper`](/docs/it/plugin-marketplaces#authenticate-archive-downloads) 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, a meno che non passi `--accept-command`. Non ha effetto all'interno di una sessione di Claude Code, quindi esegui il comando dal tuo terminale | |

1302| `--accept-command <sha256>` | Accetta il comando dichiarato dal marketplace il cui `sha256` una precedente esecuzione [`--json`](#plugin-json-result) ha segnalato in `shownCommand`, al posto di `-y`. L'accettazione conta esattamente per quel comando, plugin e catalogo del marketplace. Se uno qualsiasi di essi è cambiato da quando il comando è stato visualizzato, incluso attraverso l'aggiornamento del marketplace della stessa esecuzione, Claude Code non accetta il digest e mostra di nuovo il comando. Non può essere combinato con `-y`. Non ha effetto all'interno di una sessione di Claude Code, quindi esegui il comando dal tuo terminale. Richiede Claude Code v2.1.271 o successivo | |

1303| `--json` | Stampa il risultato come un oggetto JSON sulla ultima riga di stdout, nello [stesso formato di `plugin install --json`](#plugin-json-result). Richiede Claude Code v2.1.268 o successivo | |

1304| `-h, --help` | Visualizza la guida per il comando | |

~~1305~~

1306<Note>

1307 Claude Code risolve un nome di plugin semplice rispetto ai plugin installati. Quando i plugin installati da diversi marketplace condividono il nome, Claude Code rifiuta l'aggiornamento ed elenca i comandi `plugin-name@marketplace-name` qualificati da eseguire invece. Prima della v2.1.246, Claude Code accettava solo il modulo qualificato e rifiutava un nome semplice come non trovato.

1308</Note>

~~1309~~

1310***

~~1311~~

1312<h3 id="plugin-list">

1313 plugin list

1314</h3>

~~1315~~

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

~~1317~~

1318```bash theme={null}

1319claude plugin list [options]

1320```

~~1321~~

1322Il comando accetta queste opzioni:

~~1323~~

1324| Opzione | Descrizione | Predefinito |

1325| :------------ | :----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :---------- |

1326| `--json` | Output come JSON. Una riga di plugin con problemi di caricamento o avvisi di authoring porta array di stringhe `errors` o `notes`. Su Claude Code v2.1.268 o successivo, array paralleli `errorDetails` e `noteDetails` forniscono il `type` diagnostico di ogni voce e i nomi a cui si riferisce, come il plugin, il marketplace, il server o il file | |

1327| `--available` | Includi i plugin disponibili dai marketplace. Richiede `--json` | |

1328| `-h, --help` | Visualizza la guida per il comando | |

~~1329~~

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

~~1331~~

1332* I plugin caricati dalle directory delle skill appaiono nell'interfaccia `/plugin` e in `claude plugin list`, ma non nell'output inline `/plugin list`.

1333* I [plugin sincronizzati da claude.ai](#synced-plugins) appaiono in `claude plugin list` su Claude Code v2.1.239 o successivo e nell'interfaccia `/plugin`, ma non nell'output inline `/plugin list`.

1334* 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.

~~1335~~

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

~~1337~~

1338<h3 id="plugin-details">

1339 plugin details

1340</h3>

~~1341~~

1342Mostra 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/`.

~~1343~~

1344```bash theme={null}

1345claude plugin details <name>

1346```

~~1347~~

1348Il comando accetta questi argomenti:

~~1349~~

1350* `<name>`: Nome del plugin o `plugin-name@marketplace-name`

~~1351~~

1352Il comando accetta queste opzioni:

~~1353~~

1354| Opzione | Descrizione | Predefinito |

1355| :----------- | :--------------------------------- | :---------- |

1356| `-h, --help` | Visualizza la guida per il comando | |

~~1357~~

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

~~1359~~

1360* **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.

1361* **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.

~~1362~~

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

~~1364~~

1365```

1366dependency-guard 1.2.0

1367 Dependency analysis for Claude Code sessions

1368 Source: dependency-guard@example-marketplace

~~1369~~

1370Component inventory

1371 Skills (2) scan-dependencies, review-changes

1372 Agents (0)

1373 Hooks (1) SessionStart (harness-only — no model context cost)

1374 MCP servers (0)

1375 LSP servers (0)

~~1376~~

1377Projected token cost

1378 Always-on: ~180 tok added to every session

~~1379~~

1380Per-component (rounded)

1381 component always-on on-invoke

1382 scan-dependencies ~100 ~2400

1383 review-changes ~80 ~1800

~~1384~~

1385 On-invoke cost is paid each time a skill or agent fires.

1386 Token counts are estimates and may differ from actual usage.

1387```

~~1388~~

1389Il 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.

~~1390~~

1391<h3 id="plugin-validate">

1392 plugin validate

1393</h3>

~~1394~~

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

~~1396~~

1397Il 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.

~~1398~~

1399```bash theme={null}

1400claude plugin validate <path> [options]

1401```

~~1402~~

1403Il comando accetta questi argomenti:

~~1404~~

1405* `<path>`: Percorso a una directory di plugin o una directory di marketplace. Vedi [Validate a plugin or a directory without a manifest](/docs/it/plugin-marketplaces#validate-a-plugin-or-a-directory-without-a-manifest) per quali file una esecuzione di plugin copre.

~~1406~~

1407Il comando accetta queste opzioni:

~~1408~~

1409| Opzione | Descrizione | Predefinito |

1410| :----------- | :---------------------------------------------------------------------------------------------------------------------------------------------------------------- | :---------- |

1411| `--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](#unrecognized-fields) | |

1412| `--json` | Output il rapporto di convalida come un oggetto JSON con gli stessi codici di uscita. Richiede Claude Code v2.1.259 o successivo | |

1413| `-h, --help` | Visualizza la guida per il comando | |

~~1414~~

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

~~1416~~

1417* `success`: lo stesso verdetto che il codice di uscita fornisce

1418* `strict`: se l'esecuzione ha trattato gli avvisi come errori

1419* `target`: il percorso risolto che Claude Code ha convalidato

1420* `manifest`: il risultato del manifest stesso, o `null` per un'[esecuzione senza manifest](/docs/it/plugin-marketplaces#validate-a-plugin-or-a-directory-without-a-manifest)

1421* `contents`: risultati per file, ognuno nominando il suo `file` e portando array `errors`, `warnings` e `notes`

~~1422~~

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

~~1424~~

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

~~1426~~

1427<h3 id="plugin-eval">

1428 plugin eval

1429</h3>

~~1430~~

1431Esegui i [eval cases](/docs/it/plugin-evals) di un plugin e segnala i risultati valutati. Richiede Claude Code v2.1.269 o successivo. Ogni caso è un prompt più grader; Claude Code lo esegue più volte in una sessione isolata con solo il plugin target caricato, e per impostazione predefinita anche senza il plugin in modo che il rapporto mostri la differenza. Vedi [Test plugins with evals](/docs/it/plugin-evals) per il formato del caso, i grader, i risultati e l'utilizzo in CI.

~~1432~~

1433```bash theme={null}

1434claude plugin eval [target] [options]

1435```

~~1436~~

1437Il `target` facoltativo è una directory di plugin, un singolo file `prompt.md` o `case.yaml`, un plugin installato come `name` o `name@marketplace`, o `name@skills-dir`, e predefinito è la directory corrente. Mettilo prima di `--tag`, `--allow-tools` e `--json`.

~~1438~~

1439Questa tabella elenca le opzioni che la maggior parte delle esecuzioni utilizza. Esegui `claude plugin eval --help` per l'insieme completo, inclusi `--case`, `--tag`, `--output-dir`, `--report`, `--allow-real-servers`, `--keep-temp` e `--verbose`.

~~1440~~

1441| Opzione | Descrizione | Predefinito |

1442| :------------------------- | :----------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :--------------------------------------------------------------------------------------------------------- |

1443| `--runs <n>` | Esecuzioni per caso per braccio | Ogni `runs` del caso, altrimenti 3 |

1444| `-j, --concurrency <n>` | Sessioni di agent da eseguire contemporaneamente, da 1 a 8. Condividono il tuo limite di velocità | `1` |

1445| `--model <model>` | Modello per l'agent in test | Ogni `model` del caso, altrimenti `ANTHROPIC_MODEL` se impostato, altrimenti il predefinito di Claude Code |

1446| `--judge-model <model>` | Modello per i grader `llm` e `baseline` | Un modello piccolo e veloce |

1447| `--ablation <mode>` | `none` o `with-without`. Vedi [Compare against a no-plugin baseline](/docs/it/plugin-evals#compare-against-a-no-plugin-baseline) | `with-without` quando un plugin si risolve, altrimenti `none` |

1448| `--threshold <0..1>` | Esci con 1 se un caso qualsiasi punteggia al di sotto di questo | `1.0` |

1449| `--max-cost-usd <usd>` | Interrompi prima della prossima esecuzione una volta che la spesa raggiunge questo, esci con 2 e segnala risultati parziali | Nessun limite |

1450| `--allow-tools <tools...>` | Concedi strumenti oltre l'insieme di sola lettura, come `Bash`, `Write`, `Edit` o `"mcp__plugin_<plugin>_<server>__*"`. Vedi [Grant tools](/docs/it/plugin-evals#grant-tools) | |

1451| `--scaffold` | Esegui lo [`scaffold_script`](/docs/it/plugin-evals#add-setup-or-history-with-case-yaml) di ogni caso | Off |

1452| `--trust-plugin` | Salta il prompt di fiducia della prima esecuzione, per CI. Vedi [What a run can access](/docs/it/plugin-evals#security) | Off |

1453| `--mocks <mode>` | `record` o `off`. Vedi [Mock MCP servers](/docs/it/plugin-evals#mock-mcp-servers) | `record` |

1454| `--eval-dir <dir>` | Directory sotto il plugin che contiene i casi | Il `experimental.evals` del manifest, altrimenti `evals` |

1455| `--json [path]` | Stampa il [result document](/docs/it/plugin-evals#json-result) su stdout, o scrivilo in un percorso `.json` | |

1456| `--no-publish` | Mantieni il rapporto HTML locale | |

1457| `-h, --help` | Visualizza la guida per il comando | |

~~1458~~

1459Il comando esce con 0 quando ogni caso soddisfa la soglia, 1 su un caso fallito, un errore di caricamento o una directory di plugin non attendibile, 2 su un'esecuzione parziale, 130 quando interrotto e 143 quando terminato. Vedi [Run evals in CI](/docs/it/plugin-evals#run-evals-in-ci).

~~1460~~

1461<h3 id="plugin-eval-init">

1462 plugin eval init

1463</h3>

~~1464~~

1465Crea una suite di eval per il plugin nella directory corrente. Richiede Claude Code v2.1.269 o successivo. In un terminale questo avvia un'intervista di authoring che legge il plugin, propone casi e grader, li pilota e scrive i file. Con `--bare`, o senza un terminale, scrive invece un modello di singolo caso vuoto. Esegui da dentro una sessione interattiva di Claude Code, stampa le istruzioni dell'intervista per quella sessione da seguire piuttosto che scrivere un modello. Vedi [Create your first eval suite](/docs/it/plugin-evals#create-your-first-eval-suite).

~~1466~~

1467```bash theme={null}

1468claude plugin eval init [name] [options]

1469```

~~1470~~

1471Il `name` facoltativo è un nome di caso: l'intervista non ne ha bisogno, mentre `--bare` e il percorso del modello senza terminale lo richiedono. Accetta queste opzioni:

~~1472~~

1473| Opzione | Descrizione | Predefinito |

1474| :------------------ | :----------------------------------------------------------------------------------------------- | :------------------------------------------------------- |

1475| `--bare` | Scrivi un `prompt.md` vuoto e `graders/criteria.md` per `<name>` invece di eseguire l'intervista | |

1476| `-i, --interactive` | Richiedi l'intervista. Fallisce senza un terminale invece di scrivere un modello | |

1477| `--eval-dir <dir>` | Directory sotto la directory corrente in cui scrivere i casi | Il `experimental.evals` del manifest, altrimenti `evals` |

1478| `-h, --help` | Visualizza la guida per il comando | |

~~1479~~

1480<h3 id="plugin-tag">

1481 plugin tag

1482</h3>

~~1483~~

1484Crea 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](/docs/it/plugin-dependencies#tag-plugin-releases-for-version-resolution).

~~1485~~

1486```bash theme={null}

1487claude plugin tag [path] [options]

1488```

~~1489~~

1490Il comando accetta questi argomenti:

~~1491~~

1492* `[path]`: Percorso alla directory del plugin. Predefinito è la directory corrente.

~~1493~~

1494Il comando accetta queste opzioni:

~~1495~~

1496| Opzione | Descrizione | Predefinito |

1497| :-------------------- | :------------------------------------------------------------------------- | :---------- |

1498| `--push` | Spinge il tag al remote dopo averlo creato | |

1499| `--dry-run` | Stampa cosa verrebbe etichettato senza creare il tag | |

1500| `-f, --force` | Crea il tag anche se l'albero di lavoro è sporco o il tag esiste già | |

1501| `-m, --message <msg>` | Messaggio di annotazione del tag. Usa `%s` come segnaposto per la versione | |

1502| `--remote <name>` | Remote a cui spingere con `--push` | `origin` |

1503| `-h, --help` | Visualizza la guida per il comando | |

~~1504~~

1505***

~~1506~~

1507<h2 id="debugging-and-development-tools">

1508 Strumenti di debug e sviluppo

1509</h2>

~~1510~~

1511<h3 id="debugging-commands">

1512 Comandi di debug

1513</h3>

~~1514~~

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

~~1516~~

1517Questo mostra:

~~1518~~

1519* Quali plugin vengono caricati

1520* Eventuali errori nei manifest dei plugin

1521* Registrazione di skill, agent e hook

1522* Inizializzazione del server MCP

~~1523~~

1524<h3 id="common-issues">

1525 Problemi comuni

1526</h3>

~~1527~~

1528| Problema | Causa | Soluzione |

1529| :---------------------------------- | :------------------------------- | :----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |

1530| 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](/docs/it/plugin-marketplaces#validate-a-plugin-or-a-directory-without-a-manifest) per informazioni su cosa copre un'esecuzione |

1531| Skill non visualizzate | Struttura di directory errata | Assicurarsi che `skills/` o `commands/` sia nella radice del plugin, non dentro `.claude-plugin/` |

1532| Hook non attivati | Script non eseguibile | Eseguire `chmod +x script.sh` |

1533| Server MCP non funziona | `${CLAUDE_PLUGIN_ROOT}` mancante | Utilizzare la variabile per tutti i percorsi dei plugin |

1534| Errori di percorso | Percorsi assoluti utilizzati | Rendere i percorsi relativi, iniziando con `./`; vedere [Path behavior rules](#path-behavior-rules), che coprono l'eccezione `"."` del campo `skills` |

1535| LSP `Executable not found in $PATH` | Language server non installato | Installare il binario (ad es., `npm install -g typescript-language-server typescript`) |

~~1536~~

1537<h3 id="example-error-messages">

1538 Messaggi di errore di esempio

1539</h3>

~~1540~~

1541**Errori di convalida del manifest**:

~~1542~~

1543* `Invalid JSON syntax: Unexpected token } in JSON at position 142`: controllare la presenza di virgole mancanti, virgole extra o stringhe non quotate

1544* `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

1545* `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.

~~1546~~

1547**Errori di caricamento del plugin**:

~~1548~~

1549* `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

1550* `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

1551* `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

~~1552~~

1553<h3 id="hook-troubleshooting">

1554 Risoluzione dei problemi degli hook

1555</h3>

~~1556~~

1557**Script hook non in esecuzione**:

~~1558~~

15591. Verificare che lo script sia eseguibile: `chmod +x ./scripts/your-script.sh`

15602. Verificare la riga shebang: La prima riga deve essere `#!/bin/bash` o `#!/usr/bin/env bash`

15613. Verificare che il percorso utilizzi `${CLAUDE_PLUGIN_ROOT}`: `"command": "\"${CLAUDE_PLUGIN_ROOT}\"/scripts/your-script.sh"`

15624. Testare lo script manualmente: `./scripts/your-script.sh`

~~1563~~

1564**Hook non attivato su eventi previsti**:

~~1565~~

15661. Verificare che il nome dell'evento sia corretto (sensibile alle maiuscole): `PostToolUse`, non `postToolUse`

15672. Verificare che il pattern del matcher corrisponda ai vostri strumenti: `"matcher": "Write|Edit"` per le operazioni su file

15683. Confermare che il tipo di hook sia valido: `command`, `http`, `mcp_tool`, `prompt` o `agent`

~~1569~~

1570<h3 id="mcp-server-troubleshooting">

1571 Risoluzione dei problemi del server MCP

1572</h3>

~~1573~~

1574**Server non avviato**:

~~1575~~

15761. Verificare che il comando esista e sia eseguibile

15772. Verificare che tutti i percorsi utilizzino la variabile `${CLAUDE_PLUGIN_ROOT}`

15783. Controllare i log del server MCP: `claude --debug` mostra gli errori di inizializzazione

15794. Testare il server manualmente al di fuori di Claude Code

~~1580~~

1581**Strumenti del server non visualizzati**:

~~1582~~

15831. Assicurarsi che il server sia configurato correttamente in `.mcp.json` o `plugin.json`

15842. Verificare che il server implementi correttamente il protocollo MCP

15853. Controllare i timeout di connessione nell'output di debug

~~1586~~

1587<h3 id="directory-structure-mistakes">

1588 Errori di struttura della directory

1589</h3>

~~1590~~

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

~~1592~~

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

~~1594~~

1595**Elenco di controllo del debug**:

~~1596~~

15971. Eseguire `claude --debug` e cercare i messaggi "loading plugin"

15982. Verificare che ogni directory di componenti sia elencata nell'output di debug

15993. Verificare che i permessi dei file consentano la lettura dei file del plugin

~~1600~~

1601***

~~1602~~

1603<h2 id="distribution-and-versioning-reference">

1604 Riferimento di distribuzione e versioning

1605</h2>

~~1606~~

1607<h3 id="version-management">

1608 Gestione delle versioni

1609</h3>

~~1610~~

1611Claude 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. Un plugin [caricato in place](#plugin-caching-and-file-resolution) da un marketplace di directory locale carica i suoi file sorgente correnti all'inizio di ogni sessione, indipendentemente da ciò che dice la sua stringa di versione.

~~1612~~

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

~~1614~~

16151. Il campo `version` nel `plugin.json` del plugin

16162. Il campo `version` nella voce del plugin nel marketplace in `marketplace.json`

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

16184. Il digest SHA-256, per le [sorgenti `archive`](/docs/it/plugin-marketplaces#zip-archives): 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

16195. `unknown`, per le sorgenti `npm` o le directory locali quando né la directory del plugin né il suo marketplace è un repository git. Claude Code non prende la versione da un repository che racchiude il percorso di installazione, come un `~/.claude` gestito da git

~~1620~~

1621Per una [sorgente `command`](/docs/it/plugin-marketplaces#command-sources), 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](/docs/it/plugin-marketplaces#copy-mode-and-link-mode), l'hash copre il percorso reale della directory stampata e le sue voci di primo livello piuttosto che i contenuti dei file.

~~1622~~

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

~~1624~~

1626| :---------------------- | :--------------------------------------------------------------------------------------------------------------------------------------------- | :---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :----------------------------------------------------------------------------- |

1627| **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". Per un plugin [caricato in place](#plugin-caching-and-file-resolution), il nuovo contenuto si carica comunque. | Plugin pubblicati con cicli di rilascio stabili |

1628| **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 |

1629| **Versione Digest** | Utilizza una [sorgente `archive`](/docs/it/plugin-marketplaces#zip-archives) 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 |

~~1630~~

1631Se utilizzi versioni esplicite, segui il [semantic versioning](https://semver.org) (`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`.

~~1632~~

1633***

~~1634~~

1635<h2 id="see-also">

1636 Vedi anche

1637</h2>

~~1638~~

1639* [Plugin](/docs/it/plugins) - Tutorial e utilizzo pratico

1640* [Marketplace dei plugin](/docs/it/plugin-marketplaces) - Creazione e gestione dei marketplace

1641* [Skills](/docs/it/skills) - Dettagli dello sviluppo delle skill

1642* [Subagents](/docs/it/sub-agents) - Configurazione e capacità dell'agent

1643* [Hooks](/docs/it/hooks) - Gestione degli eventi e automazione

1644* [MCP](/docs/it/mcp) - Integrazione di strumenti esterni

1645* [Impostazioni](/docs/it/settings) - Opzioni di configurazione per i plugin