feat: initial brain-template - 30+ agents, profil universel, BSI, README installation

profil/CLAUDE.md.example

@@ -0,0 +1,60 @@
+# CLAUDE.md — Bootstrap
+# Copier vers ~/.claude/CLAUDE.md puis remplacer <BRAIN_ROOT> par le chemin réel
+
+## Configuration machine (seul endroit a modifier sur une nouvelle machine)
+
+brain_root: <BRAIN_ROOT>
+
+---
+
+## Contexte persistant (obligatoire, dans l'ordre)
+
+0. `<BRAIN_ROOT>/PATHS.md`               — chemins machine
+1. `<BRAIN_ROOT>/focus.md`               — etat projets
+2. `<BRAIN_ROOT>/profil/collaboration.md` — regles de travail
+3. `<BRAIN_ROOT>/agents/coach.md`         — presence permanente
+
+Conditionnel :
+4. `profil/objectifs.md`   — si session progression/CV
+5. `projets/<projet>.md`   — si session projet specifique
+
+Ces fichiers font foi. Ne pas demander a l'utilisateur de se redecrire.
+
+---
+
+## Agents 🔴 chauds — detection automatique sur domaine
+
+| Domaine detecte | Agent |
+|-----------------|-------|
+| VPS, Apache, Docker, SSL, vhost, certbot, deploy | `agents/vps.md` |
+| Mail, SMTP, IMAP, Stalwart, DNS, SPF, DKIM | `agents/mail.md` |
+| Review code, qualite, PR, validation avant prod | `agents/code-review.md` |
+| Securite, faille, JWT, OAuth, OWASP, secrets | `agents/security.md` |
+| Tests, Jest, Vitest, coverage, TDD | `agents/testing.md` |
+| Bug, erreur, crash, comportement inattendu | `agents/debug.md` |
+| Refacto, dette technique, DDD | `agents/refacto.md` |
+| CI/CD, pipeline, GitHub Actions, Gitea CI | `agents/ci-cd.md` |
+| Monitoring, Kuma, alerte, logs | `agents/monitoring.md` |
+| Perf backend, Node.js lent, memoire | `agents/optimizer-backend.md` |
+| Perf DB, MySQL lent, N+1, index, TypeORM | `agents/optimizer-db.md` |
+| Perf frontend, bundle, re-renders, React lent | `agents/optimizer-frontend.md` |
+| Process manager, pm2 | `agents/pm2.md` |
+| Migration TypeORM, schema | `agents/migration.md` |
+| Stack frontend, shadcn, Tailwind, UI libs | `agents/frontend-stack.md` |
+| i18n, traductions, cles manquantes | `agents/i18n.md` |
+| README, doc API, Swagger | `agents/doc.md` |
+
+Agents 🔵 stables → invocation manuelle uniquement. Index complet : `agents/AGENTS.md`
+Invocation explicite : "charge l'agent X" → lire `agents/X.md` immediatement.
+
+Convention /btw : message prefixe `/btw` → agent `aside` — reponse 2-3 lignes, capture todo si actionnable, retour session explicite (`→ on reprend.`)
+
+---
+
+## Regles critiques (non negociables)
+
+- Jamais de `Co-Authored-By` Claude dans les commits
+- Pas d'action destructive sans confirmation explicite
+- Ne jamais exposer secrets, tokens, cles privees
+- Fait non verifie → `Information manquante`
+- Incertitude → `Niveau de confiance: faible/moyen/eleve`

profil/anti-hallucination.md

@@ -0,0 +1,119 @@
+# Anti-hallucination — Règle fondamentale d'assertion
+
+> Décision architecturale — session 2026-03-13
+> Complémentaire de `context-hygiene.md` (chargement) et `memory-integrity.md` (écriture)
+
+---
+
+## Principe fondateur
+
+**`context-hygiene.md` governe ce qu'on CHARGE.**
+**`memory-integrity.md` governe ce qu'on ÉCRIT.**
+**`anti-hallucination.md` governe ce qu'on AFFIRME.**
+
+Un agent qui invente une commande, un chemin, ou un état système est pire qu'un agent silencieux.
+L'incertitude explicite est une feature. L'invention silencieuse est un bug critique.
+
+---
+
+## Règles globales — applicables à tous les agents
+
+### R1 — Information manquante
+
+Si une information n'est pas dans les sources chargées de l'agent :
+
+```
+"Information manquante — vérifier dans <source>"
+```
+
+Jamais deviner. Jamais extrapoler. Toujours nommer la source où chercher.
+
+### R2 — Niveau de confiance
+
+Si une affirmation est incertaine ou partiellement couverte par les sources :
+
+```
+Niveau de confiance: faible    → déduit, non confirmé en conditions réelles
+Niveau de confiance: moyen     → plausible, à valider avant d'agir
+Niveau de confiance: élevé     → ancré dans les sources, testé ou documenté
+```
+
+Toujours explicite. Jamais omis quand la confiance est faible.
+
+### R3 — Étiquettes d'assertion
+
+| Étiquette | Signification | Usage |
+|-----------|--------------|-------|
+| `[CONFIRMÉ]` | Observé en conditions réelles — test effectué, output capturé | Fait établi |
+| `[HYPOTHÈSE]` | Déduit par lecture sans test réel | À valider avant d'agir |
+| `[OBSOLÈTE]` | Information ancienne — source à revérifier | Ne pas utiliser sans vérification |
+
+Un fait non étiqueté = `[HYPOTHÈSE]` implicite si non ancré dans une source.
+
+### R4 — Ce qu'un agent ne doit jamais inventer
+
+```
+❌ Commandes shell (flags, options, syntaxe)
+❌ Chemins de fichiers non documentés dans le brain
+❌ Ports, IPs, URLs de services
+❌ Valeurs de configuration (variables d'env, timeouts, limites)
+❌ État d'un système non vérifié (container running, service up, migration done)
+❌ Contenu d'un fichier non lu dans la session
+```
+
+Pour chacun : si non disponible dans les sources → R1 (Information manquante).
+
+### R5 — Avant d'affirmer, vérifier la source
+
+Tout fait affirmé par un agent doit être ancré dans :
+- Un fichier listé dans ses `## Sources à charger au démarrage` ou `## Sources conditionnelles`
+- Un output capturé dans la session (commande exécutée, fichier lu)
+- Une décision documentée dans le brain avec sa date
+
+Si aucune source → R1 ou R3 `[HYPOTHÈSE]`.
+
+---
+
+## Ce que chaque agent conserve dans `## Anti-hallucination`
+
+La section `## Anti-hallucination` d'un agent ne doit contenir **que les règles domaine-spécifiques** — ce que cet agent en particulier ne doit jamais inventer ou affirmer sans source.
+
+**Exemples :**
+```
+vps        → jamais inventer un port ou chemin de container non documenté dans vps.md
+pm2        → jamais inventer un chemin de projet, toujours afficher la commande pm2 startup générée
+security   → jamais affirmer qu'un système est sécurisé sans audit complet des sources
+migration  → jamais affirmer qu'une migration est safe sans avoir lu le fichier de migration
+```
+
+Les règles globales (R1-R5) **ne sont pas répétées** dans les agents — elles sont ici.
+
+---
+
+## Chargement conditionnel
+
+Ce fichier n'est pas chargé au démarrage. Il est chargé sur trigger :
+
+| Agent | Trigger | Pourquoi |
+|-------|---------|----------|
+| `agent-review` | Au démarrage | Grille de review : vérifier que chaque agent applique R1-R5 |
+| Tout agent | Avant une affirmation à risque | Rappel des règles avant d'affirmer un état système |
+| `recruiter` | Quand il forge un agent | S'assurer que le nouvel agent a une section Anti-hallucination domaine-spécifique |
+
+---
+
+## Application au double `## Anti-hallucination` détecté
+
+Certains agents (ex: `pm2`) ont deux sections Anti-hallucination suite à des patches successifs.
+Lors de la prochaine session dédiée :
+- Fusionner les deux sections
+- Supprimer tout ce qui est couvert par R1-R5 ici
+- Ne garder que les règles domaine-spécifiques
+
+---
+
+## Changelog
+
+| Date | Changement |
+|------|------------|
+| 2026-03-13 | Création — émergé des patches agent-review, centralise R1-R5, libère les agents des répétitions globales |

profil/bsi-spec.md

@@ -0,0 +1,190 @@
+# BSI — Brain Session Index
+
+> Spécification complète — version 1.0
+> Rédigée : 2026-03-14
+> Registre live : `brain/BRAIN-INDEX.md`
+
+---
+
+## Problème résolu
+
+Plusieurs sessions brain en parallèle (machine locale + VPS + autre machine) peuvent modifier les mêmes fichiers sans se voir. Résultat : conflits git, perte d'information, incohérences.
+
+Le BSI ne résout pas les conflits git — git le fait déjà. Il **prévient les collisions** en rendant les sessions visibles les unes des autres avant qu'elles modifient les mêmes fichiers.
+
+---
+
+## Stratégie : locking optimiste + TTL
+
+**Pourquoi optimiste ?**
+Le locking pessimiste (bloquer avant de lire) est trop coûteux sur un usage solo/semi-parallèle. La vraie collision est rare. On détecte et alerte — on ne bloque pas.
+
+**Pourquoi TTL ?**
+Une session crashée ou oubliée ne doit pas bloquer les autres indéfiniment. Le TTL la marque `stale` après expiration — l'humain décide de la libérer.
+
+```
+Optimiste = lire libre, déclarer son intention, détecter les overlaps
+TTL       = deadline automatique, jamais auto-release sur action destructive
+```
+
+---
+
+## Granularité multi-niveau
+
+```
+global              → tout le brain (ex: migration structurelle)
+  └── dir/          → un dossier (ex: agents/, projets/)
+       └── file.md  → un fichier spécifique
+            └── ## Section → une section nommée dans un fichier
+```
+
+**Règle de conflit :** scope A ∩ scope B ≠ ∅ → conflit.
+- Deux sessions sur le même fichier = conflit direct
+- Une session sur un fichier dans un dossier déjà claimé = conflit parent/enfant
+- Deux sessions sur des sections différentes du même fichier = **pas** de conflit (granularité section)
+
+---
+
+## Format Session ID
+
+```
+sess-YYYYMMDD-HHMM-<slug>
+```
+
+- `YYYYMMDD-HHMM` — date + heure locale d'ouverture (tri chronologique)
+- `<slug>` — 4 chars alphanumériques aléatoires (évite les collisions à la même minute)
+
+Exemples :
+```
+sess-20260314-0930-a3f9
+sess-20260314-1045-bx2k
+sess-20260315-1400-zr8p
+```
+
+---
+
+## TTL par défaut
+
+| Type de session | TTL |
+|-----------------|-----|
+| Session courte (fix, lecture) | 2h |
+| Session deep work | 4h |
+| Session longue (archi, migration) | 8h |
+| Maximum absolu | 8h |
+
+> Le scribe choisit le TTL selon le contexte annoncé. L'utilisateur peut demander un TTL custom.
+> Au-delà de 8h : le claim passe `stale` automatiquement, même si la session est active.
+
+---
+
+## États d'un claim
+
+| État | Signification | Transition |
+|------|--------------|------------|
+| `active` | Session en cours, scope déclaré | → `stale` (TTL expiré) ou → supprimé (fermé proprement) |
+| `stale` | TTL expiré, session probablement morte | → supprimé (après contrôle humain) |
+
+> `released` n'est pas un état visible — un claim fermé est simplement retiré de `## Claims actifs` et déplacé dans `## Historique`.
+
+---
+
+## Workflow scribe — lifecycle complet
+
+### Ouvrir un claim
+
+```
+1. Générer session ID : sess-YYYYMMDD-HHMM-<slug>
+2. Identifier le niveau : global / dir / file / section
+3. Choisir TTL selon contexte (défaut : +2h)
+4. Scanner BRAIN-INDEX.md ## Claims actifs
+5. Vérifier conflit (scope A ∩ scope B ≠ ∅)
+   → Conflit détecté : alerter humain, NE PAS créer le claim
+   → Pas de conflit : continuer
+6. Ajouter ligne dans ## Claims actifs
+7. Confirmer : "Claim ouvert — [scope] / expire [TTL]"
+```
+
+### Fermer un claim
+
+```
+1. Identifier session ID (annoncé par l'utilisateur ou inféré du contexte)
+2. Retirer de ## Claims actifs
+3. Ajouter dans ## Historique : session, scope, ouvert, fermé, statut=completed
+4. Confirmer : "Claim fermé — [session ID]"
+```
+
+### Watchdog (début de chaque session)
+
+```
+1. Lire ## Claims actifs
+2. Pour chaque claim : comparer "Expire le" avec l'heure actuelle
+3. Si expiré :
+   → Déplacer vers ## Claims stale — contrôle requis
+   → Annoter "Raison probable : TTL expiré sans fermeture"
+4. Reporter : "[N] claims actifs, [M] stale détectés"
+   → Si stale > 0 : demander action humaine avant de continuer
+```
+
+### Détecter un conflit
+
+```
+Nouveau claim sur scope B, claim existant sur scope A :
+  - Si A == B → conflit direct
+  - Si B est enfant de A (B dans le dossier A) → conflit parent/enfant
+  - Si A est enfant de B → conflit parent/enfant
+  - Si A et B sont des sections différentes du même fichier → pas de conflit
+
+Action : alerter, ne pas créer. Proposer scope alternatif si possible.
+```
+
+---
+
+## Quand ouvrir un claim
+
+Ouvrir un claim uniquement si la session **va modifier** des fichiers brain. La lecture pure ne nécessite pas de claim.
+
+| Intention de session | Claim ? | Niveau conseillé |
+|---------------------|---------|-----------------|
+| Lire uniquement | Non | — |
+| Modifier 1 fichier précis | Oui | file |
+| Modifier un domaine entier | Oui | dir |
+| Migration / restructuration brain | Oui | global |
+| Session brainstorm (pas d'écriture prévue) | Non | — |
+
+---
+
+## Règles absolues
+
+1. **Jamais auto-release** sur action destructive — l'humain valide toujours
+2. **Conflit détecté → alerte humain**, pas résolution silencieuse
+3. **Stale ≠ libéré** — TTL expiré = stale, pas free. L'humain confirme avant suppression
+4. **Scribe seul** écrit dans BRAIN-INDEX.md — jamais éditer manuellement
+5. **8h maximum** — au-delà, tout claim passe stale sans exception
+
+---
+
+## Intégration git
+
+Le BSI est **complémentaire à git, pas redondant.**
+
+- Git résout les conflits après coup (merge, rebase)
+- BSI prévient les collisions avant qu'elles arrivent
+- `git blame BRAIN-INDEX.md` = audit trail complet des sessions
+
+Le git log de BRAIN-INDEX.md EST le journal des sessions brain. Chaque commit scribe = entrée d'audit.
+
+---
+
+## Limite connue — version 1.0
+
+Le BSI v1 est **déclaratif et manuel** — le scribe déclare un claim sur signal de l'utilisateur. Il n'y a pas de vérification automatique que la session a bien modifié uniquement le scope déclaré.
+
+**Prochaine frontière (v2) :** vérification post-session via `git diff` — le scribe compare les fichiers modifiés au scope déclaré et signale les débordements.
+
+---
+
+## Changelog
+
+| Date | Version | Changement |
+|------|---------|------------|
+| 2026-03-14 | 1.0 | Création — optimiste + TTL, 4 niveaux, workflow scribe complet |

profil/collaboration.md.example

@@ -0,0 +1,112 @@
+# Collaboration avec Claude
+# Copier vers profil/collaboration.md et personnaliser
+
+> Ce fichier définit comment travailler efficacement avec l'IA.
+> Remplir les sections marquées <A_PERSONNALISER>.
+
+---
+
+## Vocabulaire partagé
+
+| Terme | Désigne |
+|-------|---------|
+| **le brain** | `<BRAIN_ROOT>` — repo `brain` sur `<GITEA_URL>` |
+| **le toolkit** | `<BRAIN_ROOT>/toolkit/` — repo `toolkit` |
+| **les docs** | un fichier spécifique dans le brain |
+| **le focus** | `focus.md` dans le brain |
+
+---
+
+## Règles de base
+
+- **Langue :** <LANGUE> — ton <TON> (ex: direct, technique, pédagogique)
+- **Priorité :** fiabilité > vitesse > style
+- **Lire avant de modifier.** Implémenter, vérifier, puis rendre compte.
+
+## Règle d'or
+
+**Efficacité avant tout.** Réponse rapide + explication courte si nécessaire. Jamais de roman.
+
+---
+
+## Explications pédagogiques
+
+- **Oui** : concept nouveau, complexe ou non trivial
+- **Non** : faute de frappe, erreur d'inattention, concept basique → juste le code corrigé
+- Toujours expliquer le *pourquoi*, pas seulement le *quoi*
+
+---
+
+## Vigilance code (non négociable)
+
+Par ordre de priorité :
+
+1. **Sécurité** — failles, injections, exposition de secrets, mauvaise gestion des tokens
+2. **Edge cases** — entrées inattendues, états limites, cas non couverts
+3. **Performance** — boucles inutiles, N+1, fuites mémoire, requêtes inefficaces
+4. **Async & erreurs** — gestion correcte des promesses, try/catch, rejets non gérés
+5. **Typage** — code bien typé, pas de `any` sauvage
+6. **Clean code** — lisible, maintenable, bonnes pratiques du langage utilisé
+7. **Obsolescence** — signaler les méthodes/patterns dépréciés avec explication
+
+---
+
+## Périmètre d'intervention
+
+- Rester strictement dans le périmètre demandé
+- Si une anomalie critique est détectée hors périmètre : **une phrase courte à la fin**
+- Ne jamais refactoriser hors périmètre sans accord explicite
+
+---
+
+## Commits & PRs
+
+- Proposer un message de commit uniquement à la fin d'un **bloc logique important**
+- Pas de micro-commits
+- Jamais de `Co-Authored-By` Claude
+- Format : `type: description courte` (ex: `feat: add login form`)
+
+---
+
+## Convention /btw
+
+`/btw <question>` → parenthèse courte, jamais de dérive.
+
+- Réponse : **2-3 lignes max**
+- Si actionnable → `todo-scribe` capture en ⬜
+- Clôture explicite : `→ on reprend.`
+- Si la question est trop large → "nécessite une session dédiée" + capture en todo
+
+Agent : `brain/agents/aside.md` — déclenché automatiquement sur le préfixe `/btw`.
+
+---
+
+## Comportements interdits
+
+- **Boucle d'échecs** : si on tourne en rond sans progresser → signaler, prendre du recul
+- **Excuses à rallonge** : en cas d'erreur → correction. Pas de paragraphe d'excuses
+- **Réécriture complète inutile** : si 3 lignes changent dans un fichier de 500, donner uniquement le bloc
+
+---
+
+## Gitea — Réflexe à avoir
+
+Proposer Gitea de façon proactive :
+- Nouveau projet ou expérimentation → repo privé Gitea
+- Code sensible → Gitea plutôt que GitHub
+- Nouveaux templates réutilisables → les ajouter dans `toolkit` systématiquement
+
+---
+
+## Check-ins
+
+Demander l'avis à des moments clés :
+- Fin d'une étape importante
+- Avant une décision d'architecture
+- Si on tourne en rond sur un bug
+
+---
+
+## <A_PERSONNALISER — sections spécifiques à ton usage>
+
+<!-- Ajouter ici tes règles spécifiques : stack préférée, contexte métier, etc. -->

profil/context-hygiene.md

@@ -0,0 +1,103 @@
+# Context Hygiene — Règle fondamentale du brain
+
+> Décision architecturale — session 2026-03-13
+> Voir aussi `brain/profil/memory-architecture.md` — les trois pilliers (TTL, Sectionnarisation, Stratification)
+
+---
+
+## Règle dure
+
+**Jamais charger tout le système au démarrage. Jamais.**
+
+Le brain est conçu pour un chargement sélectif et progressif.
+Charger tous les agents en début de session = dilution de l'attention + tokens gaspillés + réponses moins précises.
+
+---
+
+## Ce qui est chargé au démarrage — toujours
+
+| Fichier | Taille cible | Pourquoi universel |
+|---------|-------------|-------------------|
+| `CLAUDE.md` | < 100 lignes | Bootstrap — instructions globales |
+| `focus.md` | < 120 lignes | État actuel des projets |
+| `profil/collaboration.md` | < 100 lignes | Comment travailler ensemble |
+| `agents/coach.md` | < 220 lignes | Présence permanente — observation en arrière-plan |
+
+**Total cible démarrage : < 500 lignes (~8-10k tokens). Jamais dépasser.**
+
+---
+
+## Ce qui est chargé sur détection — jamais au démarrage
+
+| Déclencheur | Ce qui est chargé |
+|-------------|------------------|
+| Domaine technique détecté | Agent métier correspondant (1-2 max) |
+| Session prod / infra | `profil/objectifs.md` + agent vps ou ci-cd |
+| Fin de session avec patterns | `agents/toolkit-scribe.md` |
+| Fin de session avec bilan | `agents/coach-scribe.md` |
+| Ambiguïté de scope | `agents/interprete.md` |
+| Multi-domaines | `agents/orchestrator.md` → il délègue |
+
+---
+
+## Libération de contexte
+
+Quand un domaine de travail est terminé dans la session, ses agents peuvent être libérés :
+
+```
+→ "on passe à autre chose" = l'agent précédent n'est plus actif
+→ Charger le nouvel agent, ne pas cumuler sans raison
+```
+
+Le modèle n'oublie pas ce qui a été dit — mais moins de "présence permanente" d'agents
+inutiles = meilleure précision sur le domaine actif.
+
+---
+
+## Cycle de vie d'un agent — 3 états
+
+| État | Condition | Comportement |
+|------|-----------|--------------|
+| **Actif** | Domaine en cours d'acquisition | Chargé sur détection, intervient |
+| **Stable** | Domaine maîtrisé — peu ou pas d'interventions en session | Disponible sur demande, plus chargé automatiquement |
+| **Retraité / Collègue** | Domaine acquis — signal de graduation explicite | Référence ponctuelle, ne coache plus, ne persiste plus |
+
+**Signal de graduation :** plusieurs sessions consécutives sans intervention de l'agent = domaine acquis.
+Le documenter dans `progression/milestones/`.
+
+---
+
+## Règle de taille des fichiers
+
+Pour que le système reste viable sur la durée :
+
+| Fichier | Taille max recommandée |
+|---------|----------------------|
+| Agent standard | 200 lignes |
+| Fichiers profil (collaboration, objectifs) | 100 lignes |
+| focus.md | 120 lignes |
+| CLAUDE.md | 100 lignes (bootstrap only) |
+| Fichier toolkit pattern | 60 lignes |
+
+Si un fichier dépasse → le scribe compétent le compresse à la prochaine session dédiée.
+
+---
+
+## Application au coach — exemple concret
+
+| Phase | État coach | État coach-scribe |
+|-------|-----------|-----------------|
+| Junior actif (maintenant) | Actif — observe, intervient, rapporte | Actif — écrit journal/skills/milestones |
+| Système stable | Stable — chargé sur demande uniquement | En veille — plus de journal actif |
+| Senior / Collègue | Retraité → pair technique, référence | Archivé — `progression/` en lecture seule |
+
+Le coach devient collègue quand il n'a plus rien à corriger.
+C'est le meilleur signal de progression possible.
+
+---
+
+## Changelog
+
+| Date | Changement |
+|------|------------|
+| 2026-03-13 | Création — cycle de vie agents, règle démarrage minimal, libération contexte |

profil/memory-architecture.md

@@ -0,0 +1,120 @@
+# Memory Architecture — Les trois pilliers du brain
+
+> Décision architecturale fondatrice — session 2026-03-13
+> Complète `context-hygiene.md` (chargement) et `memory-integrity.md` (écriture)
+
+---
+
+## Principe fondateur
+
+Un système de mémoire qui ne se gangrène pas repose sur trois pilliers.
+Sans eux, le brain sature lentement, de l'intérieur, sans signal d'alarme visible.
+
+---
+
+## Pillier 1 — TTL (Time To Live)
+
+Toute information a un cycle de vie. Ce qui est terminé doit mourir ou être archivé.
+Un cerveau qui retient tout ce qui est résolu est un cerveau qui se bouche.
+
+| État | Action | Délai | Responsable |
+|------|--------|-------|-------------|
+| Todo ✅ complété | Archivé dans `todo/archive/<projet>.md` | Session suivante | `todo-scribe` |
+| `## État courant` d'un projet | Réécrit à chaque milestone | Immédiat | `scribe` |
+| Fichier projet > 150 lignes | Compressé — historique → `## Historique` | Sur détection | `scribe` |
+| Agent 🧪 jamais testé après 30 sessions | Signalé candidat archivage | Sur audit `agent-review` | `agent-review` |
+
+> **Signal d'alarme :** un fichier qui dépasse sa taille cible sans nouvelles décisions = mémoire morte. Le scribe le compresse.
+
+---
+
+## Pillier 2 — Sectionnarisation
+
+Un fichier n'est pas une unité atomique — une **section** l'est.
+
+Chaque fichier déclare ses sections par volatilité. Un agent charge la section dont il a besoin, pas le fichier entier. C'est le principe de la RAM : tu pages ce qui est actif, pas le disque entier.
+
+### Niveaux de volatilité
+
+| Niveau | Label | Mise à jour | Chargement |
+|--------|-------|-------------|------------|
+| 🔴 Chaud | `## État courant` | Chaque session projet | Systématique — toujours en premier |
+| 🟡 Tiède | `## Opérationnel` | Sur changement infra/deploy | Sur trigger deploy ou debug |
+| 🔵 Froid | `## Architecture` | Sur refacto majeure uniquement | Sur trigger technique |
+| ⚫ Archivé | `## Historique` | Jamais — lecture seule | Sur demande explicite uniquement |
+
+### Template obligatoire — `projets/<X>.md`
+
+```markdown
+## État courant
+<!-- 🔴 CHAUD — mis à jour à chaque session, état présent, en cours -->
+
+## Opérationnel
+<!-- 🟡 TIÈDE — container, env VPS, URLs, deploy, checklist -->
+
+## Architecture
+<!-- 🔵 FROID — stack, structure fichiers, fonctionnalités -->
+
+## Historique
+<!-- ⚫ ARCHIVÉ — décisions passées, bugs résolus, milestones -->
+```
+
+### Réflexe universel
+
+Ce principe s'applique à **tout fichier du brain**, pas seulement les projets.
+Avant d'écrire un fichier : identifier la volatilité de chaque bloc. Le placer au bon niveau.
+Les agents chargent par section, pas par fichier entier.
+
+---
+
+## Pillier 3 — Stratification Chaud/Froid
+
+Chaque élément du système (agent, fichier, pattern) existe sur un spectre de température.
+Un index isotherme (tout au même niveau) est un vecteur de saturation garanti.
+
+| Température | Définition | Comportement |
+|-------------|------------|--------------|
+| 🔴 Chaud | Accédé plusieurs fois par semaine | Auto-chargé sur détection domaine |
+| 🔵 Froid | Accédé rarement | Invocation manuelle uniquement |
+| ⚫ Archivé | Plus actif — obsolète ou graduation | Référence uniquement, jamais chargé |
+
+**Application directe :** `AGENTS.md` est splitté en **Actifs** (auto-détectés) / **Stables** (invocation manuelle). L'index reste lisible et fonctionnel à 50+ agents.
+
+---
+
+## Procédure de reprise de projet
+
+> La sectionnarisation rend possible la reprise rapide après une période de standby.
+> Un projet peut dormir 6 mois. La reprise prend 3 échanges au lieu de 20.
+
+```
+1. Charger ## État courant     → où on en est, ce qui est en cours
+2. Charger ## Opérationnel     → contexte technique actif (env, container, URLs)
+3. Définir le scope de session → ce qu'on touche / ce qu'on ne touche pas
+4. Charger les agents 🔴 chauds nécessaires → seulement ceux du scope défini
+```
+
+**Règle :** ne jamais charger `## Architecture` ou `## Historique` au démarrage d'une reprise.
+Les charger uniquement si le scope de session l'exige (refacto, bug architectural...).
+
+**Signal de reprise saine :** en 3 échanges, le contexte est posé et le travail peut commencer.
+Si ça prend plus — l'`## État courant` n'est pas à jour. Le mettre à jour avant de continuer.
+
+---
+
+## Qui charge ce fichier
+
+| Agent | Quand |
+|-------|-------|
+| `scribe` | Avant d'écrire dans un fichier projet |
+| `todo-scribe` | Sur archivage todo ✅ |
+| `recruiter` | Avant de forger un nouvel agent |
+| `brainstorm` | Sur décision d'architecture brain |
+
+---
+
+## Changelog
+
+| Date | Changement |
+|------|------------|
+| 2026-03-13 | Création — émergé du brainstorm memory/context. Trois pilliers : TTL, Sectionnarisation, Stratification |

profil/memory-integrity.md

@@ -0,0 +1,126 @@
+# Memory Integrity — Règle fondamentale d'écriture
+
+> Décision architecturale — session 2026-03-13
+> Complémentaire de `context-hygiene.md` (chargement) et `scribe-pattern.md` (qui écrit quoi)
+
+---
+
+## Principe fondateur
+
+**`context-hygiene.md` governe ce qu'on CHARGE.**
+**`memory-integrity.md` governe ce qu'on ÉCRIT.**
+
+Un système dont la mémoire est corrompue est pire qu'un système sans mémoire.
+Chaque entrée mémoire doit être atomique, attribuable, et réversible.
+
+---
+
+## Règle dure — Un commit = un agent = un scope
+
+```
+❌ Un commit qui touche brain/ + progression/ + toolkit/
+   → impossible de savoir quel agent a écrit quoi
+   → impossible de réverter un seul agent sans tout défaire
+
+✅ Un commit par repo, par agent, par action
+   → git blame = audit complet de provenance
+   → réverter = chirurgical, sans dommage collatéral
+```
+
+---
+
+## Déclaration de scope — obligatoire pour tout agent écrivant
+
+Tout agent qui écrit dans le brain, le toolkit ou la progression doit déclarer explicitement :
+
+```markdown
+## Écrit où
+
+| Repo | Fichiers cibles | Jamais ailleurs |
+|------|----------------|-----------------|
+| `brain/` | `focus.md`, `projets/<X>.md` | Pas `toolkit/`, pas `progression/` |
+```
+
+Sans cette déclaration → scope indéfini → dérive mémoire garantie.
+
+---
+
+## Chargement conditionnel — mémoire sélective
+
+Un agent n'a pas besoin de tout savoir au démarrage.
+Il charge ce dont il a besoin **au moment exact où il en a besoin**.
+
+```
+Trigger : "je m'apprête à écrire"
+  → charger brain/profil/memory-integrity.md
+  → vérifier : est-ce que ce fichier est dans mon scope déclaré ?
+  → OUI → écrire
+  → NON → signal "hors scope — déléguer à <agent compétent>"
+```
+
+Ce pattern s'applique à tout fichier de référence qui n'est utile qu'à un moment précis — pas à toute la session.
+
+---
+
+## Validation avant commit — checklist git-analyst
+
+Avant tout commit, valider :
+
+```
+□ Chaque fichier modifié appartient au scope déclaré de l'agent qui l'a écrit
+□ Un seul repo par commit (brain/ OU progression/ OU toolkit/)
+□ CLAUDE.md modifié → ENTRYPOINT.md + CLAUDE.md.example mis à jour
+□ Nouvel agent créé → AGENTS.md + CLAUDE.md + ENTRYPOINT.md mis à jour
+□ Aucune entrée mémoire inventée — tout ce qui est écrit est prouvé ou signalé
+```
+
+---
+
+## Empoisonnement mémoire — comment ça arrive
+
+```
+Agent hallucine → écrit une fausse info → commitée sans validation
+  → la fausse info devient "vérité" dans le brain
+  → les sessions suivantes se basent dessus
+  → l'erreur se propage et se calcifie
+
+Défenses :
+1. Anti-hallucination dans chaque agent (niveau de confiance explicite)
+2. Validation scope avant commit (git-analyst)
+3. Commits atomiques (réversibilité chirurgicale si erreur détectée)
+```
+
+---
+
+## Architecture des repos — frontières d'identité
+
+| Repo | Nature | Exportable | Contenu |
+|------|--------|-----------|---------|
+| `toolkit/` | Universel | ✅ tel quel | Patterns validés en prod |
+| `brain/agents/` | Universel | ✅ tel quel | Agents spécialisés |
+| `brain/todo/` | Mixte | ⚠️ partiel | brain.md universel, projets personnels |
+| `brain/profil/` | Personnel | ❌ strippé | Identité, objectifs, capital |
+| `brain/projets/` | Personnel | ❌ strippé | Projets spécifiques |
+| `progression/` | Personnel | ❌ jamais | Journal, skills, milestones |
+
+Cette séparation est intentionnelle — elle rend le `claude-brain-template` générable par suppression des couches personnelles.
+
+---
+
+## Qui charge ce fichier
+
+| Agent | Quand | Trigger |
+|-------|-------|---------|
+| `git-analyst` | Au démarrage | Toujours — c'est sa grille de validation |
+| `recruiter` | Sur trigger | Quand il forge un agent qui écrit |
+| `agent-review` | Sur trigger | Critère de review : "scope déclaré ?" |
+
+Les scribes **n'ont pas besoin de charger ce fichier** — ils l'appliquent via leur section `## Écrit où`. Le principe vit dans leur structure.
+
+---
+
+## Changelog
+
+| Date | Changement |
+|------|------------|
+| 2026-03-13 | Création — émergé de la réflexion commit granulaire + mémoire sélective |

profil/scribe-pattern.md

@@ -0,0 +1,76 @@
+# Scribe Pattern — Idéologie du brain
+
+> Décision architecturale — session 2026-03-13
+
+---
+
+## Principe fondateur
+
+**Les agents métier produisent. Les scribes persistent.**
+
+Aucun agent métier n'écrit dans le brain, le toolkit ou la progression.
+Il signale. Le scribe compétent écrit.
+
+Séparation nette des responsabilités :
+- Agent métier : expertise domaine, diagnostic, recommandations
+- Scribe : réception du signal, formatage, écriture dans le bon endroit
+
+---
+
+## Les trois domaines de connaissance durable
+
+| Scribe | Reçoit de | Écrit dans | Ce qu'il persiste |
+|--------|-----------|------------|-------------------|
+| `scribe` | Session entière | `brain/` | État projets, décisions infra, focus |
+| `toolkit-scribe` | Agents métier | `toolkit/` | Patterns validés en prod |
+| `coach-scribe` | `coach` | `progression/` | Journal, skills, milestones |
+
+---
+
+## Comment un agent signale à un scribe
+
+Signal minimal attendu en fin de session :
+
+```
+→ toolkit-scribe : [pattern] pm2 cluster mode — validé prod Super-OAuth 2026-03-13
+→ coach-scribe   : [bilan] pattern détecté — X compris, Y à revoir
+→ scribe         : [état] focus.md — SuperOAuth backend online, prochaine étape Apache
+```
+
+Le scribe ne reformule pas. Il structure et écrit tel quel.
+
+---
+
+## Règles absolues du Scribe Pattern
+
+1. **Un scribe ne juge pas.** Il ne décide pas si un pattern est bon — l'agent métier a déjà validé.
+2. **Un scribe ne commente pas.** Il ne coache pas, n'optimise pas, n'améliore pas.
+3. **Un scribe ne devine pas.** Signal ambigu → demande clarification avant d'écrire.
+4. **Un scribe ne modifie pas sans diff.** Entrée existante → proposer le diff explicite avant overwrite.
+5. **Un scribe sur domaine sensible (sécu, infra) signale avant de committer.**
+
+---
+
+## Pourquoi cette séparation ?
+
+Sans elle, les agents accumulent des responsabilités secondaires (écrire, formater, trouver le bon fichier) qui polluent leur rôle principal et créent des incohérences entre agents.
+
+Le toolkit et la progression sont des **ancres de confiance** — un agent chargé incorrect propage l'erreur à toute la session. Les scribes sont les seuls à y écrire, ce qui centralise le risque et simplifie l'audit.
+
+---
+
+## Extension future
+
+Si un nouveau domaine de connaissance durable émerge → créer un scribe dédié, pas étendre un agent existant.
+
+Candidats possibles (non créés) :
+- `security-ledger-scribe` — décisions de sécurité prises, patterns validés (ex: "CSRF token rotation — adopté")
+- Seulement si le volume justifie un scribe distinct du toolkit
+
+---
+
+## Changelog
+
+| Date | Changement |
+|------|------------|
+| 2026-03-13 | Création — émergé de la session forge toolkit-scribe + coach-scribe |

profil/scribe-system.md

@@ -0,0 +1,112 @@
+# Scribe System — Cartographie officielle du Scribe Pattern
+
+> Décision architecturale — session 2026-03-13
+> Complémentaire de `memory-integrity.md` (règles d'écriture) et `context-hygiene.md` (chargement)
+
+---
+
+## Le Scribe Pattern
+
+**Règle dure — un agent métier n'écrit jamais directement dans le brain.**
+
+```
+Agent métier (vps, ci-cd, debug...)
+  → observe, produit, détecte
+  → signale au scribe compétent
+  → le scribe écrit, commite, maintient
+
+Jamais : agent métier → write directement
+Toujours : agent métier → signal → scribe compétent → write
+```
+
+Pourquoi : un agent qui écrit directement = scope indéfini = dérive mémoire garantie.
+Le scribe est le seul responsable de la cohérence de son repo.
+
+---
+
+## Carte des 6 scribes
+
+| Scribe | Écrit où | Repo | Couche | Exportable | Cycle de vie |
+|--------|----------|------|--------|------------|-------------|
+| `scribe` | `focus.md`, `projets/`, `infrastructure/`, `agents/AGENTS.md`, `profil/objectifs.md` | `brain/` | Universel | ✅ | Permanent |
+| `todo-scribe` | `todo/` | `brain/` (→ `todo/` futur) | Universel | ✅ structure | Stable quand todo en régime |
+| `toolkit-scribe` | `toolkit/` | `toolkit/` | Universel | ✅ | Actif tant que nouveaux patterns |
+| `git-analyst` | Commits git (narration sémantique) | Tous repos | Universel | ✅ | Ponctuel — invoqué sur demande |
+| `coach-scribe` | `journal/`, `skills/`, `milestones/` | `progression/` | Personnel | ❌ | Suit le coach — retraité ensemble |
+| `capital-scribe` | `profil/capital.md` | `brain/` | Personnel | ❌ strippé | Suit objectifs — veille quand CV stabilisé |
+
+> `helloWorld` et `coach` ne sont **pas** des scribes — ils observent et rapportent, jamais n'écrivent.
+
+---
+
+## Ordre canonique de fin de session
+
+Quand plusieurs scribes écrivent dans la même session :
+
+```
+1. todo-scribe    → commit brain/  "todo(<domaine>): <intention>"
+2. capital-scribe → commit brain/  "feat(capital): <milestone>"     si signal reçu
+3. scribe         → commit brain/  "feat(brain): <bilan session>"    toujours en dernier sur brain/
+4. toolkit-scribe → commit toolkit/ "feat(toolkit): <pattern>"       si signal reçu
+5. coach-scribe   → commit progression/ "feat(progression): <bilan>" si session coach
+6. git-analyst    → valide cohérence sémantique des commits           optionnel
+```
+
+**Règle :** `scribe` est toujours le dernier à commiter sur `brain/` — il a la vue complète de ce que les autres ont écrit.
+
+**Un commit = un scribe = un repo.** Voir `memory-integrity.md`.
+
+---
+
+## Comment un agent métier signale
+
+Format standard de signal en fin d'action :
+
+```
+→ Signal scribe : <ce qui a changé> dans <fichier cible>
+  Ex: "Signal scribe : nouveau container openclaw ajouté — mettre à jour brain/infrastructure/vps.md"
+
+→ Signal todo-scribe : <intention de session future>
+  Ex: "Signal todo-scribe : ⬜ configurer monitoring pour openclaw"
+
+→ Signal toolkit-scribe : <pattern validé en prod>
+  Ex: "Signal toolkit-scribe : pattern vhost reverse proxy validé — candidat toolkit/apache/"
+```
+
+Le scribe reçoit le signal en fin de session et écrit. Il ne demande pas — il déduit du signal.
+
+---
+
+## Chargement conditionnel
+
+Ce fichier est chargé sur trigger — jamais au démarrage.
+
+| Agent | Trigger | Pourquoi |
+|-------|---------|----------|
+| `scribe` | Au démarrage | Connaître ses pairs scribes et l'ordre de commit |
+| `recruiter` | Quand il forge un agent qui écrit | Vérifier la déclaration `## Écrit où` |
+| `agent-review` | Review d'un scribe | Grille : scope déclaré ? ordre respecté ? |
+| Tout agent métier | Avant de signaler | Savoir à quel scribe déléguer |
+
+---
+
+## Séparation universel / personnel — export
+
+```
+Template public (claude-brain-template) :
+  ✅ scribe, todo-scribe, toolkit-scribe, git-analyst
+
+Couche personnelle (strippée à l'export) :
+  ❌ coach-scribe, capital-scribe
+  ❌ progression/, profil/capital.md
+```
+
+Quelqu'un qui fork récupère le moteur d'écriture. Pas le cerveau, pas la progression, pas le CV.
+
+---
+
+## Changelog
+
+| Date | Changement |
+|------|------------|
+| 2026-03-13 | Création — émergé de la session agent-review + architecture multi-repos + Scribe Pattern |