Hoe werken Claude Code hooks?

Wat een Claude Code hook is

Claude Code hooks zijn shell-commando's die Claude Code zelfstandig uitvoert op vaste punten in zijn eigen levenscyclus. Dat is het fundamentele verschil tussen een hook en een rules-bestand. Een instructie in CLAUDE.md is advies, en het model weegt dit af tegen alle andere informatie in de context. Een hook is code, en deze wordt uitgevoerd, ongeacht of het model het ermee eens is of niet. Als uw agent de formatter die u twee keer heeft opgegeven blijft overslaan, heeft u geen strengere instructie nodig. U heeft een hook nodig.

Het mechanisme is eenvoudig. U registreert een commando in een instellingenbestand onder een eventnaam. Wanneer dat event wordt geactiveerd, voert Claude Code uw commando uit en schrijft de eventdata naar de standaardinvoer (stdin) als JSON (JavaScript object notation). Uw commando leest die data, voert de taak uit en antwoordt met een exit-status. Exit 2 van een PreToolUse hook annuleert de tool-aanroep voordat deze wordt uitgevoerd, en alles wat uw script naar de standaardfoutuitvoer (stderr) heeft geschreven, wordt aan het model teruggegeven als reden.

Eventnamen en veldnamen in deze tekst zijn afkomstig uit de Claude Code hooks reference, gecontroleerd in augustus 2026 tegen release 2.1.232. Dit oppervlak verandert snel, dus controleer de referentie voor uw eigen versie voordat u JSON kopieert uit een blogpost, inclusief deze. Print de uwe met claude --version.

Locatie van hook-configuratie

Een hook is een JSON-blok in een instellingenbestand. Er zijn zes locaties waar deze kan staan, waarbij de scope van het bestand gelijk is aan de scope van de hook.

• ~/.claude/settings.json: elk project op uw machine, en van niemand anders.
• .claude/settings.json: één project, gecommit naar de repository, zodat iedereen die het project kloont de hook ontvangt.
• .claude/settings.local.json: één project, alleen op uw machine.
• Beheerde beleidsinstellingen: organisatiebreed, ingesteld door een beheerder.
• hooks/hooks.json binnen een plugin, actief zolang die plugin is ingeschakeld.
• Skill- of subagent-frontmatter, actief zolang die component actief is.

Hook-vermeldingen uit deze bestanden worden samengevoegd in plaats van elkaar te overschrijven. Een projectinstellingenbestand voegt zijn hooks toe aan die in uw gebruikersinstellingen in plaats van ze te vervangen, waardoor één gebeurtenis meerdere hooks uit verschillende bestanden kan bevatten. De instelling "disableAllHooks": true schakelt ze uit, met één uitzondering: hooks uit beheerde beleidsinstellingen blijven actief, tenzij die instelling ook in de beheerde instellingen wordt toegepast.

Voer /hooks uit binnen een sessie om elke momenteel geregistreerde hook weer te geven, gegroepeerd per gebeurtenis, inclusief het bronbestand en de matcher voor elk. Het menu is alleen-lezen; u wijzigt een hook dus door het instellingenbestand te bewerken. De file watcher verwerkt de wijziging meestal zonder dat een herstart nodig is.

Welke Claude Code hook-events bestaan er

Release 2.1.232 vermeldt eenendertig events, van SessionStart tot en met SessionEnd, die betrekking hebben op compactie, subagents, worktrees en configuratiebestanden. Serverwerkzaamheden maken gebruik van een handvol hiervan.

• PreToolUse: voordat een tool-aanroep wordt uitgevoerd. Dit is het event dat kan blokkeren.
• PostToolUse: nadat een tool-aanroep is geslaagd. PostToolUseFailure wordt geactiveerd wanneer deze faalt; een hook die elk resultaat moet zien, heeft dus beide nodig.
• PermissionRequest: wanneer een tool-aanroep een toestemmingsbesluit vereist; dit is het moment waarop de goedkeuringsprompt zou verschijnen.
• UserPromptSubmit: wanneer u een prompt indient, voordat Claude deze verwerkt. Alles wat deze hook naar stdout schrijft, wordt toegevoegd aan de context van het model.
• SessionStart en SessionEnd: aan elk uiteinde van een sessie. SessionStart wordt ook geactiveerd na compactie, onder de matcher-waarde compact.
• Stop: wanneer Claude klaar is met reageren. Dit gebeurt eenmaal per beurt, niet eenmaal per voltooide taak.

Elke groep bevat een matcher die bepaalt welke voorvallen de hook uitvoeren. Bij de tool-events filtert dit op toolnaam, dus "Edit|Write" wordt geactiveerd bij bestandswijzigingen en nergens anders. Matchers zijn hoofdlettergevoelig. Een lege matcher wordt bij elk voorval geactiveerd. Tools van een MCP (model context protocol) server worden benoemd als mcp__<server>__<tool>, dus een matcher van "mcp__github__.*" vangt de tools van één server op en laat de andere ongemoeid.

Stop-hooks bevatten een valkuil die het waard is om te kennen voordat u er een schrijft. Een Stop-hook die blokkeert, stuurt het model terug naar het werk, en Claude Code overrulet de hook na acht opeenvolgende blokkades. Lees het stop_hook_active-veld uit de hook-input en exit 0 wanneer dit true is, anders zal uw hook blijven loopen totdat deze de limiet bereikt.

Wat een hook ontvangt via stdin

Wanneer Claude op het punt staat om npm test uit te voeren, leest een PreToolUse-hook op Bash het volgende via stdin:

{
  "session_id": "abc123",
  "cwd": "/home/deploy/myproject",
  "hook_event_name": "PreToolUse",
  "tool_name": "Bash",
  "tool_input": {
    "command": "npm test"
  }
}

Elke gebeurtenis bevat session_id, cwd, permission_mode, transcript_path en hook_event_name. De tool-gebeurtenissen voegen tool_name, tool_input en tool_use_id toe. Andere gebeurtenissen bevatten hun eigen velden: UserPromptSubmit krijgt de prompt-tekst en SessionStart krijgt een source van startup, resume, clear, compact of fork.

jq is de gebruikelijke manier om dit binnen een shell-script te lezen, en een minimale server-image bevat dit niet. Installeer het eerst met sudo apt install -y jq op Ubuntu en Debian.

Wat de exit-status doet met de actieve tool-aanroep

Er zijn drie mogelijke uitkomsten.

• Exit 0 betekent dat uw hook geen bezwaar maakt. Bij PreToolUse is dit niet hetzelfde als goedkeuring, en de normale autorisatiestroom wordt nog steeds uitgevoerd. Bij UserPromptSubmit en SessionStart wordt stdout toegevoegd aan de context van het model.
• Exit 2 blokkeert de actie bij gebeurtenissen die geblokkeerd kunnen worden, waaronder PreToolUse, en stderr wordt de reden die aan het model wordt getoond. Bij gebeurtenissen die niet geblokkeerd kunnen worden, zoals PostToolUse, wordt de blokkade genegeerd, hoewel stderr nog steeds als feedback het model bereikt.
• Elke andere exit-code is een niet-blokkerende fout. De actie gaat door. Het transcript toont een melding over een hook-fout met de eerste regel van stderr na de tekst Failed with non-blocking status code:.

Voor alles wat verder gaat dan blokkeren of stilzwijgen, gebruikt u exit 0 en print u een JSON-object naar stdout. Een PreToolUse-hook beslist met permissionDecision:

{
  "hookSpecificOutput": {
    "hookEventName": "PreToolUse",
    "permissionDecision": "deny",
    "permissionDecisionReason": "Database drops go through a migration, not through the agent."
  }
}

"allow" slaat de interactieve prompt over, "deny" annuleert de aanroep en stuurt de reden naar het model, en "ask" toont de prompt zoals gebruikelijk. Kies één stijl per hook. Het combineren van exit 2 met een JSON-beslissing op stdout levert een resultaat op dat u moet opzoeken.

Wanneer meerdere hooks overeenkomen met één gebeurtenis, worden ze parallel uitgevoerd en wordt elke hook volledig afgerond. Een deny van de ene hook stopt de andere hooks niet; een logging-hook schrijft dus nog steeds zijn regel terwijl een guardrail-hook dezelfde aanroep weigert. Claude Code voegt vervolgens de antwoorden samen en hanteert de meest restrictieve, in de volgorde: weigeren, uitstellen, vragen, toestaan.

Voorbeeld 1: blokkeer een destructief commando voordat het wordt uitgevoerd

Sla dit op als .claude/hooks/block-destructive.sh in uw project:

#!/bin/bash
# Deny a Bash tool call whose command matches a banned pattern.
INPUT=$(cat)
COMMAND=$(echo "$INPUT" | jq -r '.tool_input.command // empty')

for pattern in 'rm -rf /' 'mkfs' 'dd if=' 'DROP TABLE'; do
  if printf '%s' "$COMMAND" | grep -qiF -- "$pattern"; then
    echo "Blocked by policy: the command matches '$pattern'. A human runs this one." >&2
    exit 2
  fi
done

exit 0

Maak het uitvoerbaar en registreer het vervolgens op PreToolUse in .claude/settings.json:

chmod +x .claude/hooks/block-destructive.sh

{
  "hooks": {
    "PreToolUse": [
      {
        "matcher": "Bash",
        "hooks": [
          {
            "type": "command",
            "command": "${CLAUDE_PROJECT_DIR}/.claude/hooks/block-destructive.sh",
            "timeout": 10,
            "statusMessage": "Checking the command against policy"
          }
        ]
      }
    ]
  }
}

Test het script handmatig voordat u het vertrouwt, want een hook die crasht op zijn eigen invoer faalt in de open stand:

echo '{"tool_name":"Bash","tool_input":{"command":"rm -rf /var/lib/postgresql"}}' \
  | .claude/hooks/block-destructive.sh
echo $?

U hoort de Blocked by policy:-regel op stderr te zien en een exitcode van 2. Voer een onschadelijk commando in zoals ls -la; u hoort dan geen uitvoer te zien en een exitcode van 0 te krijgen. In een sessie verschijnt de geweigerde aanroep in het transcript met uw bericht als reden, waarna het model dat bericht leest en zich aanpast.

Eén eigenschap maakt dit de moeite waard: PreToolUse-hooks worden geactiveerd vóór de controle van de permissiemodus, in elke permissiemodus. Een weigering blijft dus van kracht, zelfs onder bypassPermissions. Dat is wat een hook nuttig maakt in combinatie met Claude Code auto-modus en de bijbehorende permissie-instellingen, waar de prompts worden beperkt maar de hook nog steeds wordt geactiveerd.

Wees eerlijk over wat dit is. Patroonherkenning op een commandoreeks is een vangrail tegen een onvoorzichtige agent; het is geen grens tegen een slimme agent, omdat hetzelfde commando kan worden geschreven in een vorm die uw grep nooit ziet. Harde regels horen thuis in het permissiesysteem en in het account waaronder het proces wordt uitgevoerd.

Voorbeeld 2: formatteren en linten na elke bewerking

PostToolUse met een Edit|Write-matcher wordt uitgevoerd na elk hulpprogramma voor het bewerken van bestanden. Sla dit op als .claude/hooks/after-edit.sh:

#!/bin/bash
# Format the edited file, then report lint failures back to the model.
INPUT=$(cat)
FILE=$(echo "$INPUT" | jq -r '.tool_input.file_path // empty')
[ -z "$FILE" ] && exit 0

case "$FILE" in
  *.py)
    ruff format "$FILE" >/dev/null 2>&1
    if ! ruff check "$FILE" >&2; then
      exit 2
    fi
    ;;
  *.sh)
    if ! shellcheck "$FILE" >&2; then
      exit 2
    fi
    ;;
esac

exit 0

{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Edit|Write",
        "hooks": [
          {
            "type": "command",
            "command": "${CLAUDE_PROJECT_DIR}/.claude/hooks/after-edit.sh",
            "timeout": 60
          }
        ]
      }
    ]
  }
}

Vraag Claude om een slecht ingesprongen functie toe te voegen aan een Python-bestand en open vervolgens het bestand. Het bestand is automatisch geformatteerd. Dit is uw controle dat de hook is uitgevoerd, aangezien een succesvolle hook niets weergeeft in het gesprek.

De exit 2 hier maakt niets ongedaan. PostToolUse wordt geactiveerd nadat het hulpprogramma al is uitgevoerd, dus de bewerking staat hoe dan ook op de schijf. Wat exit 2 u oplevert, is dat de ruff check-uitvoer het model bereikt als feedback, waardoor het de zojuist geïntroduceerde fout herstelt in plaats van verder te gaan. Dat is het verschil tussen een lint-fout die u vindt tijdens het commit-moment en een fout die de agent in dezelfde beurt herstelt.

Twee limieten voor matchers zijn hier van belang. Edit|Write ziet geen bestanden die zijn gewijzigd door een shell-commando, en Claude schrijft bestanden vaak genoeg via Bash om dat gat reëel te maken. Voor dekking per aanroep, match ook Bash en laat het script gewijzigde bestanden weergeven met git status --porcelain. Voor dekking per beurt, plaats de scan in een Stop-hook.

Voorbeeld 3: elke tool-aanroep loggen voor auditdoeleinden

Een lege matcher op PostToolUse wordt geactiveerd bij elke tool. Door het record naar de system journal te sturen in plaats van naar een bestand in de home-directory, blijft het buiten bereik van de shell van de agent zelf:

{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "",
        "hooks": [
          {
            "type": "command",
            "command": "jq -c '{time: now|todate, session: .session_id, cwd: .cwd, tool: .tool_name, input: .tool_input}' | logger -t claude-code -p local0.info"
          }
        ]
      }
    ]
  }
}

Lees het terug met journalctl -t claude-code -o cat | tail -n 5. U hoort per tool-aanroep één JSON-regel te zien, met de nieuwste onderaan. Als er niets verschijnt, is de hook niet uitgevoerd; de onderstaande sectie voor probleemoplossing behandelt dit.

Voeg hetzelfde blok toe onder PostToolUseFailure om aanroepen die zijn mislukt vast te leggen, omdat PostToolUse alleen bij succes wordt geactiveerd en een mislukt commando meestal het meest relevant is. De reden voor logger in plaats van toevoegen aan een bestand in uw home-directory is eigenaarschap: een hook draait als dezelfde gebruiker als de shell van de agent, dus alles waaraan die gebruiker kan toevoegen, kan die gebruiker ook wissen. De journal wordt geschreven door systemd-journald onder zijn eigen account.

Hoe lang een hook mag draaien

[
  {
    "label": "command, http or mcp_tool hook",
    "default_timeout_seconds": 600
  },
  {
    "label": "agent hook",
    "default_timeout_seconds": 60
  },
  {
    "label": "prompt hook",
    "default_timeout_seconds": 30
  },
  {
    "label": "command hook on UserPromptSubmit",
    "default_timeout_seconds": 30
  },
  {
    "label": "command hook on MessageDisplay",
    "default_timeout_seconds": 10
  },
  {
    "label": "any hook on SessionEnd",
    "default_timeout_seconds": 1.5
  }
]

Een command hook krijgt standaard 600 seconden, wat gelijkstaat aan tien minuten. Sommige events verkorten deze tijd aanzienlijk. SessionEnd hooks delen een budget van 1.5 seconden met elkaar, dus het opschonen aan het einde van een sessie moet snel gebeuren. Het instellen van een langere timeout op de hook verhoogt dit gedeelde budget tot maximaal 60 seconden.

Een hook die zijn time-out bereikt, wordt geannuleerd en levert geen besluit op. Voor een PreToolUse guardrail betekent dit dat deze niet blokkeert: de tool call gaat door in de normale autorisatiestroom. Houd guardrail-scripts om die reden kort. Voor langzame taken waar niemand op wacht, zoals het versturen van een log naar een externe locatie, stelt u "async": true in. De hook draait dan op de achtergrond zonder de tool call op te houden.

Hooks, rules-bestanden, skills en MCP-servers

Vier zaken worden vaak met elkaar verward omdat ze alle vier het gedrag van een agent beïnvloeden. Slechts één daarvan is geen suggestie meer.

Een rules-bestand (CLAUDE.md, of een bestand onder .claude/rules/) is tekst die in de context van het model wordt geladen. Het vormt het gedrag, maar dwingt niets af. In een lange conversatie, bij een grote diff en een nieuwe gebruikersaanvraag, kan één regel tekst verloren gaan. Dat is het gebruikelijke mechanisme achter agents die de instructies negeren die u heeft opgeschreven.

Een skill is een map met instructies en scripts die het model laadt wanneer het de skill relevant acht. Dat oordeel is het doel van een skill, maar ook de beperking: het model beslist nog steeds zelf. U ziet beide kanten in een skill zoals Ponytail, die een agent aanzet tot de kleinst mogelijke wijziging die werkt, omdat het de aanpak van een volledige taak vormgeeft op een manier die geen enkele hook kan, en alleen zolang het model ervoor kiest deze te laden.

Een MCP-server (Model Context Protocol) geeft het model nieuwe tools om aan te roepen. Het verbreedt het bereik van de agent. Het dwingt de agent niet om ergens gebruik van te maken, en het is een afzonderlijk proces dat u moet beheren, wat een taak op zich is: zie het draaien van MCP-servers op een VPS.

Een hook is de enige van de vier die wordt uitgevoerd zonder dat het model daarvoor kiest. Gebruik een rules-bestand voor een voorkeur en een skill voor een procedure die het model moet volgen wanneer het deze toepast. Gebruik een hook voor de stap die elke keer moet plaatsvinden, of voor de actie die nooit mag gebeuren. De diepere vergelijking, inclusief wanneer een skill de voorkeur verdient boven een rules-bestand, staat in de vergelijking tussen skills, MCP en rules-bestanden.

Een plugin is eerder een verpakkingsmethode dan een vijfde mechanisme. Het bundelt hooks en skills in één installeerbare eenheid; dit is hoe een team dezelfde vangrail op elke machine uitrolt: zie hoe Claude Code plugins werken.

De beveiligingsbeslissing op een gedeelde VPS

Een hook is code die door de agent wordt geactiveerd en uitgevoerd onder de gebruiker die Claude Code heeft gestart. Deze erft de omgeving en de bestandsrechten van die gebruiker. Op een laptop is dit een workflow-vraagstuk. Op een VPS waar een agent onbeheerd draait, is het een beveiligingsvraagstuk met vier praktische onderdelen.

Een hook in een repository is code die u niet zelf heeft geschreven. .claude/settings.json wordt gecommit, dus het klonen van een repository en het starten van een sessie daarin kan hooks registreren die bij de repository horen. Claude Code blokkeert project-hooks achter het dialoogvenster voor workspace-vertrouwen voor die map; dit betekent dat het accepteren van vertrouwen het moment is waarop u besluit ze uit te voeren. Lees eerst het hooks-blok.

Een hook ziet de volledige tool-input. Een audit-hook die tool_input logt, schrijft elk argument van elk commando naar een bestand, inclusief elk token dat toevallig op de commandoregel stond. Dat logbestand heeft vervolgens dezelfde bescherming nodig als het geheim zelf, wat onderdeel is van het bredere probleem van het buiten bereik houden van geheimen voor een AI-agent.

Een hook kan schrijven naar de context van het model. Alles wat een SessionStart- of UserPromptSubmit-hook naar stdout stuurt, wordt toegevoegd aan het gesprek. Een hook die tekst van buitenaf, een issue tracker of een logbestand doorstuurt, voert niet-vertrouwde tekst in bij het model alsof u het zelf heeft getypt. Behandel die stdout als input in plaats van als output.

Privileges vormen de echte controle. Draai de agent als een toegewijde gebruiker zonder privileges met alleen de sudo-regels die nodig zijn. Een PreToolUse-weigering is nuttig om te hebben, en het is ontworpen als een 'best effort'-maatregel: de referentie zegt hetzelfde over het if-filter en adviseert u om het permissiesysteem te gebruiken wanneer u een strikte weigering nodig heeft. De permissieregels en het account waaronder het proces draait, zijn de onderdelen die standhouden onder druk.

Eén eigenschap geldt in elke configuratie. PreToolUse-hooks worden geactiveerd vóór de permissiemodus-controle in elke permissiemodus, dus een hook die deny teruggeeft, blokkeert de tool zelfs onder bypassPermissions. Hooks kunnen de toegestane acties van permissieregels inperken. Ze kunnen deze niet verruimen.

Waarom wordt mijn hook niet uitgevoerd?

Doorloop deze stappen in de aangegeven volgorde. Elke stap benoemt het symptoom dat u zult waarnemen.

• Voer /hooks uit en controleer of de hook verschijnt onder het verwachte event. Als een hook ontbreekt in het menu, betekent dit meestal dat het instellingenbestand een JSON-syntaxfout bevat (aangezien afsluitende komma's en commentaar niet zijn toegestaan), of dat het bestand zich niet op een van de zes bovenstaande locaties bevindt.
• Vergelijk de matcher exact met de naam van de tool. Matchers zijn hoofdlettergevoelig; "bash" komt dus nooit overeen met de tool Bash.
• Voer het script handmatig uit met voorbeeldinvoer, zoals in voorbeeld 1 hierboven. Een onverwachte exitcode is een bug in uw script; Claude Code rapporteert dit als een hook-fout in plaats van als een beslissing.
• Een melding met de tekst jq: command not found betekent dat jq ontbreekt op die machine. Een command not found voor uw eigen script betekent dat het pad niet kon worden opgelost; gebruik daarom ${CLAUDE_PROJECT_DIR} of een absoluut pad. Als het script helemaal niet start, is het waarschijnlijk niet uitvoerbaar.
• De hook print geldige JSON, maar er gebeurt niets. Een shell-form hook wordt uitgevoerd via sh -c. Als uw shell-profiel een banner print, wordt die banner vóór uw JSON geplaatst. De stdout begint dan niet meer met {, waardoor Claude Code het geheel als platte tekst leest en de beslissing negeert. Bij exit 0 wordt er nergens iets gerapporteerd, behalve in het debug-logboek. Plaats eventuele echo in uw profiel zodanig dat deze alleen worden uitgevoerd in interactieve shells.
• Komt u er nog steeds niet uit? Start de sessie met claude --debug-file /tmp/claude.log en voer tail -f /tmp/claude.log uit in een tweede terminal. Het debug-logboek registreert welke hooks overeenkwamen, welke exitcode elk daarvan teruggaf, en alles wat ze naar stdout en stderr schreven.

FAQ

Wat is het verschil tussen een Claude Code hook en een CLAUDE.md instructie?

Een CLAUDE.md instructie is tekst in de context van het model; deze concurreert dus om aandacht met het gesprek en het huidige verzoek, waardoor het model de instructie kan afwegen tegen andere factoren. Een hook is een shell-commando dat Claude Code op een vast punt in zijn levenscyclus uitvoert. Het wordt daarom bij elke gebeurtenis uitgevoerd, ongeacht wat het model heeft besloten. Gebruik een instructie voor een voorkeur. Gebruik een hook voor een stap die altijd moet plaatsvinden of een actie die nooit mag gebeuren.

Hoe voorkom ik dat Claude Code een specifiek shell-commando uitvoert?

Registreer een PreToolUse hook met een Bash matcher die het commando uit .tool_input.command leest, een reden naar stderr schrijft en afsluit met exitcode 2. Claude Code annuleert de aanroep en toont de reden aan het model. Dit gebeurt vóór de controle van de permission-mode, waardoor de blokkade zelfs in bypassPermissions mode standhoudt. Patroonherkenning op een commandoreeks is een vangrail en geen beveiligingsgrens, omdat hetzelfde commando kan worden geschreven in een vorm die het patroon mist. Ondersteun dit daarom met toegangsregels en een account zonder verhoogde rechten.

Mijn hook print geldige JSON, maar er gebeurt niets. Hoe komt dat?

De meest voorkomende oorzaak is uw shell-profiel. Een hook zonder args veld wordt uitgevoerd via sh -c, en sommige profielen printen een banner bij elke shell-sessie. Deze banner komt op stdout terecht, vóór uw JSON. Omdat de output niet langer begint met {, behandelt Claude Code alles als platte tekst en negeert het de beslissing. Bij exitcode 0 wordt er dan niets gerapporteerd in het transcript. Beveilig elke echo in uw profiel met een test voor een interactieve shell en bevestig de oplossing door het debug-logboek uit claude --debug-file /tmp/claude.log te lezen.

Is het veilig om Claude Code hooks uit te voeren op een gedeelde server?

Hooks worden uitgevoerd als de gebruiker die Claude Code heeft gestart, met de bestandsrechten van die gebruiker. Een hook kan dus alles wat dat account kan doen. Twee gewoontes dekken het grootste deel van het risico: voer de agent uit als een toegewezen account zonder verhoogde rechten met een beperkt sudo beleid, en lees het hooks blok van elke repository voordat u het dialoogvenster voor workspace-vertrouwen accepteert, omdat project-hooks worden meegeleverd in .claude/settings.json. Stel "disableAllHooks": true in uw instellingenbestand in als u wilt dat er geen enkele hook wordt uitgevoerd.