# Notification sur iPhone quand Claude Code vous attend

> Un push sur votre iPhone ou votre Apple Watch quand Claude Code demande une autorisation ou termine une tâche. Deux hooks Claude Code et la CLI honk.

Source: https://honk-honk.app/fr/guides/notifications-claude-code

Claude Code peut travailler seul pendant plusieurs minutes, puis s’arrêter : il a besoin de votre autorisation pour lancer une commande, ou il a terminé et attend votre prochain prompt. Si vous n’êtes plus devant le terminal, il attend votre retour, aussi longtemps qu’il le faut.

Claude Code a des [hooks](https://code.claude.com/docs/en/hooks) pour ces deux moments. Un hook `Notification` s’exécute quand il a besoin de votre autorisation, et un hook `Stop` quand il termine une réponse. Ce guide les relie tous les deux à Honk : votre iPhone et votre Apple Watch vous préviennent, et une session qui vous appelle dix fois envoie une seule notification, pas dix.

## Avant de commencer

- Un compte Honk (pour l’instant sur invitation : [demandez un accès](https://honk-honk.app/fr/demander-un-acces)) et un projet pour vos agents de code, par exemple « Claude Code », avec une clé d’ingestion. Donnez à ce projet sa propre clé : qui la possède peut publier dans ce projet, et nulle part ailleurs.
- La CLI `honk` sur l’ordinateur où tourne Claude Code : `go install github.com/honk-hq/go/cmd/honk@latest`, ou un binaire depuis la [page des releases](https://github.com/honk-hq/go/releases).
- `jq`, qui lit le JSON que Claude Code transmet aux hooks. Les versions récentes de macOS l’incluent ; sous Linux, installez-le avec votre gestionnaire de paquets.

## 1. Garder la clé dans un fichier

Les hooks s’exécutent comme des commandes shell, dans l’environnement de Claude Code. Pour que la clé ne se retrouve pas dans des fichiers de configuration que vous pourriez committer, placez-la dans `~/.config/honk/env` :

```sh
HONK_URL=https://honk-honk.app
HONK_KEY=honk_…
```

Lancez ensuite `chmod 600 ~/.config/honk/env` pour que vous seul puissiez le lire.

## 2. Ajouter le script du hook

Enregistrez ce script sous `~/.claude/hooks/honk.sh` et rendez-le exécutable avec `chmod +x` :

```bash
#!/usr/bin/env bash
# A push when Claude Code needs your permission (Notification) or finishes (Stop).
# Claude Code sends the event as JSON on stdin. Every ping from one project
# shares a group key, so Honk folds repeats into one notification.
set -a; . "$HOME/.config/honk/env"; set +a
input=$(cat)
dir=${CLAUDE_PROJECT_DIR:-$(jq -r '.cwd // empty' <<<"$input")}
project=$(basename "${dir:-$PWD}")

case $(jq -r '.hook_event_name' <<<"$input") in
  Notification)
    level=loud
    title="Claude Code needs you in $project"
    text=$(jq -r '.message // empty' <<<"$input") ;;
  Stop)
    level=light
    title="Claude Code finished in $project"
    text=$(jq -r '.last_assistant_message // empty | .[:280]' <<<"$input") ;;
  *) exit 0 ;;
esac

honk send --severity "$level" --title "$title" --message "${text:-$title}" \
  --group-key "claude-code/$project" --source "$(hostname -s)" --quiet || true
```

Il lit l’événement que Claude Code envoie sur stdin et en fait un événement Honk :

- **Demande d’autorisation :** un Coup de klaxon appuyé intitulé « Claude Code needs you in my-app », avec le message de Claude Code lui-même, par exemple « Claude needs your permission ».
- **Tâche terminée :** un Petit coup de klaxon intitulé « Claude Code finished in my-app », avec les 280 premiers caractères de la dernière réponse.

Les titres sont dans le script : vous pouvez les écrire en français. `|| true` garantit qu’un problème réseau ne devient jamais une erreur de hook.

## 3. Déclarer les hooks

Ajoutez les deux hooks à `~/.claude/settings.json`, qui s’applique à tous les projets de cet ordinateur. Si le fichier contient déjà une clé `hooks`, ajoutez `Notification` et `Stop` à côté des événements déjà présents :

```json
{
  "hooks": {
    "Notification": [
      {
        "matcher": "permission_prompt",
        "hooks": [
          {
            "type": "command",
            "command": "$HOME/.claude/hooks/honk.sh",
            "async": true
          }
        ]
      }
    ],
    "Stop": [
      {
        "hooks": [
          {
            "type": "command",
            "command": "$HOME/.claude/hooks/honk.sh",
            "async": true
          }
        ]
      }
    ]
  }
}
```

- `"matcher": "permission_prompt"` limite le hook `Notification` aux demandes d’autorisation. Le hook `Stop` n’a pas de matcher : il s’exécute à la fin de chaque réponse.
- `"async": true` lance le hook en arrière-plan : Claude Code n’attend jamais le push.

Le même bloc fonctionne dans le `.claude/settings.json` d’un dépôt, que vous pouvez committer pour le partager avec votre équipe (chacun a alors besoin du script, de la CLI et de sa propre clé), ou dans `.claude/settings.local.json`, pour un seul projet et sur votre ordinateur uniquement.

Tapez `/hooks` dans Claude Code pour vérifier que les deux hooks apparaissent. Pour tester le script sans attendre Claude, lancez :

```sh
echo '{"hook_event_name":"Notification","message":"Test from the terminal"}' | ~/.claude/hooks/honk.sh
```

## Une notification par projet, pas une par appel

Tous les événements d’un projet utilisent la clé de groupe `claude-code/<project>`, donc Honk les garde dans un seul groupe. C’est ce qui détermine la fréquence à laquelle votre téléphone vibre :

- Le premier appel déclenche un push tout de suite.
- Les suivants n’envoient pas chacun leur push. Vous recevez au plus une mise à jour toutes les 5 minutes, avec le compteur, et sur iPhone chaque mise à jour remplace la précédente au lieu de s’empiler.
- Un niveau plus fort que tout ce que le groupe a envoyé jusque-là passe tout de suite, même pendant ces 5 minutes : une demande d’autorisation (Coup de klaxon appuyé) après une réponse terminée (Petit coup de klaxon), par exemple.

Les deux valeurs sont dans les **Réglages** du projet. **Tant qu’un problème se répète, prévenir au plus une fois par …** modifie les 5 minutes. Après une journée sans appel, le suivant compte comme nouveau et déclenche un push tout de suite ; **Regrouper les messages qui arrivent à moins de … d’intervalle** raccourcit cette journée, pour que chaque nouvelle session de travail commence par un push.

## Plus discret : seulement quand vous n’êtes pas là

Le hook `Stop` s’exécute après chaque réponse, même quand vous avez les yeux sur le terminal. Pour n’être prévenu que lorsque vous vous êtes éloigné, supprimez le bloc `Stop` et remplacez le matcher par `"permission_prompt|idle_prompt"`. Claude Code envoie `idle_prompt` quand il a terminé depuis environ 60 secondes et que vous n’avez rien tapé depuis : un push signifie alors qu’il vous attend vraiment.

## Ce qu’affiche le push

Le push affiche le titre et le message, et le message peut être le début de la réponse de Claude, code compris. Pour un travail confidentiel, ouvrez les **Réglages** du projet et choisissez **Générique (sans contenu)** sous **Ce qu’affichent les notifications** : le push n’affiche plus que le nom du projet, et le texte reste dans la boîte de réception. Ou retirez simplement la réponse du script.

## Codex

La CLI Codex d’OpenAI a un hook plus simple : `notify` lance un programme à la fin de chaque tour et lui passe l’événement sous la forme d’un seul argument JSON. Ce script envoie le même Petit coup de klaxon, dans un groupe à part :

```bash
#!/usr/bin/env bash
# Codex runs this after each finished turn, with the event as one JSON argument.
set -a; . "$HOME/.config/honk/env"; set +a
project=$(basename "$(jq -r '.cwd // "codex"' <<<"$1")")
text=$(jq -r '."last-assistant-message" // empty | .[:280]' <<<"$1")

honk light "Codex finished in $project" "${text:-Done.}" \
  --group-key "codex/$project" --source "$(hostname -s)" --quiet || true
```

Enregistrez-le sous `~/.codex/honk.sh`, rendez-le exécutable et ajoutez une ligne à `~/.codex/config.toml`, avec votre dossier personnel dans le chemin :

```toml
# a top-level key: put it above the first [section]
notify = ["/Users/you/.codex/honk.sh"]
```

Pour l’instant, Codex n’envoie à `notify` que les tours terminés (`agent-turn-complete`) : cela couvre la fin d’une tâche, pas les demandes d’approbation.