Chapitre 7.4 — Atelier : les hooks de TaskFlow

⏱️ TL;DR — On assemble la chaîne de hooks de TaskFlow dans .claude/settings.json (niveau projet, versionné) : PostToolUse (prettier + eslint —fix, léger), Stop (tests + typecheck, lourd), PreToolUse (protège migrations/.env, refuse commit sur main). On s’appuie sur la skill update-config pour écrire une config correcte sans se tromper de syntaxe. Résultat : toute contribution à TaskFlow est forcément propre, testée et sans franchissement de ligne rouge — le filet qui autorise l’autonomie (5.3) est complet.

🎯 Objectifs

• Écrire un .claude/settings.json de projet complet.
• Combiner hooks légers (Post), lourds (Stop) et garde-fous (Pre).
• Utiliser update-config pour ne pas se tromper de syntaxe.
• Vérifier que la chaîne fonctionne de bout en bout.

Écrire la config sans se tromper : update-config

La syntaxe exacte des hooks (noms d’événements, forme du matcher, données reçues) évolue et se trompe facilement. Plutôt que de deviner, utilise la skill update-config : elle sait configurer le harness via settings.json (hooks, permissions, env) avec la bonne syntaxe.

« Ajoute au settings.json de projet un hook qui lance npx prettier --write après chaque édition, et un hook Stop qui lance npm test. »

C’est le bon réflexe : les automatismes (« à partir de maintenant, à chaque fois… ») ne peuvent pas être portés par la mémoire ou une préférence — ils doivent vivre dans settings.json, et update-config t’aide à les y écrire correctement.

La chaîne complète de TaskFlow

Cible : .claude/settings.json à la racine de TaskFlow (versionné, donc partagé). Structure visée :

{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Edit|Write",
        "hooks": [
          { "type": "command", "command": "npx prettier --write ." },
          { "type": "command", "command": "npx eslint --fix ." }
        ]
      }
    ],
    "Stop": [
      {
        "hooks": [
          { "type": "command", "command": "npm run typecheck" },
          { "type": "command", "command": "npm test" }
        ]
      }
    ],
    "PreToolUse": [
      {
        "matcher": "Edit|Write",
        "hooks": [{ "type": "command", "command": "node .claude/hooks/protect-paths.mjs" }]
      },
      {
        "matcher": "Bash",
        "hooks": [{ "type": "command", "command": "node .claude/hooks/git-guard.mjs" }]
      }
    ]
  },
  "permissions": {
    "allow": ["Bash(npm test)", "Bash(npm run lint)", "Bash(npm run typecheck)", "Bash(git status)", "Bash(git diff)"],
    "deny": ["Bash(git push --force*)", "Bash(rm -rf*)"]
  }
}

⚠️ Piège — Recopier ce bloc tel quel sans vérifier la syntaxe courante. Les noms de clés et le format peuvent différer selon la version. Fais-le générer/valider par update-config ou vérifie dans la doc. La structure pédagogique (Post léger / Stop lourd / Pre garde-fou) est stable ; les détails de syntaxe, non.

Les deux petits scripts de garde-fou (protect-paths.mjs, git-guard.mjs) font ce qu’on a décrit en 7.3 : refuser (avec message) l’édition de prisma/migrations/**, .env*, *.generated.*, et refuser un commit/push sur main ou un --force.

Le résultat, illustré

Ce que TaskFlow a gagné

• Le code est toujours formaté et linté (plus besoin de le dire).
• L’agent ne peut pas conclure sur un typecheck ou des tests rouges.
• Les migrations, .env, fichiers générés sont intouchables à la main.
• main est protégé du commit direct et du force push.
• On peut alléger le CLAUDE.md : les lignes marquées [futur hook] (3.5) sont désormais garanties → supprimées ou réduites à un rappel.

Surtout : l’autonomie devient sûre (5.3). Avec ce filet (garde-fous + qualité + git/tests), tu peux passer l’agent en mode « accepter les éditions » voire élargir sur les tâches mécaniques, sans craindre les dégâts. Le filet précède l’autonomie — et là, il est complet.

🧭 Sur TaskFlow — Le fil rouge a maintenant : direction (P2), mémoire (P3), design system (P4), une feature prouvée (P5), la capacité d’être repris (P6), et une automatisation de la qualité (P7). Prochaine étape : apprendre à déléguer proprement les grosses sous-tâches (Partie 8).

✏️ Exercices

Exercice 1 — Ta chaîne complète. Sur un projet, fais mettre en place par update-config : Post (format+lint), Stop (test), Pre (protéger .env). Teste chaque maillon (édition formatée ? test rouge bloque la conclusion ? .env protégé ?).

Exercice 2 — Autonomie gagnée. Une fois la chaîne en place, passe l’agent en « accepter les éditions » sur une tâche mécanique de faible risque. Constate : le filet (hooks + git) rend-il l’autonomie confortable ?

🧠 Quiz de révision

Fin de la Partie 7. La qualité de TaskFlow est automatisée. On apprend maintenant à déléguer : Partie 8 — Déléguer : subagents & workflows.