Permissions, hooks et garde-fous

Le chapitre précédent a posé la distinction : un CLAUDE.md exprime une intention, une permission impose une contrainte. Ce chapitre traite des mécanismes qui contraignent réellement.

C’est aussi le chapitre qui permet de travailler vite sans travailler dangereusement — les deux ne s’opposent que si l’on n’a pas configuré les garde-fous.

Les fichiers de configuration#

Quatre niveaux, dans l’ordre de priorité décroissante.

La politique gérée l’emporte sur tout et ne se contourne pas.

Une exception importante : les règles de permission fusionnent entre les niveaux au lieu de s’écraser. Une interdiction posée au niveau projet reste active même si votre fichier local autorise largement.

/status affiche les fichiers effectivement chargés et les règles actives. Un fichier au JSON invalide n’apparaît pas — c’est la première chose à vérifier quand une règle semble ignorée.

Les règles de permission#

Trois listes, une syntaxe.

{
  "permissions": {
    "allow": [
      "Bash(npm run test *)",
      "Bash(npm run lint)",
      "Bash(git status)",
      "Bash(git diff *)",
      "Read(./src/**)",
      "Edit(./src/**)"
    ],
    "ask": [
      "Bash(git push *)",
      "Bash(npm publish *)"
    ],
    "deny": [
      "Read(./.env)",
      "Read(./.env.*)",
      "Read(./secrets/**)",
      "Edit(./migrations/**)",
      "Bash(rm -rf *)",
      "Bash(curl *)"
    ]
  }
}

Trois choses à retenir sur la syntaxe.

Le nom de l’outil, puis un motif entre parenthèses. Bash, Read, Edit, Write, et les outils apportés par les serveurs MCP sous la forme mcp__serveur__outil.

Les motifs acceptent * et **. Read(./src/**) couvre toute l’arborescence.

Le refus gagne toujours. C’est ce qui permet d’autoriser largement le travail courant tout en fermant quelques portes précises.

Les hooks#

Un hook est une commande exécutée automatiquement à un point précis du cycle de vie, quelle que soit la décision du modèle. C’est la différence de nature avec une instruction.

Ils se déclarent dans les mêmes fichiers de réglages, avec une structure à trois niveaux : l’événement, un groupe de filtrage, les gestionnaires.

{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Edit|Write",
        "hooks": [
          {
            "type": "command",
            "command": "npx prettier --write \"$CLAUDE_FILE_PATHS\"",
            "timeout": 30
          }
        ]
      }
    ]
  }
}

Les événements les plus utiles au quotidien :

Le mécanisme de blocage tient au code de sortie : un hook qui sort en 2 bloque l’action, et son stderr devient le message d’erreur transmis à Claude. Un code 0 laisse passer ; un JSON en sortie permet un contrôle plus fin.

Un hook qui bloque#

L’exemple canonique : empêcher toute écriture hors du dépôt.

#!/usr/bin/env bash
# .claude/hooks/protege-hors-depot.sh
# Refuse toute écriture dont le chemin sort du répertoire du projet.

set -euo pipefail

entree=$(cat)
chemin=$(printf '%s' "$entree" | jq -r '.tool_input.file_path // empty')

[ -z "$chemin" ] && exit 0

racine=$(git rev-parse --show-toplevel 2>/dev/null || pwd)
absolu=$(cd "$(dirname "$chemin")" 2>/dev/null && pwd -P)/$(basename "$chemin")

case "$absolu" in
  "$racine"/*) exit 0 ;;
  *)
    echo "Écriture refusée hors du dépôt : $absolu" >&2
    exit 2
    ;;
esac

{
  "hooks": {
    "PreToolUse": [
      {
        "matcher": "Edit|Write",
        "hooks": [
          { "type": "command", "command": "${CLAUDE_PROJECT_DIR}/.claude/hooks/protege-hors-depot.sh" }
        ]
      }
    ]
  }
}

Ce que ce hook garantit et qu’aucune instruction ne garantit : quelle que soit la façon dont Claude formule son action, elle est refusée.

Un hook qui referme la boucle#

L’usage le plus rentable au quotidien : relancer la vérification après chaque modification, pour que Claude voie immédiatement ce qu’il a cassé.

{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Edit|Write",
        "hooks": [
          {
            "type": "command",
            "command": "npm run lint:changed --silent || true",
            "timeout": 60,
            "async": true
          }
        ]
      }
    ]
  }
}

Le async évite de bloquer la session sur une vérification longue.

Un hook qui injecte du contexte#

{
  "hooks": {
    "SessionStart": [
      {
        "hooks": [
          {
            "type": "command",
            "command": "echo \"Branche : $(git branch --show-current) — dernier commit : $(git log -1 --format=%s)\""
          }
        ]
      }
    ]
  }
}

La sortie standard d’un hook SessionStart est ajoutée au contexte. C’est une manière élégante de donner à Claude l’état courant sans l’écrire dans CLAUDE.md.

Isoler une session#

Quand une session doit tourner sans supervision — traitement long, intégration continue, travail nocturne — la bonne réponse n’est pas d’élargir les permissions : c’est de réduire ce qui peut être atteint.

Trois niveaux, du plus léger au plus solide.

Un dépôt jetable. Un clone frais, sans secrets, sans accès aux environnements. Ce qui peut être cassé se jette.

Un worktree git dédié. git worktree add ../travail-auto isole les modifications de votre copie de travail sans dupliquer le dépôt.

Un conteneur. L’isolation réelle : système de fichiers, réseau et identifiants contrôlés. C’est le seul contexte où un mode sans confirmation se justifie.

Une combinaison qui marche bien : conteneur + permissions larges à l’intérieur + réseau restreint en sortie. Claude travaille librement dans une boîte dont les parois sont sûres.

{
  "$schema": "https://json.schemastore.org/claude-code-settings.json",
  "permissions": {
    "allow": [
      "Bash(pnpm run *)",
      "Bash(pnpm test *)",
      "Bash(git status)",
      "Bash(git diff *)",
      "Bash(git log *)",
      "Read(./src/**)",
      "Read(./tests/**)",
      "Edit(./src/**)",
      "Edit(./tests/**)"
    ],
    "ask": [
      "Bash(git push *)",
      "Bash(gh pr create *)"
    ],
    "deny": [
      "Read(./.env)",
      "Read(./.env.*)",
      "Read(./**/credentials*)",
      "Edit(./migrations/**)",
      "Edit(./.github/workflows/**)",
      "Bash(curl *)",
      "Bash(wget *)",
      "Bash(psql *)"
    ]
  },
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Edit|Write",
        "hooks": [
          { "type": "command", "command": "pnpm exec prettier --write \"$CLAUDE_FILE_PATHS\"", "timeout": 30 }
        ]
      }
    ],
    "PreToolUse": [
      {
        "matcher": "Bash",
        "hooks": [
          { "type": "command", "command": "${CLAUDE_PROJECT_DIR}/.claude/hooks/refuse-prod.sh" }
        ]
      }
    ]
  }
}

{
  "permissions": {
    "allow": ["Bash(docker compose *)"]
  }
}

Ce qu’il faut retenir#