plugin-dependencies.md +0 −267 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.
4
5# Vincola le versioni delle dipendenze dei plugin
6
7> Dichiara vincoli di versione sulle dipendenze dei plugin e raggruppa un set di plugin curato dietro un'unica installazione.
8
9Un plugin può dipendere da altri plugin elencandoli in `plugin.json` o nella sua voce del marketplace. Per impostazione predefinita, una dipendenza traccia la versione più recente disponibile, quindi un rilascio upstream può modificare la dipendenza del tuo plugin senza preavviso. I vincoli di versione consentono di mantenere una dipendenza a un intervallo di versione testato fino a quando non scegli di passare a una versione più recente.
10
11Quando installi un plugin che dichiara dipendenze, Claude Code le risolve e le installa automaticamente, ad eccezione di una dipendenza la cui voce del marketplace ha una [`command` source](/docs/it/plugin-marketplaces#how-users-accept-the-command) o una [`headersHelper`](/docs/it/plugin-marketplaces#how-users-accept-a-headershelper-command), che installi tu stesso per primo. Successivamente, `/reload-plugins`, l'aggiornamento automatico del marketplace del plugin dipendente, l'esecuzione nuova di `claude plugin install` sul plugin dipendente e `claude plugin marketplace add` installano ciascuno qualsiasi dipendenza dichiarata che non sia ancora installata, secondo le stesse regole; se una rimane non risolta, vedi [Risolvi gli errori di dipendenza](#resolve-dependency-errors).
12
13Questa guida è per gli autori di plugin che dichiarano dipendenze in `plugin.json` e per i manutentori del marketplace che taggano i rilasci. Le dipendenze qui sono altri plugin; per i pacchetti npm e Bun che un plugin stesso utilizza, vedi [Dipendenze dei pacchetti Node.js](/docs/it/plugins-reference#node-js-package-dependencies). Per installare plugin che hanno dipendenze, vedi [Scopri e installa plugin](/docs/it/discover-plugins). Per lo schema completo del manifest, vedi il [Riferimento dei plugin](/docs/it/plugins-reference).
14
15<h2 id="why-constrain-dependency-versions">
16 Perché vincolare le versioni delle dipendenze
17</h2>
18
19Considera un marketplace interno in cui due team pubblicano plugin. Il team della piattaforma mantiene `secrets-vault`, un server MCP che avvolge un backend di segreti. Il team di deploy mantiene `deploy-kit`, che chiama `secrets-vault` per recuperare le credenziali durante i deploy.
20
21`deploy-kit` è testato rispetto a `secrets-vault` v2.1.0. Senza un vincolo di versione, la prossima volta che il team della piattaforma tagga un rilascio che rinomina uno strumento MCP, l'aggiornamento automatico sposta `secrets-vault` di ogni ingegnere alla nuova versione e `deploy-kit` si rompe.
22
23Con un vincolo di versione, `deploy-kit` dichiara che ha bisogno di `secrets-vault` nell'intervallo `~2.1.0`. Gli ingegneri con `deploy-kit` installato rimangono sulla patch `2.1.x` più alta corrispondente. Il team di deploy esegue l'aggiornamento secondo il proprio programma pubblicando una nuova versione di `deploy-kit` con un vincolo più ampio.
24
25<h2 id="declare-a-dependency-with-a-version-constraint">
26 Dichiara una dipendenza con un vincolo di versione
27</h2>
28
29Elenca le dipendenze nell'array `dependencies` del file `.claude-plugin/plugin.json` del tuo plugin.
30
31Il seguente manifest dichiara una dipendenza senza versione e una dipendenza vincolata:
32
33```json .claude-plugin/plugin.json theme={null}
34{
35 "name": "deploy-kit",
36 "version": "3.1.0",
37 "dependencies": [
38 "audit-logger",
39 { "name": "secrets-vault", "version": "~2.1.0" }
40 ]
41}
42```
43
44Una voce può essere una stringa semplice con solo il nome del plugin, come `"audit-logger"` nel manifest `deploy-kit`, che dipende da qualsiasi versione fornita dal marketplace di quel plugin. Per un maggiore controllo, usa un oggetto con questi campi:
45
46| Campo | Tipo | Descrizione |
47| :------------ | :----- | :-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
48| `name` | string | Nome del plugin. Si risolve all'interno dello stesso marketplace del plugin dichiarante. Obbligatorio. |
49| `version` | string | Un [intervallo semver](https://github.com/npm/node-semver#ranges) come `~2.1.0`, `^2.0`, `>=1.4`, o `=2.1.0`. La dipendenza viene recuperata alla versione taggata più alta che soddisfa questo intervallo. |
50| `marketplace` | string | Un marketplace diverso in cui risolvere `name`. Le dipendenze cross-marketplace sono bloccate a meno che il marketplace di destinazione non sia elencato in [`allowCrossMarketplaceDependenciesOn`](#depend-on-a-plugin-from-another-marketplace) nel file `marketplace.json` del marketplace root. |
51
52Le versioni pre-release come `2.0.0-beta.1` sono escluse a meno che il tuo intervallo non opti per un suffisso pre-release come `^2.0.0-0`.
53
54<h2 id="bundle-plugins-for-a-team">
55 Raggruppare i plugin per un team
56</h2>
57
58Oltre al `name` obbligatorio, un manifest di plugin può consistere solo in un array `dependencies`. L'installazione di questo plugin scarica tutte le dipendenze, il che lo rende un modo per raggruppare un set di plugin curato dietro un'unica installazione.
59
60Ad esempio, un team di piattaforma può pubblicare bundle specifici per ruolo in un marketplace interno in modo che gli ingegneri eseguano un solo `claude plugin install` invece di installare ogni strumento separatamente:
61
62```json .claude-plugin/plugin.json theme={null}
63{
64 "name": "backend-standard",
65 "version": "1.0.0",
66 "description": "Standard plugin set for backend engineers",
67 "dependencies": [
68 "secrets-vault",
69 "deploy-kit",
70 { "name": "db-migrate", "version": "^3.0" },
71 "oncall-runbook"
72 ]
73}
74```
75
76L'installazione di `backend-standard` risolve e installa tutte e quattro le dipendenze.
77
78Per aggiungere uno strumento al set standard in seguito, pubblicare una nuova versione di `backend-standard` con la dipendenza aggiuntiva. A meno che il marketplace non [auto-aggiorni](/docs/it/discover-plugins#configure-auto-updates), gli ingegneri acquisiscono la nuova versione in uno di due modi:
79
80* Abilitare l'auto-aggiornamento per il marketplace in `/plugin`. Il prossimo auto-aggiornamento sposta il bundle alla nuova versione e installa tutte le dipendenze che aggiunge.
81* Eseguire `claude plugin update backend-standard`, quindi `/reload-plugins` per installare le dipendenze appena aggiunte.
82
83Per distribuire i bundle in tutta l'organizzazione, aggiungere il plugin bundle a `enabledPlugins` nelle [impostazioni gestite](/docs/it/settings-reference#enabledplugins).
84
85<h2 id="depend-on-a-plugin-from-another-marketplace">
86 Dipendi da un plugin di un altro marketplace
87</h2>
88
89Per impostazione predefinita, Claude Code rifiuta di installare automaticamente una dipendenza che si trova in un marketplace diverso da quello del plugin che la dichiara. Questo impedisce a un marketplace di estrarre silenziosamente plugin da una fonte che non hai revisionato.
90
91Per consentirlo, il manutentore del marketplace root aggiunge il nome del marketplace di destinazione a `allowCrossMarketplaceDependenciesOn` in `marketplace.json`. Il marketplace root è quello che ospita il plugin che l'utente sta installando; solo la sua lista di autorizzazione viene consultata, quindi la fiducia non si propaga attraverso i marketplace intermedi.
92
93Il seguente `marketplace.json` consente a `deploy-kit` di dipendere da un plugin di `acme-shared`:
94
95```json .claude-plugin/marketplace.json theme={null}
96{
97 "name": "acme-tools",
98 "owner": { "name": "Acme" },
99 "allowCrossMarketplaceDependenciesOn": ["acme-shared"],
100 "plugins": [
101 {
102 "name": "deploy-kit",
103 "source": "./deploy-kit",
104 "dependencies": [
105 { "name": "audit-logger", "marketplace": "acme-shared" }
106 ]
107 }
108 ]
109}
110```
111
112Se il campo è mancante o non include il marketplace di destinazione, l'installazione fallisce con un errore `cross-marketplace` che nomina il campo da impostare. Gli utenti possono comunque installare manualmente la dipendenza per prima, il che soddisfa il vincolo senza modificare la lista di autorizzazione.
113
114<h2 id="test-a-plugin-and-its-dependency-locally">
115 Testare un plugin e la sua dipendenza localmente
116</h2>
117
118Se state sviluppando un plugin e il plugin da cui dipende contemporaneamente, caricate entrambi con `--plugin-dir`:
119
120```bash theme={null}
121claude --plugin-dir ./my-dependency --plugin-dir ./my-plugin
122```
123
124La copia locale della dipendenza soddisfa la voce di dipendenza del vostro plugin, anche quando la voce nomina un marketplace, quindi non è necessario installare la dipendenza dal suo marketplace. Claude Code non controlla un [vincolo di versione](#declare-a-dependency-with-a-version-constraint) rispetto a una copia locale, quindi il `plugin.json` locale non ha bisogno di una `version`. Prima della v2.1.242, una voce di dipendenza che nominava un marketplace non corrispondeva mai alla copia locale, e Claude Code disabilitava il vostro plugin al caricamento.
125
126Quando entrambi i plugin si trovano in una cartella padre, potete passare quella cartella a `--plugin-dir` una sola volta. Se la cartella non è essa stessa un plugin, Claude Code carica ogni cartella figlio che ha un `.claude-plugin/plugin.json`. Richiede Claude Code v2.1.265 o successivo.
127
128Se non avete installato la dipendenza dal suo marketplace, il vostro plugin smette di caricarsi quando la copia locale scompare:
129
130* **Avete disabilitato la copia locale**: Claude Code disabilita il vostro plugin al prossimo caricamento del plugin. Per una voce di dipendenza che nomina un marketplace, Claude Code segnala `Dependency "<name>@inline" is disabled — enable it or remove the dependency`; per una voce con nome semplice, la segnala per il suo nome semplice. `<name>@inline` è il modo in cui Claude Code identifica ogni plugin `--plugin-dir` e `--plugin-url`.
131* **Avete avviato una sessione senza il flag `--plugin-dir` della dipendenza**: Claude Code segnala la dipendenza come non installata. Passate di nuovo il flag, oppure installate la dipendenza dal suo marketplace.
132
133<h2 id="tag-plugin-releases-for-version-resolution">
134 Rilasci di tag plugin per la risoluzione delle versioni
135</h2>
136
137Claude Code risolve i vincoli di versione rispetto ai tag git nel repository che ospita la dipendenza: il repository del plugin stesso per le [fonti plugin](/docs/it/plugin-marketplaces#plugin-sources) `github`, `url` e `git-subdir`, oppure il repository del marketplace per un plugin a cui il marketplace fa riferimento tramite un percorso relativo. Affinché Claude Code trovi le versioni disponibili di una dipendenza, i rilasci del plugin upstream devono essere taggati utilizzando una convenzione di denominazione specifica.
138
139Tagga ogni rilascio come `{plugin-name}--v{version}`, dove `{version}` corrisponde al campo `version` nel `plugin.json` di quel commit. Dalla directory del plugin, esegui:
140
141```bash theme={null}
142claude plugin tag --push
143```
144
145Il comando `claude plugin tag` deriva il nome del tag dal manifest del plugin e dalla voce del marketplace che lo contiene. Prima di creare il tag, convalida il contenuto del plugin, verifica che `plugin.json` e la voce del marketplace concordino sulla versione, richiede un albero di lavoro pulito nella directory del plugin e rifiuta se il tag esiste già.
146
147* `--push` spinge il tag al remote `origin`, quindi il repository ha bisogno di un remote `origin` configurato. Passa `--remote` per spingere a uno diverso.
148* Se lo spinta fallisce, il tag viene comunque creato localmente e il comando esce con un errore.
149* Con `--push`, un'esecuzione riuscita termina con `Created tag secrets-vault--v2.1.0` e `Pushed to origin`, dove l'ultima riga nomina il remote a cui è stato spinto. Senza `--push`, il comando stampa il comando `git push` da eseguire.
150* `--dry-run` stampa ciò che verrebbe taggato senza crearlo.
151
152Eseguire `git tag secrets-vault--v2.1.0` direttamente è equivalente se mantieni `plugin.json` e la voce del marketplace sincronizzati da solo.
153
154Il prefisso del nome del plugin consente a un repository del marketplace di ospitare più plugin con linee di versione indipendenti. Il separatore `--v` viene analizzato come una corrispondenza di prefisso sul nome completo del plugin, quindi i nomi dei plugin che contengono trattini vengono gestiti correttamente.
155
156Quando installi un plugin che dichiara `{ "name": "secrets-vault", "version": "~2.1.0" }`, Claude Code elenca i tag nel repository che ospita `secrets-vault`, filtra quelli che iniziano con `secrets-vault--v` e recupera la versione più alta che soddisfa `~2.1.0`. Se nessun tag nel repository del plugin stesso soddisfa l'intervallo, l'installazione fallisce con `Dependency "secrets-vault@acme-tools" has no git tag satisfying ~2.1.0`, che nomina la dipendenza insieme al suo marketplace. Per un plugin con percorso relativo senza tag corrispondente, Claude Code installa la copia corrente del marketplace e verifica il vincolo quando il plugin viene caricato.
157
158Per un plugin a cui il marketplace fa riferimento tramite un percorso relativo, un marketplace aggiunto come percorso di cartella locale risolve i tag nello stesso modo quando la cartella è un repository git. Ciò richiede Claude Code v2.1.196 o successivo. In due casi Claude Code installa la dipendenza dal contenuto corrente della cartella:
159
160* Le versioni precedenti non leggono i tag da un marketplace di cartella locale, quindi una dipendenza vincolata viene caricata solo se quella copia soddisfa l'intervallo.
161* Una cartella locale che non è un repository git non ha tag, indipendentemente dalla versione.
162
163Il semver del tag risolto viene registrato separatamente dalla `version` di `plugin.json`, quindi i controlli dei vincoli utilizzano il tag che è stato effettivamente recuperato anche se `plugin.json` in quel commit ha un valore obsoleto. Il nome della directory della cache per un'installazione risolta da tag include un suffisso SHA commit di 12 caratteri, quindi se un manutentore sposta forzatamente un tag a un commit diverso, l'installazione successiva ottiene una directory della cache nuova invece di riutilizzare contenuto obsoleto.
164
165<Note>
166 Per le dipendenze con una [fonte plugin](/docs/it/plugin-marketplaces#plugin-sources) `npm`, `archive` o `command`, il vincolo non controlla quale versione viene recuperata, poiché la risoluzione basata su tag si applica solo alle fonti supportate da git. Il vincolo viene comunque verificato al momento del caricamento e il plugin dipendente viene disabilitato con `dependency-version-unsatisfied` se la versione installata non lo soddisfa. Per una fonte `command`, Claude Code verifica la versione nel `plugin.json` della dipendenza e ignora il suffisso dell'hash del contenuto; una dipendenza il cui `plugin.json` non imposta alcuna versione non soddisfa alcun vincolo, quindi impostane uno prima di vincolarlo.
167
168 Claude Code non installa mai una dipendenza con una fonte `command` da solo, quindi gli utenti [la installano prima](/docs/it/plugin-marketplaces#how-users-accept-the-command). Claude Code non esegue mai nemmeno `headersHelper` su una voce del marketplace di una dipendenza, quindi gli utenti [installano prima quel plugin](/docs/it/plugin-marketplaces#how-users-accept-a-headershelper-command).
169</Note>
170
171<h2 id="how-constraints-interact">
172 Come i vincoli interagiscono
173</h2>
174
175Quando più plugin installati vincolano la stessa dipendenza, Claude Code interseca i loro intervalli e risolve la dipendenza alla versione più alta che soddisfa tutti loro. La tabella seguente mostra come si risolvono le combinazioni comuni.
176
177| Plugin A richiede | Plugin B richiede | Risultato |
178| :---------------- | :---------------- | :------------------------------------------------------------------------------------------------------------------------ |
179| `^2.0` | `>=2.1` | Un'installazione al tag `2.x` più alto a o sopra `2.1.0`. Entrambi i plugin si caricano. |
180| `~2.1` | `~3.0` | L'installazione del plugin B fallisce con `range-conflict`. Plugin A e la dipendenza rimangono come erano. |
181| `=2.1.0` | nessuno | La dipendenza rimane a `2.1.0`. L'aggiornamento automatico salta le versioni più recenti mentre il plugin A è installato. |
182
183L'aggiornamento automatico recupera una dipendenza vincolata al tag git più alto che soddisfa l'intervallo di ogni plugin installato, piuttosto che alla versione più recente del marketplace, quindi la dipendenza continua a ricevere aggiornamenti all'interno del suo intervallo consentito. Se nessun tag soddisfa tutti gli intervalli, l'aggiornamento automatico salta quella dipendenza e elenca il salto nella scheda Errori di `/plugin`, nominando il plugin vincolante.
184
185Quando disinstalli l'ultimo plugin che vincola una dipendenza, la dipendenza non viene più mantenuta e riprende a tracciare la sua voce del marketplace al prossimo aggiornamento.
186
187<h2 id="enable-or-disable-a-plugin-with-dependencies">
188 Abilita o disabilita un plugin con dipendenze
189</h2>
190
191Questa sezione copre i plugin installati da un marketplace. Per una copia che hai caricato con `--plugin-dir`, vedi [Testa un plugin e la sua dipendenza localmente](#test-a-plugin-and-its-dependency-locally).
192
193L'abilitazione di un plugin abilita anche i plugin da cui dipende, e la disabilitazione di un plugin è bloccata se un altro plugin abilitato ne ha ancora bisogno.
194
195Quando abiliti un plugin, Claude Code abilita anche le sue dipendenze nello stesso ambito. Se una dipendenza ha le sue dipendenze, Claude Code abilita anche quelle. Il messaggio di successo elenca cos'altro è stato abilitato insieme al plugin che hai denominato. Se una dipendenza non può essere abilitata, il comando rifiuta e ti dice cosa sta bloccando e come risolvere:
196
197| Condizione | Risultato |
198| :---------------------------------------------------------------------------------------------------- | :------------------------------------------------------------------------------------------------------------------------------- |
199| Una dipendenza non è installata | L'abilitazione fallisce e stampa il comando `claude plugin install` per ogni dipendenza mancante. |
200| Una dipendenza è bloccata dalla politica dei plugin della tua organizzazione | L'abilitazione fallisce e nomina la dipendenza bloccata. |
201| Una dipendenza è impostata su `false` a un ambito con precedenza più alta dell'ambito di destinazione | L'abilitazione fallisce. Abilita la dipendenza a quell'ambito, o passa `--scope` per scrivere lì. |
202| Tutte le dipendenze sono installate e consentite | L'abilitazione ha successo e scrive `true` per il plugin e ogni dipendenza che non era già abilitata all'ambito di destinazione. |
203
204Questo vale anche quando una dipendenza imposta [`defaultEnabled: false`](/docs/it/plugins-reference#default-enablement) nel suo manifest, perché Claude Code scrive un `true` esplicito per essa. Lo stesso vale all'installazione: una dipendenza richiamata per soddisfare un plugin attivo si installa con `true` indipendentemente dal suo valore predefinito.
205
206Quando disabiliti un plugin, Claude Code rifiuta se un altro plugin abilitato ne dipende ancora. L'errore nomina i plugin che ne dipendono e ti fornisce un comando concatenato che li disabilita nell'ordine corretto, terminando con quello che hai richiesto.
207
208Ad esempio, se `deploy-kit` dipende da `secrets-vault`, la disabilitazione di `secrets-vault` da sola fallisce con un output simile al seguente:
209
210```text theme={null}
211secrets-vault is still required by deploy-kit. Disable that plugin first, or
212disable everything together: claude plugin disable deploy-kit@acme-tools && claude plugin disable secrets-vault@acme-tools
213```
214
215Copia il comando concatenato dall'errore per disabilitare l'intero set in un unico passaggio.
216
217<h2 id="remove-orphaned-auto-installed-dependencies">
218 Rimuovi le dipendenze auto-installate orfane
219</h2>
220
221Le dipendenze auto-installate rimangono su disco dopo che i plugin che le hanno installate vengono disinstallati, nel caso in cui tu voglia reinstallare un plugin dipendente o desideri continuare a utilizzare la dipendenza direttamente. Per pulirle, esegui `claude plugin prune` per elencare le dipendenze auto-installate che non hanno più alcun plugin installato che le richiede e rimuoverle dopo un prompt di conferma.
222
223```bash theme={null}
224claude plugin prune
225```
226
227Se nulla si qualifica per la rimozione, il comando stampa `Nothing to prune` con il motivo ed esce. Questo è l'output previsto su un'installazione nuova, non un errore.
228
229Per impostazione predefinita, prune opera a livello di utente e chiede conferma prima di rimuovere qualsiasi cosa:
230
231* `--scope project` o `--scope local` indirizza un ambito diverso.
232* `--dry-run` elenca cosa verrebbe rimosso senza modificare nulla.
233* `-y` salta il prompt di conferma. Quando stdin o stdout non è un terminale, prune elenca gli orfani ed esce senza rimuoverli a meno che non venga passato `-y`.
234
235Per eseguire prune come parte di una disinstallazione, passa `--prune` a `claude plugin uninstall`. Dopo aver rimosso il plugin denominato, Claude Code scansiona e rimuove eventuali dipendenze auto-installate che sono ora orfane. I plugin che hai installato tu stesso non vengono mai eliminati, solo quelli installati automaticamente attraverso l'array `dependencies` di un altro plugin.
236
237Lo stesso comportamento di conferma si applica. Quando stdin o stdout non è un terminale, la disinstallazione si completa comunque, ma il passaggio prune elenca gli orfani e non rimuove nulla a meno che non venga passato `-y`.
238
239Ad esempio, per disinstallare `deploy-kit` e pulire le dipendenze che lascia dietro:
240
241```bash theme={null}
242claude plugin uninstall deploy-kit --prune
243```
244
245<h2 id="resolve-dependency-errors">
246 Risolvi gli errori delle dipendenze
247</h2>
248
249I problemi di dipendenza emergono in `claude plugin list` e nell'interfaccia `/plugin`, come messaggi di errore descrittivi anziché i codici letterali in questa tabella. Claude Code disabilita il plugin interessato fino a quando non risolvi l'errore. La tabella seguente elenca gli errori più comuni e come risolverli.
250
251| Errore | Significato | Come risolvere |
252| :------------------------------- | :-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
253| `dependency-unsatisfied` | Una dipendenza dichiarata non è installata, oppure è installata ma disabilitata. | Esegui il comando `claude plugin install` mostrato nel messaggio di errore. Se il marketplace della dipendenza non è ancora configurato, aggiungilo con `claude plugin marketplace add` e Claude Code risolve la dipendenza automaticamente. Se la dipendenza è disabilitata, abilitala. |
254| `range-conflict` | I requisiti di versione per una dipendenza non possono essere combinati. Il messaggio di errore nomina la causa: nessuna versione soddisfa tutti gli intervalli, un intervallo non è una sintassi semver valida, o gli intervalli combinati sono troppo complessi da intersecare. | Disinstalla o aggiorna uno dei plugin in conflitto, correggi qualsiasi stringa `version` non valida, semplifica le catene `\|\|` lunghe, o chiedi all'autore upstream di ampliare il suo vincolo. |
255| `dependency-version-unsatisfied` | La versione della dipendenza installata è al di fuori dell'intervallo dichiarato di questo plugin. | Esegui `claude plugin install <dependency>@<marketplace>` per ri-risolvere la dipendenza rispetto a tutti i vincoli attuali. |
256| `no-matching-tag` | Il repository della dipendenza non ha un tag `{name}--v*` che soddisfa l'intervallo. | Verifica che l'upstream abbia taggato i rilasci usando la convenzione sopra, o rilassa il tuo intervallo. |
257
258Per controllare questi errori a livello di programmazione, esegui `claude plugin list --json`. I plugin con problemi includono un campo `errors` che li elenca. I plugin che si sono caricati correttamente omettono il campo.
259
260<h2 id="see-also">
261 Vedi anche
262</h2>
263
264* [Crea plugin](/docs/it/plugins): costruisci plugin con skills, agent e hooks
265* [Crea e distribuisci un marketplace di plugin](/docs/it/plugin-marketplaces): ospita plugin per il tuo team
266* [Riferimento dei plugin](/docs/it/plugins-reference#plugin-manifest-schema): lo schema completo di `plugin.json`
267* [Gestione delle versioni](/docs/it/plugins-reference#version-management): come la versione di un plugin viene risolta e utilizzata come chiave di cache