Claude · 1 min
Les 4 Hooks Claude qui évoluent tout seul
Le package complet pour que Claude apprenne de ses propres erreurs, automatiquement.
Ce qu’il y a dedans
- Ce que tu vas obtenir
- Comment ça marche
- 📁 Les 4 fichiers
- ⚙️ Installation (3 étapes)
Le package complet pour que Claude apprenne de ses propres erreurs, automatiquement.
Ce que tu vas obtenir
4 scripts qui s'activent tout seuls à chaque session Claude Code. Ensemble, ils :
- Observent chaque run (outils appelés, erreurs, durée)
- Détectent les patterns d'échec récurrents
- Écrivent des règles dans .claude/rules/ que Claude lira au prochain run
Résultat : Claude se corrige tout seul entre les sessions. Plus besoin de répéter la même instruction.
Comment ça marche
┌─────────────┐ ┌──────────────┐ ┌─────────────┐ ┌──────────────┐
│ 01-startup │ → │ 02-tracker │ → │ 03-stop │ → │ 04-engine │
│ PreToolUse │ │ PostToolUse │ │ Stop │ │ Stop (gate) │
└─────────────┘ └──────────────┘ └─────────────┘ └──────────────┘
init session log chaque dump final toutes les 4h
outil/erreur OK ou FAIL → spawn worker
→ écrit règles
📁 Les 4 fichiers
Fichier 1 — 01-startup.sh
Hook : PreToolUse — Initialise l'état de la session au premier outil appelé.
#!/usr/bin/env bash
python3 -c "
import json, sys, os
from datetime import datetime
data = json.load(sys.stdin)
session_id = data.get('session_id', 'unknown')
sessions_dir = '.claude/observations'
session_file = f'{sessions_dir}/{session_id}.json'
os.makedirs(sessions_dir, exist_ok=True)
if not os.path.exists(session_file):
session = {
'session_id': session_id,
'start_time': datetime.now().isoformat(),
'status': 'running',
'tools': [],
'errors': []
}
with open(session_file, 'w') as f:
json.dump(session, f, indent=2)
"
Fichier 2 — 02-tool-tracker.sh
Hook : PostToolUse — Enregistre chaque appel d'outil + détecte les erreurs.
#!/usr/bin/env bash
python3 -c "
import json, sys
from datetime import datetime
data = json.load(sys.stdin)
session_id = data.get('session_id', 'unknown')
tool_name = data.get('tool_name', 'unknown')
tool_response = str(data.get('tool_response', ''))
session_file = f'.claude/observations/{session_id}.json'
with open(session_file) as f:
session = json.load(f)
is_error = any(w in tool_response.lower() for w in
['error', 'failed', 'exception', 'traceback', 'denied'])
session['tools'].append({
'time': datetime.now().isoformat(),
'tool': tool_name,
'error': is_error
})
if is_error:
session['errors'].append({
'time': datetime.now().isoformat(),
'tool': tool_name,
'snippet': tool_response[:300]
})
with open(session_file, 'w') as f:
json.dump(session, f, indent=2)
"
Fichier 3 — 03-session-stop.sh
Hook : Stop — Dump l'observation complète à l'arrêt de la session.
#!/usr/bin/env bash
python3 -c "
import json, sys
from datetime import datetime
data = json.load(sys.stdin)
session_id = data.get('session_id', 'unknown')
session_file = f'.claude/observations/{session_id}.json'
with open(session_file) as f:
session = json.load(f)
start = datetime.fromisoformat(session['start_time'])
duration = round((datetime.now() - start).total_seconds())
session['status'] = 'failed' if session['errors'] else 'success'
session['end_time'] = datetime.now().isoformat()
session['duration_seconds'] = duration
session['summary'] = f\"{'FAIL' if session['errors'] else 'OK'} | {len(session['tools'])} outils | {duration}s\"
with open(session_file, 'w') as f:
json.dump(session, f, indent=2)
"
Fichier 4 — 04-rule-engine.sh
Hook : Stop — Le gate. Toutes les 4h, si 3+ nouvelles observations, spawn un worker en background qui analyse les 20 derniers runs et écrit les règles.
#!/usr/bin/env bash
python3 -c "
import json, sys, subprocess
from datetime import datetime, timedelta
from pathlib import Path
GATE = Path('.claude/.rule-engine-last-run')
OBS = Path('.claude/observations')
now = datetime.now()
if GATE.exists():
last = datetime.fromisoformat(GATE.read_text().strip())
if (now - last) < timedelta(hours=4):
sys.exit(0)
last_dt = datetime.fromisoformat(GATE.read_text().strip()) if GATE.exists() else datetime.min
new = [f for f in OBS.glob('*.json')
if datetime.fromtimestamp(f.stat().st_mtime) > last_dt
and json.loads(f.read_text()).get('status') in ('success', 'failed')]
if len(new) < 3:
sys.exit(0)
GATE.parent.mkdir(exist_ok=True)
GATE.write_text(now.isoformat())
subprocess.Popen(
['python3', '.claude/hooks/worker-rules.py'],
stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL,
start_new_session=True
)
"
Bonus — worker-rules.py
Le worker lancé en background par le fichier 4. Analyse les 20 derniers runs, détecte les outils qui plantent en boucle, écrit les règles.
#!/usr/bin/env python3
import json
from pathlib import Path
from datetime import datetime
from collections import Counter
OBS_DIR = Path('.claude/observations')
RULES_DIR = Path('.claude/rules')
RULES_DIR.mkdir(exist_ok=True)
obs_files = sorted(
[f for f in OBS_DIR.glob('*.json')
if json.loads(f.read_text()).get('status') in ('success', 'failed')],
key=lambda f: f.stat().st_mtime
)[-20:]
sessions = [json.loads(f.read_text()) for f in obs_files]
failed = [s for s in sessions if s['status'] == 'failed']
if not failed:
exit(0)
error_tools = Counter()
for s in failed:
for err in s.get('errors', []):
error_tools[err.get('tool', 'unknown')] += 1
rules = [
f"- L'outil `{tool}` a échoué {count} fois. Vérifier permissions et contexte avant d'appeler."
for tool, count in error_tools.most_common(5) if count >= 2
]
if not rules:
exit(0)
ts = datetime.now().strftime('%Y%m%d_%H%M%S')
rule_file = RULES_DIR / f'auto-{ts}.md'
rule_file.write_text(
f"# Règles auto — {datetime.now().strftime('%Y-%m-%d %H:%M')}\n\n"
f"Basées sur {len(failed)} sessions en échec / {len(sessions)} analysées.\n\n"
+ '\n'.join(rules) + '\n'
)
⚙️ Installation (3 étapes)
- Crée le dossier .claude/hooks/ dans ton projet et colle les 5 fichiers dedans.
- Ajoute ce bloc dans ton .claude/settings.json :
{
"hooks": {
"PreToolUse": [{"matcher": ".*", "hooks": [
{"type": "command", "command": "bash .claude/hooks/01-startup.sh"}
]}],
"PostToolUse": [{"matcher": ".*", "hooks": [
{"type": "command", "command": "bash .claude/hooks/02-tool-tracker.sh"}
]}],
"Stop": [{"hooks": [
{"type": "command", "command": "bash .claude/hooks/03-session-stop.sh"},
{"type": "command", "command": "bash .claude/hooks/04-rule-engine.sh"}
]}]
}
}
- Rends les scripts exécutables : chmod +x .claude/hooks/*.sh
C'est tout. Le loop démarre au prochain run.
Rejoins CORE LABS®
