> ## Documentation Index
> Fetch the complete documentation index at: https://code.claude.com/docs/llms.txt
> Use this file to discover all available pages before exploring further.

# Reagire agli eventi con un mod

> Gestire gli eventi di Claude Code da un mod: osservare, riscrivere o rispondere alle chiamate di strumenti, ai prompt e ai turni, filtrare quali eventi un hook gestisce e pianificare per altri mod.

Un hook è un gestore di eventi: una funzione che Claude Code esegue quando si verifica un evento denominato. Claude Code genera un evento in ogni punto in cui sta per agire, ad esempio quando esegue uno strumento, invia un prompt, invia una richiesta al modello o avvia o termina una sessione. Il vostro hook viene eseguito prima che Claude Code agisca, quindi può osservare l'evento, riscriverlo o rispondere al suo posto. Registrate un hook con [`on(eventName, handler)`](/docs/it/plugins/mods/reference#the-hook-function).

Costruite il vostro [primo mod](/docs/it/plugins/mods/create) prima di iniziare qui. Per ogni evento e i suoi campi esatti, consultate il [riferimento](/docs/it/plugins/mods/reference#events) o leggete [i tipi per la vostra build](/docs/it/plugins/mods/create#get-the-types-for-your-build).

<h2 id="how-a-hook-handles-an-event">
  Come un hook gestisce un evento
</h2>

Un hook si trova tra un evento e ciò che Claude Code farebbe al riguardo, quindi può osservare l'evento, riscriverlo o rispondere da solo. Riceve tre argomenti: l'[API dei mods](/docs/it/plugins/mods/api) come `$`, l'evento come `e` e il gestore successivo come `next`. I gestori di un evento formano una catena middleware. `next(e)` chiama il gestore successivo, che è un hook di un altro mod o, alla fine della catena, il comportamento proprio di Claude Code, e si risolve nel risultato. Ciò che il vostro hook fa con `next` decide quale dei tre fa.

<h3 id="observe-an-event">
  Osservare un evento
</h3>

Per osservare un evento senza modificarlo, fate il vostro lavoro e restituite `next(e)`. Questo hook registra ogni strumento che Claude sta per utilizzare:

```javascript theme={null}
on('tool.call', async ($, e, next) => {
  // Viene eseguito prima che lo strumento venga eseguito
  $.ui.log('Claude is about to use ' + e.tool)
  // Passa l'evento invariato
  return next(e)
})
```

Prima di ogni esecuzione dello strumento, una riga attenuata come `● my-mod: Claude is about to use Bash` appare nella trascrizione, dove `my-mod` è il nome del vostro plugin. Lo strumento viene eseguito come farebbe senza il mod.

Per agire dopo l'evento, `await next(e)`, fate il vostro lavoro e restituite il risultato. Questo hook registra ogni strumento dopo che è stato eseguito:

```javascript theme={null}
on('tool.call', async ($, e, next) => {
  // Lascia che lo strumento venga eseguito e attendi il suo risultato
  const result = await next(e)
  // Viene eseguito dopo che lo strumento è stato eseguito
  $.ui.log(e.tool + ' finished')
  // Restituisci il risultato invariato
  return result
})
```

La riga ora appare dopo che ogni strumento termina. Claude legge lo stesso risultato in entrambi i casi, perché l'hook restituisce ciò a cui `next(e)` si è risolto.

<h3 id="rewrite-an-event">
  Riscrivere un evento
</h3>

Per modificare ciò su cui Claude Code agisce, ad esempio il testo di un prompt, chiamate `next` con una copia modificata dell'evento. L'evento stesso è immutabile: è congelato a ogni profondità e l'assegnazione a un campo genera un errore. Questo hook taglia ogni prompt prima che venga inviato:

```javascript theme={null}
on('prompt.submit', async ($, e, next) => {
  // Passa una copia dell'evento con il suo testo modificato
  return next({ ...e, text: e.text.trim() })
})
```

I gestori successivi e Claude Code ricevono il prompt tagliato e non vedono mai l'originale. Potete anche modificare il risultato: `await next(e)`, quindi restituite una copia del risultato con un campo sostituito.

<h3 id="answer-an-event">
  Rispondere a un evento
</h3>

Per gestire un evento da soli, restituite un risultato senza chiamare `next`. Questo cortocircuita la catena, quindi i mod successivi e il comportamento proprio di Claude Code non vengono eseguiti. Questo hook rifiuta ogni comando Bash:

```javascript theme={null}
on('tool.call', { tool: 'Bash' }, async () => {
  // Nessuna chiamata a next, quindi il comando non viene mai eseguito
  return { deny: 'Bash is turned off in this project. Use the file tools.' }
})
```

Quando Claude prova un comando Bash, il comando non viene eseguito e Claude legge il testo `deny` come risultato dello strumento. Ogni evento ha la sua forma di risultato, che il [riferimento degli eventi](/docs/it/plugins/mods/reference#events) elenca.

<h3 id="filter-which-events-a-hook-handles">
  Filtrare quali eventi un hook gestisce
</h3>

Per eseguire un hook solo per alcuni eventi, passate un filtro come secondo argomento a `on`. Claude Code chiama il filtro un matcher. È un oggetto i cui campi vengono confrontati con quelli dell'evento e l'hook viene eseguito solo quando ogni campo corrisponde. Un campo può essere un valore, un array di valori consentiti o un'espressione regolare.

Ogni riga in questo esempio registra la stessa funzione, `hook`, per un insieme più ristretto di chiamate di strumenti:

```javascript theme={null}
// Una stringa corrisponde a un valore: solo chiamate Bash
on('tool.call', { tool: 'Bash' }, hook)
// Un array corrisponde a qualsiasi valore in esso: chiamate Edit e Write
on('tool.call', { tool: ['Edit', 'Write'] }, hook)
// Un'espressione regolare corrisponde per pattern: ogni strumento di un server MCP
on('tool.call', { tool: /^mcp__github__/ }, hook)
```

`hook` viene eseguito una volta per una chiamata Bash, Edit o Write e una volta per una chiamata a uno strumento il cui nome inizia con `mcp__github__`. Una chiamata a qualsiasi altro strumento, come Read, non corrisponde a nessuno dei tre, quindi `hook` non viene eseguito per essa.

Il nome dell'evento può essere un wildcard. `'classic.*'` corrisponde a ogni [evento hook delle impostazioni](#hook-the-settings-hook-events). `'*'` corrisponde a ogni evento tranne gli [eventi di telemetria](/docs/it/plugins/mods/reference#telemetry), che potete agganciare per nome o come `'telemetry.*'`.

Registrate ogni evento una volta per matcher. Se chiamate `on` due volte per `session.start` senza un matcher, il modulo non si carica con `on("session.start") is registered twice without a matcher`. Mettete tutto ciò che il vostro mod fa all'inizio della sessione in un hook.

<h2 id="hook-what-claude-is-doing">
  Agganciare ciò che Claude sta facendo
</h2>

Agganciate questi eventi per vedere o modificare una chiamata di strumento, un prompt o un turno mentre accade. Per ogni evento e ciò che un hook può restituire, consultate il [riferimento degli eventi](/docs/it/plugins/mods/reference#events).

<h3 id="guard-or-change-a-tool-call">
  Proteggere o modificare una chiamata di strumento
</h3>

Un hook `tool.call` vede ogni strumento che Claude sta per utilizzare, quindi può rifiutare la chiamata, modificare i suoi argomenti o lasciarla passare. `tool.call` si attiva quando Claude Code sta per eseguire uno strumento, incluse le chiamate che un subagent effettua e le chiamate agli strumenti MCP. `e.tool` è il nome dello strumento e gli argomenti dello strumento sono campi di `e`, come `e.command` per Bash. Quando chiamate `next(e)`, Claude Code esegue il controllo delle autorizzazioni e quindi lo strumento.

Questo hook rifiuta un comando Bash che fa un force-push e dice a Claude perché:

```javascript theme={null}
// Il matcher limita l'hook alle chiamate Bash, quindi e.command è il comando della shell
on('tool.call', { tool: 'Bash' }, async ($, e, next) => {
  if (/git push .*--force/.test(e.command)) {
    // Restituire senza chiamare next risponde all'evento, quindi il comando non viene mai eseguito
    return { deny: 'Force pushes are not allowed in this repository. Push to a new branch instead.' }
  }
  // Ogni altro comando va al controllo delle autorizzazioni e poi a Bash
  return next(e)
})
```

Quando Claude prova `git push --force`, il comando non viene eseguito e non appare alcun prompt di autorizzazione, perché l'hook non chiama mai `next`. Claude legge il testo `deny` come risultato dello strumento, quindi scrivilo come un'istruzione su cui Claude può agire. Ogni altro comando Bash viene eseguito come farebbe senza il mod.

Per agire dopo che uno strumento è stato eseguito, `await next(e)`, fate il vostro lavoro e restituite ciò che `next` vi ha dato. Questo hook registra ogni file `.mdx` che Claude modifica, con [`$.ui.log`](/docs/it/plugins/mods/api#show-something-without-starting-a-turn), che aggiunge una riga attenuata alla trascrizione che Claude non legge:

```javascript theme={null}
on('tool.call', { tool: ['Edit', 'Write'] }, async ($, e, next) => {
  // Attendi il controllo delle autorizzazioni e lo strumento, e mantieni ciò che hanno prodotto
  const result = await next(e)
  // Una chiamata rifiutata torna come { deny }, e una fallita ha isError impostato
  const changed = !result.deny && !result.isError
  if (changed && e.file_path.endsWith('.mdx')) $.ui.log('Claude changed ' + e.file_path)
  // Restituisci il risultato come è arrivato, quindi Claude legge ciò che lo strumento ha restituito
  return result
})
```

Dopo che Claude modifica o scrive un file `.mdx`, una riga attenuata nella trascrizione nomina il file. Nulla viene registrato per un altro tipo di file o per una chiamata che è stata rifiutata o non è riuscita. La vista di Claude della chiamata non cambia, perché l'hook restituisce il risultato che ha ricevuto.

Per modificare una chiamata, passate argomenti modificati a `next`. Per riprovare una chiamata, chiamate `next(e)` di nuovo: un hook che vede `isError` sul primo risultato può eseguire lo strumento una seconda volta e restituire quel risultato. Per rispondere a una chiamata da soli, restituite un oggetto con un campo `result`, come `{ result: 'Skipped by my-mod' }`, senza chiamare `next`. Quando lo fate, non appare alcun prompt di autorizzazione e lo strumento non viene eseguito, quindi il risultato che restituite è tutto ciò che Claude apprende su ciò che è accaduto.

Gli hook nelle [impostazioni gestite](/docs/it/server-managed-settings) della vostra organizzazione vengono eseguiti prima di qualsiasi hook `tool.call` di un mod, e un blocco da uno di essi è definitivo.

<h4 id="hold-a-tool-call-until-the-user-decides">
  Tenere una chiamata di strumento in sospeso fino a quando l'utente decide
</h4>

Un hook può mettere in pausa una chiamata di strumento e chiedere all'utente cosa fare prima che proceda. Un hook `tool.call` può `await` prima di chiamare `next` o restituire, e la chiamata dello strumento rimane in sospeso fino ad allora. Per porre la domanda all'utente, chiamate `$.ui.ask`. Mostra la vostra domanda sopra un elenco numerato delle vostre opzioni, nella finestra di dialogo che Claude usa per chiedervi qualcosa, e si risolve nell'etichetta che l'utente sceglie. Dopo le vostre opzioni, la finestra di dialogo aggiunge una riga per digitare una risposta diversa e una riga **Chat about this**.

Il pattern `RISKY` in questo esempio corrisponde a `rm -r`, `rm -rf`, `git reset --hard` e `git push` con `--force`, e manca altre ortografie come `git push -f`. Questo modulo chiede prima di eseguire un comando Bash che corrisponde al pattern:

```javascript theme={null}
const RISKY = /\brm\s+-rf?\b|\bgit\s+reset\s+--hard\b|\bgit\s+push\b.*--force/

export function register(on) {
  on('tool.call', { tool: 'Bash' }, async ($, e, next) => {
    // Lascia passare ogni altro comando senza una domanda
    if (!RISKY.test(e.command)) return next(e)
    // Inizia dalla risposta sicura, quindi una domanda a cui nessuno risponde rifiuta il comando
    let answer = 'Refuse'
    try {
      // La chiamata dello strumento attende qui fino a quando l'utente sceglie una delle due etichette
      answer = await $.ui.ask('Run this command? ' + e.command, ['Run it', 'Refuse'])
    } catch {
      // L'utente ha chiuso la domanda, o questo è un'esecuzione claude -p senza nessuno a cui chiedere
    }
    if (answer !== 'Run it') {
      // Rispondi senza chiamare next, quindi il comando non viene eseguito
      return { deny: 'The user declined this command. Ask before trying a different approach.' }
    }
    return next(e)
  })
}
```

Quando Claude prova un comando come `rm -rf build`, la domanda appare con il comando in essa, e il comando attende la risposta:

* **L'utente sceglie Run it**: l'hook chiama `next(e)` e il solito controllo delle autorizzazioni viene comunque eseguito dopo
* **L'utente sceglie Refuse**: il comando non viene eseguito e Claude legge il testo `deny`
* **L'utente digita una risposta**: `$.ui.ask` si risolve nel testo digitato. L'hook lo confronta con `Run it`, quindi qualsiasi altro testo rifiuta il comando.
* **Nessuno risponde**: `$.ui.ask` rifiuta quando l'utente chiude la domanda o sceglie **Chat about this**, e in un'esecuzione `claude -p`, quindi il blocco `catch` lascia la risposta a `Refuse`

Mantenete l'attesa all'interno di una chiamata API dei mods come `$.ui.ask`, perché quel tempo non conta rispetto al [limite di tempo di 10 secondi](/docs/it/plugins/mods/reference#limits) dell'hook. Il tempo trascorso in attesa di una promessa propria conta. Claude Code salta un hook che scade, quindi il comando tenuto in sospeso verrebbe eseguito.

<h3 id="rewrite-or-add-to-a-prompt">
  Riscrivere o aggiungere a un prompt
</h3>

Un hook `prompt.submit` vede ogni prompt prima che il turno inizi, quindi può riscrivere il testo o aggiungervi. `e.text` è ciò che è stato digitato.

| Per fare questo | Restituite questo |
| :- | :- |
| Riscrivere il prompt. Il messaggio nella trascrizione mostra il nuovo testo. | `next({ ...e, text: newText })` |
| Aggiungere testo che solo Claude legge, dopo il prompt | `next({ ...e, context: [...(e.context ?? []), extraText] })` |
| Impedire che il prompt venga inviato | `{ drop: 'the reason' }` |

Questo hook aggiunge il nome del ramo corrente per Claude ogni volta che un prompt menziona una pull request:

```javascript theme={null}
on('prompt.submit', async ($, e, next) => {
  // Passa un prompt che non menziona una pull request così com'è
  if (!/\bPR\b|pull request/i.test(e.text)) return next(e)
  const git = await $.process.run(['git', 'branch', '--show-current'])
  // Al di fuori di un repository git il comando fallisce, quindi non c'è ramo da aggiungere
  if (git.exitCode !== 0) return next(e)
  // Mantieni qualsiasi contesto che un hook precedente ha aggiunto e aggiungi un'altra riga per Claude
  return next({ ...e, context: [...(e.context ?? []), 'Current branch: ' + git.stdout.trim()] })
})
```

Quando inviate un prompt come `open a PR for this change`, il vostro messaggio appare uguale nella trascrizione e Claude legge anche una riga come `Current branch: feature/auth` dopo di esso. Un prompt che non menziona una pull request passa invariato e `git` non viene eseguito.

[Altri eventi](/docs/it/plugins/mods/reference#prompts-and-what-claude-reads) coprono il resto di ciò che Claude legge: `prompt.section` per ogni sezione del prompt di sistema, `prompt.context` per il contesto inviato con il primo messaggio e `skill.prompt` per il testo di una skill. Il testo da questi hook che cambia tra le richieste [invalida la cache del prompt](/docs/it/prompt-caching).

<h3 id="follow-a-turn">
  Seguire un turno
</h3>

Un turno è tutto ciò che Claude fa in risposta a un prompt. Agganciate `turn.start`, `turn.step` e `turn.complete` per seguirne uno:

| Evento | Quando si attiva | Cosa può fare un hook |
| :- | :- | :- |
| `turn.start` | Un turno inizia | Osservare. `e.turnId` identifica il turno negli altri due eventi. |
| `turn.step` | Claude Code sta per inviare una richiesta al modello. Un turno con chiamate di strumenti ne ha diverse. `e.agentId` è impostato per una richiesta di un subagent. | Leggere l'utilizzo dei token di ogni richiesta, inviarlo a un modello diverso con `next({ ...e, model })` o rispondere senza chiamare il modello |
| `turn.complete` | Il turno è terminato, incluso un turno che l'utente ha interrotto, dove `e.isAborted` è `true`. `e.answer` è il testo finale di Claude, `e.durationMs` quanto tempo ha impiegato e `e.usage` i totali dei token del turno. Un turno di un subagent lo attiva con `e.agentId` impostato. | Osservare, o restituire un oggetto con un campo `text`, come `{ text: 'Done in 12 seconds' }`, per mostrare una riga sotto la risposta |

Scrivete un hook `turn.step` come generatore asincrono, perché l'evento trasmette. `yield* next(e)` inoltra la risposta mentre trasmette e si valuta nel risultato finito. Questo hook registra quanto di ogni richiesta il Claude API ha servito dalla [cache del prompt](/docs/it/prompt-caching):

```javascript theme={null}
// function* rende l'hook un generatore, che può passare la risposta pezzo per pezzo
on('turn.step', async function* ($, e, next) {
  // Invia la richiesta, inoltra ogni pezzo mentre arriva e mantieni il risultato finito
  const result = yield* next(e)
  // Salta un risultato che non riporta conteggi di token
  if (result.usage) {
    $.ui.log('cache read ' + result.usage.cache_read_input_tokens + ' · wrote ' + result.usage.cache_creation_input_tokens)
  }
  // Restituisci il risultato invariato, quindi il turno continua come al solito
  return result
})
```

La risposta di Claude trasmette allo schermo come farebbe senza il mod. Dopo che ogni richiesta termina, una riga attenuata nella trascrizione fornisce il numero di token letti dalla cache e il numero scritto in essa. Un turno con chiamate di strumenti ha diverse richieste, quindi aggiunge diverse righe.

`result.usage` contiene i quattro conteggi di token che il Claude API riporta per una richiesta, più il `model` che ha risposto: `input_tokens`, `output_tokens`, `cache_read_input_tokens` e `cache_creation_input_tokens`. L'hook viene eseguito anche per le richieste dei subagent, quindi controllate `e.agentId` quando volete solo la conversazione principale.

<h3 id="hook-the-settings-hook-events">
  Agganciare gli eventi hook delle impostazioni
</h3>

Gli hook delle impostazioni sono gli hook di comando, HTTP, prompt e agente che configurate nei file delle impostazioni. Ogni [evento hook delle impostazioni](/docs/it/hooks#hook-events), come `Stop`, `SessionEnd` o `PostToolUse`, è anche un evento denominato `classic.` seguito dal nome dell'evento hook delle impostazioni, come `classic.Stop`. `e` è il JSON che un hook delle impostazioni riceve su stdin, incluso `transcript_path`.

Questo hook usa `Stop`, che si attiva quando Claude finisce di rispondere, per registrare dove viene salvata la trascrizione della sessione:

```javascript theme={null}
on('classic.Stop', async ($, e, next) => {
  // e ha gli stessi campi che un hook Stop in un file di impostazioni legge da stdin
  $.ui.log('Transcript saved at ' + e.transcript_path)
  // Passa l'evento, quindi gli hook Stop nei vostri file di impostazioni vengono comunque eseguiti
  return next(e)
})
```

Ogni volta che Claude finisce di rispondere, una riga attenuata nella trascrizione fornisce il percorso del file di trascrizione. L'hook restituisce `next(e)`, quindi osserva l'evento e non cambia nulla su come il turno termina.

<h2 id="run-alongside-other-mods">
  Eseguire insieme ad altri mod
</h2>

Diversi mod possono agganciare lo stesso evento e uno qualsiasi di essi può fallire. Se il vostro mod blocca le chiamate di strumenti, controllate la sua posizione nella catena e cosa accade quando il suo hook fallisce.

<h3 id="the-order-mods-run-in">
  L'ordine in cui i mod vengono eseguiti
</h3>

Gli hook sullo stesso evento formano una catena middleware. Ogni `next` di un mod chiama l'hook del mod seguente e l'ultimo `next` raggiunge il comportamento proprio di Claude Code. Il primo mod è il più esterno: vede l'evento prima degli altri e il risultato dopo di loro, e decide se gli altri vengono eseguiti. Un mod successivo non può impedire a uno precedente di vedere un evento.

Claude Code ordina la catena in base a dove proviene ogni mod:

1. La guardia incorporata `sec-default@builtin`, un mod incorporato in Claude Code che `/plugin` elenca come `cc-plugin-sec-default`, dove [si carica](/docs/it/plugins/mods/admin#know-what-happens-by-default), i mod che la vostra organizzazione elenca in [`prependPlugins`](/docs/it/plugins/mods/admin#install-your-organizations-mods) e quindi qualsiasi altro mod che conta come della vostra organizzazione e non è in `appendPlugins`
2. I mod che installate
3. I mod che la vostra organizzazione elenca in `appendPlugins`
4. Altri mod incorporati in Claude Code

Tra i mod che installate, un mod viene eseguito prima dei mod che elenca sotto `dependencies` nel suo manifesto. All'interno di un modulo, gli hook vengono eseguiti nell'ordine in cui `register` ha chiamato `on`.

<h4 id="where-settings-hooks-run-in-the-order">
  Dove gli hook delle impostazioni vengono eseguiti nell'ordine
</h4>

Gli hook `PreToolUse` configurati nei file delle impostazioni vengono anche eseguiti durante una chiamata di strumento, in punti fissi nella catena dei mod:

* **Hook `PreToolUse` dalle impostazioni gestite**: vengono eseguiti prima dell'hook `tool.call` del primo mod, e un blocco da uno di essi è definitivo, quindi nessun mod vede la chiamata.
* **Hook `PreToolUse` da ogni altro file di impostazioni e da `hooks/hooks.json` dei plugin**: vengono eseguiti dopo che l'ultimo mod chiama `next`, come parte del comportamento proprio di Claude Code. Un mod che risponde a `tool.call` senza chiamare `next` li impedisce di eseguire e un mod che chiama `next` vede la loro decisione nel risultato che restituisce.

[`tool.check`](/docs/it/plugins/mods/reference#tools) è l'evento in cui Claude Code decide se una chiamata di strumento può essere eseguita. Si attiva dopo quegli hook e le regole di autorizzazione hanno deciso e `next(e)` si risolve nella loro decisione. Un hook su `tool.check` può restituire una decisione diversa, come `{ decision: 'allow' }`, quindi può approvare una chiamata che un hook nel secondo gruppo ha bloccato. [Estendere le autorizzazioni con gli hook](/docs/it/permissions#extend-permissions-with-hooks) elenca quali decisioni prevalgono su un mod.

<h3 id="handle-a-hook-that-fails">
  Gestire un hook che fallisce
</h3>

Un hook che fallisce non interrompe la sessione e potete decidere cosa accade invece. Quando un hook senza un gestore `.catch` genera un errore, scade o restituisce un risultato di forma sbagliata, ciò che accade dopo dipende dal fatto che abbia chiamato `next`:

* **Ha fallito prima di chiamare `next`**: Claude Code lo salta e il gestore successivo viene eseguito al suo posto
* **Ha fallito dopo che `next` si è risolto**: quel risultato rimane e nulla viene eseguito una seconda volta

Una riga nomina il mod, l'evento e il motivo, come `my-mod: tool.call hook skipped: threw Error: boom`. Dove lo leggete dipende dalla sessione, come [Scoprire perché un mod non fa nulla](/docs/it/plugins/mods/troubleshoot#find-out-why-a-mod-does-nothing) elenca. Un hook `ui.render` il cui disegno non convalida viene segnalato diversamente, come [Costruire un albero da elementi](/docs/it/plugins/mods/interface#build-a-tree-from-elements) descrive.

Per fare in modo che un hook che blocca le chiamate fallisca in modo sicuro, aggiungete un gestore di errore `.catch` che risponda al suo posto. Qui, `guard` è la vostra funzione hook:

```javascript theme={null}
// on restituisce una registrazione e .catch allega un gestore a quel singolo hook
on('tool.call', { tool: 'Bash' }, guard).catch(async ($, e, next) => {
  // next.error.kind è 'throw' o 'timeout', che dice come guard ha fallito
  return { deny: 'The command guard failed, so this command was not run: ' + next.error.kind }
})
```

Mentre `guard` funziona, il gestore non viene mai eseguito. Quando `guard` genera un errore o scade su una chiamata Bash, Claude Code chiama il gestore con lo stesso evento. Il gestore restituisce `{ deny }`, quindi il comando non viene eseguito e Claude legge il testo con `throw` o `timeout` alla fine. Senza il gestore, Claude Code salterebbe `guard` ed eseguirebbe il comando. Il gestore ha [un secondo](/docs/it/plugins/mods/reference#limits) per rispondere.

<h2 id="next-steps">
  Passaggi successivi
</h2>

* [Usare l'API dei mods](/docs/it/plugins/mods/api): aggiungere comandi e strumenti, chiamare un modello ed eseguire lavoro su un timer
* [Disegnare nell'interfaccia](/docs/it/plugins/mods/interface): mostrare ciò che i vostri hook raccolgono in un riquadro o sopra il prompt
* [Testare un mod](/docs/it/plugins/mods/test): generare uno qualsiasi di questi eventi da un test
* [Riferimento dei mods](/docs/it/plugins/mods/reference): ogni evento, ogni metodo dell'API dei mods e i limiti