Le remounting (/loadbundle) & Récupérer l'état mental

Le remounting : /loadbundle et redémarrage à chaud

L’idée en une phrase

Le remounting consiste à faire /clear sur un agent saturé, puis à remonter dans l’agent neuf la trajectoire de la session précédente à partir de son Context Bundle (chapitre 12) : une commande custom, /loadbundle — un pattern à construire, pas une commande native de Claude Code —, injecte le bundle (~4 à 6k tokens) et cadre la reprise ; c’est du Reduce appliqué au redémarrage : on repart avec ~97 % de fenêtre libre au lieu de continuer à ~70 % d’occupation, ou de tout rejouer avec --resume.

Analogie : la relève de quart dans un service hospitalier. L’infirmière qui termine ne raconte pas ses douze heures : elle transmet, en cinq minutes et dans un ordre fixe, les patients suivis, ce qui a été fait, ce qui reste à surveiller. Celle qui arrive est reposée, attentive, et sait où reprendre ; ce qu’elle ignore encore, elle le retrouve dans le dossier au pied du lit. La relève fonctionne parce qu’elle est courte et structurée — un récit exhaustif de la nuit épuiserait la relève avant son premier soin.

Points clés

• Trois façons de repartir, trois coûts. --resume (ou --continue) recharge le transcript intégral : la fenêtre repart à ~140k tokens, avec l’attention déjà dégradée (chapitre 2). /compact fait rédiger un résumé par l’agent saturé lui-même, avec perte et sans contrôle sur ce qui survit (chapitre 10). /clear + /loadbundle repart d’un agent vierge et lui remonte une trajectoire choisie : ~4 à 6k tokens, soit ~2 à 3 % de la fenêtre.
• /loadbundle est une commande slash ordinaire, dans .claude/commands/loadbundle.md (ou en .claude/skills/loadbundle/SKILL.md, chapitre 5). Elle utilise l’injection dynamique ! pour insérer le bundle avant que l’agent ne lise quoi que ce soit, comme /prime injectait un instantané du dépôt. Le bundle arrive en une seule pièce : pas de Read à négocier, pas d’exploration.
• Le remounting commence par l’index. index.jsonl (chapitre 12) liste les sessions pour ~30 tokens chacune : la commande affiche les cinq dernières et charge la plus récente par défaut, ou celle passée en argument. Le bundle de la session courante — que le hook SessionStart vient d’ouvrir au /clear — est exclu : il est vide.
• Un redémarrage à chaud, pas une restauration. L’agent neuf ne retrouve pas la mémoire de son prédécesseur : il retrouve sa trajectoire (objectif, prompts, fichiers touchés, commandes lancées) et reconstruit le reste en rouvrant les 3 ou 4 fichiers utiles. Le disque n’a pas changé ; le bundle dit où regarder.
• La consigne compte autant que les données. Après le bundle, la commande impose un protocole : résumer l’état compris en cinq lignes, lister ce qui est incertain, rouvrir uniquement les fichiers marqués modifiés, puis attendre l’objectif de reprise. Sans cette consigne, l’agent neuf relit tout ce que le bundle cite — et reconstruit la saturation qu’on vient d’évacuer.

Exemple concret

Reprise de la session du chapitre 12 : ~140 000 tokens d’occupation (~70 % de 200k), une hallucination sur un nom de fonction, un bundle de ~4 200 tokens sur disque. Option --resume : la fenêtre repart à ~140k, attention dégradée, et chaque nouveau tour coûte l’intégralité de cet historique en entrée. Option /compact : ~140k tokens lus par un agent déjà saturé pour produire un résumé de ~8k tokens dont on ne choisit pas le contenu. Option remounting : /clear (0 token), puis /loadbundle. La commande injecte l’index (5 lignes, ~150 tokens), le bundle (~4 200 tokens) et sa consigne (~250 tokens) : ~4 600 tokens, soit ~2,3 % de la fenêtre. L’agent neuf résume l’état en cinq lignes (~200 tokens), rouvre les 4 fichiers marqués Edit (~9 000 tokens) et annonce qu’il est prêt : ~14k tokens d’occupation, ~7 % de la fenêtre, contre ~70 % avant. Le nom de fonction halluciné disparaît : l’agent le relit dans le fichier, il ne le « souvient » pas.

Trois redémarrages — coût et qualité de l’attention

Critère	--resume	/compact	/clear + /loadbundle
Ce qui est rechargé	le transcript intégral	un résumé rédigé par l’agent saturé	la trajectoire triée du bundle
Occupation au redémarrage	~140k tokens (~70 %)	~8k tokens, après ~140k lus	~4,6k tokens (~2,3 %)
Qui choisit ce qui survit	personne — tout survit	l’agent saturé	l’auteur du hook (chapitre 12)
Attention de l’agent au redémarrage	dégradée dès le premier tour	neuve, mais résumé avec perte non contrôlée	neuve, trajectoire exacte
Position sur l’axe R&D	aucune	Reduce (avec perte)	Reduce (perte choisie)

Commande — /loadbundle, le squelette

---
description: Remonte le Context Bundle d'une session precedente dans l'agent neuf
argument-hint: [session-id, ou vide pour la plus recente]
allowed-tools: Read
disable-model-invocation: true
---

# /loadbundle — remounting

## Sessions disponibles (index, ~30 tokens chacune)
!`tail -5 .claude/bundles/index.jsonl`

## Trajectoire remontee
!`ls -t .claude/bundles/*.jsonl | grep -v -e index.jsonl -e "${CLAUDE_SESSION_ID}" | head -1 | xargs cat`

## Consigne
Ce qui precede est la trajectoire de la session precedente — pas son contenu.
Ne relis rien pour l'instant : resume l'etat compris, puis attends l'objectif.

# Le POURQUOI : ${CLAUDE_SESSION_ID} est substitué par Claude Code avant l'exécution
# des lignes `!` — on exclut ainsi le bundle que SessionStart vient d'ouvrir au /clear,
# pour charger le précédent (le vrai). disable-model-invocation : c'est l'humain qui
# décide du remounting, jamais l'agent en cours de session.

Piège courant : « /loadbundle restaure la session, comme --resume mais en moins cher » est inexact — --resume restaure la conversation (tout ce que l’agent a lu et dit) ; /loadbundle remonte une trajectoire (ce que l’agent a voulu faire). Le premier redonne un agent qui sait tout et n’écoute plus ; le second, un agent qui écoute et sait où regarder. Ce ne sont pas deux qualités du même service : c’est un choix entre continuer une session saturée et en ouvrir une neuve, informée. Quand la session tenait à ~40 % de la fenêtre, --resume reste le bon outil ; à ~70 %, le remounting l’emporte.

---

Récupérer 60-70% de l’état mental d’un agent saturé

L’idée en une phrase

L’état mental d’un agent — ce qu’il comprend du problème à un instant donné — se décompose en une trajectoire (ce qu’il a fait), des observations (ce qu’il a lu) et des inférences (ce qu’il en a conclu) ; le bundle ne conserve que la première, le disque fournit la deuxième à la demande, la troisième est perdue — d’où un plafond de récupération de l’ordre de 60 à 70 %, que l’on atteint pour ~15k tokens et qu’il ne faut pas chercher à dépasser au prix de la fenêtre : c’est du Reduce assumé, une perte choisie contre une attention entière.

Analogie : une partie d’échecs ajournée. La feuille de partie donne tous les coups joués ; l’échiquier donne la position exacte. Ce qui manque au joueur qui reprend, c’est le calcul qu’il avait en tête au moment de l’ajournement — les trois variantes qu’il avait envisagées. Il les recalcule en quelques minutes à partir de la position, et parfois mieux qu’avant, l’esprit reposé. Rejouer les quarante coups pour retrouver ses pensées d’alors ne les ramènerait pas davantage.

Points clés

• Ce qui se récupère intégralement : la trajectoire. L’objectif, la suite des prompts, les fichiers lus et modifiés, les commandes lancées, les sous-agents appelés. C’est tout le bundle (~4k tokens) et c’est ~100 % fidèle : le hook l’a écrit au moment des faits, sans résumé.
• Ce qui se récupère à la demande : les observations. Le contenu des fichiers et la sortie des commandes ne sont pas dans le bundle mais sur disque, à jour. L’agent neuf en recharge une fraction — les fichiers modifiés d’abord, ~2 000 tokens chacun — au lieu des 45 fichiers de la session d’origine. C’est ici que le remounting rend son ~10k tokens, et pas plus.
• Ce qui est perdu : les inférences. Les hypothèses écartées, la cause soupçonnée du bug, l’ordre prévu des modifications, le résultat d’un test lu il y a deux heures. Rien de tout cela n’est sur disque ni dans le bundle. C’est le tiers manquant — et c’est la partie la plus dégradée par la saturation : l’agent à ~70 % d’occupation raisonnait déjà mal (chapitre 2).
• La perte se réduit en amont, pas en aval. Un agent qui écrit ses conclusions intermédiaires dans un fichier (notes/etat.md, un report.md) transforme des inférences en observations — récupérables. Quelques lignes tous les 10 tours suffisent ; le bundle en garde la trace comme n’importe quel Edit. On passe alors de ~65 % à ~80 % de récupération pour ~500 tokens de plus.
• Chercher 100 % est le contresens. Rejouer le transcript pour récupérer les inférences, c’est revenir à --resume : ~140k tokens, attention dégradée, hallucinations conservées. Les 30 % manquants coûtent 20 fois plus que les 70 % récupérés — et contiennent les erreurs qu’on voulait fuir.

Exemple concret

Décomposition de la session saturée de ~140 000 tokens : ~5 000 tokens de prompts et de réponses de l’agent, ~120 000 tokens de résultats d’outils (observations), ~15 000 tokens de raisonnement intermédiaire (inférences). Après remounting : la trajectoire revient en entier pour ~4 200 tokens ; les observations utiles — les 4 fichiers modifiés et le dernier résultat de test relancé — reviennent pour ~10 000 tokens ; les inférences ne reviennent pas, sauf les ~400 tokens que l’agent avait notés dans notes/etat.md. Bilan : ~14 600 tokens d’occupation (~7 %) pour un état mental estimé à ~65-70 % de l’original. L’agent neuf demande deux précisions (~150 tokens de prompt), relance la suite de tests (~1 500 tokens) et reprend le travail avec ~92 % de fenêtre libre. Le même niveau d’information par --resume aurait coûté ~140k tokens, dont ~120k d’observations périmées ou inutiles.

Les trois composantes de l’état mental — ce qui revient, à quel prix

Composante	Où elle vit après /clear	Récupération	Coût au remounting	Levier
Trajectoire (objectif, prompts, fichiers, commandes)	le bundle	~100 %	~4 000 tokens	tri du hook (chapitre 12)
Observations (contenu des fichiers, sorties)	le disque, à jour	à la demande, ~10-20 % suffisent	~10 000 tokens	rouvrir les fichiers Edit d’abord
Inférences (hypothèses, causes, plan)	nulle part	~0 %, sauf notes écrites	~0 à 500 tokens	noter l’état tous les 10 tours
Total	—	~60-70 %	~15k tokens (~7 %)	ne pas viser plus

Config — un bloc CLAUDE.md qui rend les inférences récupérables

# Etat de travail

Toutes les ~10 actions, ou avant toute étape risquée, mets à jour `notes/etat.md`
(5 lignes maximum) : objectif courant, hypothèse retenue, hypothèses écartées,
prochaine étape, ce qui reste incertain. Ce fichier est relu après un /clear.

# Le POURQUOI : ~500 tokens de notes transforment des inférences perdues en
# observations sur disque. Le bundle journalise chaque Edit de notes/etat.md,
# et /loadbundle les fait rouvrir en premier. Coût dans la fenêtre pendant la
# session : ~50 tokens par mise à jour — invisible au regard du gain à la reprise.

Piège courant : « l’agent neuf a lu le bundle, il en sait autant que l’ancien » est inexact — il en sait ~65 %, et le reste, il doit le reconstruire, non le deviner. Le risque n’est pas la perte : c’est un agent qui comble les 35 % manquants par des suppositions plausibles (« le test devait passer », « la cause était sûrement le cache ») au lieu de relire le fichier ou de relancer la commande. La consigne de /loadbundle demande explicitement de lister ce qui est incertain avant d’agir. Un remounting honnête commence par « voici ce que je ne sais plus ».

---

Fil rouge — Reduce ou Delegate ?

Ce chapitre clôt le cycle Reduce ouvert au chapitre 11 : les hooks ont sorti la trajectoire de la fenêtre (0 token pendant le travail), le tri du chapitre 12 l’a ramenée à ~4k tokens, et /loadbundle la remonte dans un agent neuf pour ~2,3 % de la fenêtre. Après rechargement ciblé des observations, l’agent travaille à ~7 % d’occupation au lieu de ~70 % — dix fois moins — avec une attention entière et sans les hallucinations de son prédécesseur. Le prix de ce Reduce est une perte choisie : les inférences, ~30 à 40 % de l’état mental, que l’on ne cherche pas à récupérer parce qu’elles coûtent 20 fois plus que le reste et qu’elles étaient déjà dégradées. Le niveau Expert change de plan : au lieu de remonter un agent après coup, il sortira l’humain de la boucle et fera tourner les agents en arrière-plan (chapitre 14).

---

---

Travaux pratiques

À chaque leçon, un petit artefact à déposer dans ton .claude/ — commande, sous-agent, hook, mémo… — pour te bâtir, au fil du livre, une boîte à outils de context engineering réutilisable.

Une commande maison — /loadbundle, le remounting complet

L’artefact du jour branche la commande de la fiche sur le hook context-bundle.sh du chapitre 12. Il injecte l’index (cinq dernières sessions), le bundle à remonter — le plus récent hors session courante par défaut, ou celui passé en argument — et un protocole de reprise en quatre temps qui interdit à l’agent neuf de tout relire. C’est du Reduce : ~4,6k tokens injectés pour retrouver une trajectoire qui en occupait ~140k, et une fenêtre à ~7 % après rechargement ciblé. À enregistrer dans .claude/commands/loadbundle.md.

---
description: Remonte le Context Bundle d'une session precedente dans l'agent neuf (apres /clear)
argument-hint: [session-id, ou vide pour la session precedente]
allowed-tools: Read, Bash(cat .claude/bundles/*)
disable-model-invocation: true
---

# /loadbundle — remounting d'une session

## 1. Sessions disponibles (index, ~30 tokens par ligne)

!`tail -5 .claude/bundles/index.jsonl 2>/dev/null || echo "(aucun index : le hook context-bundle.sh n'a pas encore tourne)"`

## 2. Trajectoire remontee

Session demandee : "$ARGUMENTS" (vide = la plus recente, hors session courante).

!`ls -t .claude/bundles/*.jsonl 2>/dev/null | grep -v -e index.jsonl -e "${CLAUDE_SESSION_ID}" | head -1 | xargs -r cat`

Si "$ARGUMENTS" n'est pas vide et designe une autre session, lis a la place
`.claude/bundles/$ARGUMENTS.jsonl` avec Read, puis ignore la trajectoire ci-dessus.

## 3. Protocole de reprise — dans cet ordre, sans rien relire avant l'etape c

a. Resume en 5 lignes maximum ce que tu comprends : objectif, ce qui a ete fait,
   ce qui a ete modifie, ce qui a ete teste.
b. Liste explicitement ce que tu ne sais PLUS : resultats de tests, hypotheses,
   cause du bug. Ne comble aucun trou par une supposition.
c. Rouvre UNIQUEMENT les fichiers marques Edit ou Write dans la trajectoire,
   et `notes/etat.md` s'il existe. Pas les fichiers seulement lus.
d. Annonce « pret a reprendre » et attends l'objectif de reprise.

Rappel : ce qui precede est une trajectoire (~4k tokens), pas la session (~140k).
Ta fenetre est neuve — garde-la ainsi.

Invoque-la juste après /clear par /loadbundle (ou /loadbundle <session-id> pour une session plus ancienne relevée dans l’index) : l’agent neuf reçoit ~4,6k tokens, rouvre ~10k tokens de fichiers modifiés et repart à ~7 % d’occupation avec 60 à 70 % de l’état mental de son prédécesseur — au lieu de ~70 % d’occupation et d’une attention dégradée avec --resume. Le placeholder ${CLAUDE_SESSION_ID} est substitué par Claude Code avant l’exécution des lignes !, ce qui écarte le bundle vide que SessionStart vient d’ouvrir ; le même fichier peut vivre en .claude/skills/loadbundle/SKILL.md.