Claude Code poate lucra singur minute în șir, apoi se oprește: are nevoie de permisiunea ta ca să ruleze o comandă sau a terminat și așteaptă următorul prompt. Dacă ai plecat de la terminal, așteaptă până te întorci.

Claude Code are hookuri pentru ambele momente. Un hook Notification rulează când are nevoie de permisiunea ta, iar un hook Stop rulează când termină un răspuns. Acest ghid le leagă pe amândouă de Honk: iPhone-ul și Apple Watch-ul te anunță, iar o sesiune care te cheamă de zece ori trimite o singură notificare, nu zece.

Înainte să începi

Un cont Honk (deocamdată doar pe bază de invitație: cere acces) și un proiect pentru agenții tăi de programare, de exemplu „Claude Code”, cu o cheie API. Dă-i proiectului o cheie doar a lui: oricine o are poate trimite mesaje în proiect, și nicăieri altundeva.
CLI-ul honk pe calculatorul pe care rulează Claude Code: go install github.com/honk-hq/go/cmd/honk@latest sau un binar de pe pagina Releases.
jq, care citește JSON-ul pe care Claude Code îl transmite hookurilor. Versiunile recente de macOS îl au deja; pe Linux, îl instalezi din managerul de pachete.

1. Ține cheia într-un fișier

Hookurile rulează ca niște comenzi shell, în mediul lui Claude Code. Ca să nu ajungă cheia în fișiere de setări pe care le-ai putea pune într-un commit, pune-o în ~/.config/honk/env:

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

Apoi rulează chmod 600 ~/.config/honk/env, ca să-l poți citi doar tu.

2. Adaugă scriptul pentru hook

Salvează scriptul de mai jos ca ~/.claude/hooks/honk.sh și fă-l executabil cu chmod +x:

#!/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

Scriptul citește evenimentul pe care Claude Code îl trimite pe stdin și îl transformă într-un eveniment Honk:

Cere permisiunea: un Claxon puternic cu titlul „Claude Code needs you in my-app” și cu mesajul lui Claude Code, de exemplu „Claude needs your permission”.
A terminat: un Claxon ușor cu titlul „Claude Code finished in my-app” și cu primele 280 de caractere din ultimul răspuns.

Titlurile sunt chiar în script, deci le poți scrie în română. || true face ca o problemă de rețea să nu devină niciodată o eroare de hook.

3. Înregistrează hookurile

Adaugă ambele hookuri în ~/.claude/settings.json, care se aplică tuturor proiectelor de pe acest calculator. Dacă fișierul are deja o cheie hooks, adaugă Notification și Stop lângă evenimentele care sunt deja acolo:

{
  "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" limitează hookul Notification la cererile de permisiune. Hookul Stop nu primește matcher: rulează la finalul fiecărui răspuns.
"async": true rulează hookul în fundal, așa că Claude Code nu așteaptă niciodată trimiterea notificării.

Același bloc merge și în .claude/settings.json dintr-un repository, pe care îl poți pune într-un commit ca să-l împarți cu echipa (fiecare are apoi nevoie de script, de CLI și de propria cheie), sau în .claude/settings.local.json, pentru un singur proiect, doar pe calculatorul tău.

Scrie /hooks în Claude Code ca să verifici că apar ambele hookuri. Ca să testezi scriptul fără să-l aștepți pe Claude, rulează:

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

O notificare pe proiect, nu una la fiecare mesaj

Toate evenimentele unui proiect folosesc cheia de grup claude-code/<project>, așa că Honk le ține în același grup. De asta depinde cât de des îți vibrează telefonul:

Primul mesaj te anunță imediat.
Cele de după nu mai trimit fiecare câte o notificare. Primești cel mult o actualizare la 5 minute, cu numărul la zi, iar pe iPhone fiecare actualizare o înlocuiește pe cea de dinainte, în loc să se adune.
Un nivel mai puternic decât tot ce a trimis grupul până atunci ajunge imediat, chiar și în acele 5 minute: de exemplu, o cerere de permisiune (Claxon puternic) după un răspuns terminat (Claxon ușor).

Ambele valori sunt în Setări, la proiect. Cât timp o problemă se repetă, te anunță cel mult o dată la … schimbă cele 5 minute. După o zi fără mesaje, următorul contează ca nou și te anunță imediat; Grupează mesajele care vin la mai puțin de … unul de altul scurtează această pauză, ca fiecare nouă sesiune de lucru să înceapă cu o notificare.

Mai liniștit: doar când ai plecat de la calculator

Hookul Stop rulează după fiecare răspuns, chiar și când stai cu ochii pe terminal. Ca să primești notificări doar când ai plecat, șterge blocul Stop și schimbă matcherul în "permission_prompt|idle_prompt". Claude Code trimite idle_prompt când a terminat de vreo 60 de secunde și n-ai mai scris nimic de atunci, așa că o notificare înseamnă că te așteaptă cu adevărat.

Ce arată notificarea

Notificarea arată titlul și mesajul, iar mesajul poate fi începutul răspunsului lui Claude, cu tot cu cod. Pentru proiecte private, deschide Setări la proiect și alege la Ce arată notificările opțiunea Generic (fără conținut): notificarea arată atunci doar numele proiectului, iar textul rămâne în inbox. Sau scoate complet răspunsul din script.

Codex

Codex CLI de la OpenAI are un hook mai simplu: notify rulează un program după fiecare tură încheiată și îi transmite evenimentul ca un singur argument JSON. Acest script trimite același Claxon ușor, într-un grup separat:

#!/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

Salvează-l ca ~/.codex/honk.sh, fă-l executabil și adaugă o linie în ~/.codex/config.toml, cu directorul tău home în cale:

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

Deocamdată, Codex trimite la notify doar turele încheiate (agent-turn-complete), așa că scriptul acoperă finalul unei sarcini, nu și cererile de aprobare.

Deocamdată, Honk e disponibil doar pe bază de invitație: cere acces. Tot ce face acest ghid merge și pe planul Free.