Pourquoi Claude Code oublie d'une session à l'autre, et comment le nôtre se souvient

Claude Code oublie le contexte entre les sessions, car chaque session démarre avec une fenêtre de contexte vide. Au sein d'une même session, une fenêtre pleine est compactée : les échanges les plus anciens deviennent un résumé. D'une session à l'autre, rien ne passe, sauf ce qui a été écrit.

La mémoire inter-sessions est une routine qui pousse un agent de code IA à consulter les décisions passées avant de travailler et à enregistrer les nouvelles ensuite, pour qu'une nouvelle fenêtre de contexte démarre informée. Nous la faisons tourner sous forme de boucle dans Claude Code, imposée par un hook Stop (un script que Claude Code exécute chaque fois qu'il termine une réponse). OpenCode et Kimi Code partagent les mêmes règles et la même base de mémoire.

Au sein d'une session, les échanges anciens sont compactés ; entre deux sessions, la nouvelle fenêtre démarre vide et seules les notes enregistrées passent de l'une à l'autre.

Pourquoi Claude Code oublie, et ce que fait notre boucle de mémoire

Claude Code n'oublie pas par accident. Chaque session démarre vide par conception : la solution est donc une routine, pas un fichier plus gros.

La documentation d'Anthropic(s’ouvre dans un nouvel onglet), 2026 : « Chaque session Claude Code commence avec une fenêtre de contexte vierge. » Deux fonctionnalités intégrées donnent à Claude Code une mémoire d'une session à l'autre :

Le contexte, l'agent le soupèse ; ce n'est pas une étape qu'il est obligé de suivre. Nous avons donc ajouté une boucle par-dessus, avec une base de mémoire partagée que l'agent atteint via MCP :

La base de mémoire est notre cerveau d'entreprise ; le classement des notes correspond à la couche 1 de notre système qui s'améliore tout seul.

La version à copier (hook, entrée de configuration et test) se trouve dans Construire votre propre boucle.

Pourquoi nous l'avons construite : une règle écrite se fait ignorer

Nous avons écrit la règle, et l'agent l'a ignorée. Une règle qui compte sur l'agent pour se souvenir de la suivre n'est qu'une suggestion.

La règle figurait dans le fichier d'instructions : consulter avant d'explorer, enregistrer après. Des sessions sautaient la consultation et relisaient du code qu'une session précédente avait déjà cartographié. Des sessions modifiaient des fichiers et se terminaient sans rien noter, si bien que la suivante redécouvrait la même réponse.

La mémoire existait et les outils fonctionnaient. Il manquait un moment où sauter l'étape avait un coût. Une personne approuve le travail qui compte (notre modèle de gouvernance), mais personne ne surveille la fin de chaque session.

Découvrez comment ConvOps donne à chaque agent une mémoire unique qu'il consulte avant de travailler(s’ouvre dans un nouvel onglet), et conserve les notes que chaque session laisse derrière elle.

Comment tourne la boucle de mémoire

Le rappel coûte un appel. L'enregistrement coûte un appel. Le seul point coûteux, c'est d'obtenir les deux à chaque fois : c'est la mission que nous avons confiée au hook.

À chaque arrêt contrôlé, des modifications sans rien d'enregistré renvoient l'agent enregistrer ; sinon, la session se termine.

Comment un hook Stop décide. Il lit la transcription (le fichier où Claude Code consigne chaque message et chaque appel d'outil) et se termine par un code de sortie, un nombre qui indique à Claude Code quoi faire ensuite. Le code 0 laisse la session se terminer. Le code 2 « empêche Claude de s'arrêter et poursuit la conversation » (Anthropic, Hooks(s’ouvre dans un nouvel onglet), 2026), et l'agent lit le message du hook. Notre protection contre la suppression utilise le même code de sortie sur les appels d'outils.

Ce que vérifie le hook Stop de mémoire

Chaque seuil indiqué ici est celui qu'applique notre hook.

Chaque règle enfreinte ajoute un message, le blocage se termine par « This is mandatory. », et le hook sort avec le code 2.

Ce que le hook ne voit pas

Nous faisons davantage confiance au hook parce que nous savons exactement où il est aveugle.

• Il compte les appels d'outils par leur nom. Il ne lit jamais ce qu'un rappel a renvoyé ni si un enregistrement était bon.
• Seul memory_store compte comme un enregistrement. Une session qui n'écrit que des notes context= et modifie des fichiers est quand même renvoyée au travail.
• Les modifications faites par le shell lui échappent. Un sed ou un heredoc n'est pas une modification pour le hook ; seuls les quatre outils de modification natifs le sont.
• La transcription peut être en retard. La documentation des hooks(s’ouvre dans un nouvel onglet) d'Anthropic indique qu'elle est écrite de façon asynchrone : un enregistrement de dernière seconde est donc compté au contrôle suivant.
• Il ne s'exécute que dans Claude Code ; voir les sections OpenCode et Kimi Code.

Les hooks portent les règles qui ne doivent jamais dépendre de la mémoire (la couche des hooks). Celui-ci impose les appels, pas la mémoire.

Comment Claude Code se souvient d'une session à l'autre

Le moment utile n'est pas l'enregistrement. C'est le lendemain matin, quand une session qui n'a jamais vu le travail du lundi s'ouvre avec la leçon du lundi.

Copperfern est une boutique en ligne fictive d'articles pour la maison ; ses noms, ses fichiers et ses notes sont inventés, mais les seuils et les messages sont réels.

Lundi. Maya, qui gère les opérations, crée une tâche : « Les commandes espagnoles ont un centime d'écart au paiement. » L'agent de code lance context_query("spanish vat checkout rounding") et ne trouve rien sur l'arrondi. Il lit shop/checkout/tax.py, constate que la TVA est arrondie une seule fois sur le total de la commande, modifie le fichier et son test pour arrondir ligne par ligne, puis tente de s'arrêter.

Le hook s'exécute : 5 appels d'outils, assez de nouvelles entrées depuis le dernier contrôle. Une consultation a eu lieu, donc seul le contrôle des modifications se déclenche. Le hook bloque l'arrêt avec ce message, qui exige d'enregistrer la modification :

KNOWLEDGE CHECK: Modified 2 file(s) but stored nothing. memory_store() the change/decision (supersede if updating). If you explored files, create_route()/update_route() in ConvOps. This is mandatory.

Code 2. L'agent enregistre un piège à connaître (catégorie gotchas), importance 7, étiquettes shop, checkout, vat. La note dit : « La TVA espagnole s'arrondit ligne par ligne, pas sur le total de la commande ; arrondir le total crée un écart d'un centime sur les commandes de plusieurs articles. » Il enregistre une route : « L'arrondi de la TVA se trouve dans shop/checkout/tax.py ». Il tente à nouveau de s'arrêter. stop_hook_active vaut true, et la session se termine.

Lundi, la session corrige l'arrondi, est renvoyée une fois au travail et enregistre le pourquoi avant de se terminer.

Mardi. Nouvelle tâche : « Ajouter la TVA sur la ligne d'emballage cadeau. » Nouvelle session, fenêtre vide : rien du lundi n'y figure. L'agent lance context_query("vat gift wrap checkout"), et le piège du lundi revient avec la route. Il ouvre directement shop/checkout/tax.py et arrondit la TVA de l'emballage cadeau sur sa propre ligne.

Il s'avère que la livraison est elle aussi une ligne à part. L'agent enregistre le piège affiné, « La TVA espagnole s'arrondit ligne par ligne ; l'emballage cadeau et la livraison comptent chacun comme une ligne. », puis oublie l'enregistrement du lundi avec memory_forget, une suppression logique réversible. À l'arrêt, la consultation a précédé l'enregistrement et la modification a son enregistrement : code 0. Seule la note affinée répond à la consultation suivante.

Mardi, la session n'a jamais vu le lundi, mais sa première consultation renvoie la leçon du lundi ; elle enregistre la note affinée et oublie l'ancienne.

Ce que la boucle laisse derrière elle

Une mémoire vaut exactement ce que la session suivante peut en tirer sans poser de question : un fait, sa raison, un type et une importance honnête.

Un enregistrement de mémoire, tel que l'agent le stocke :

content:    Spanish VAT rounds per line, not per order total; rounding the
            total is off by a cent on multi-item orders.
category:   gotchas
importance: 7
tags:       shop, checkout, vat
task_id:    cf-131

Le contenu porte le fait et sa raison. L'importance mesure ce que la session suivante perd si elle passe à côté de la note : la plupart se situent entre 4 et 6, et celle-ci vaut 7 parce qu'un total faux atteint les clients. Deux à cinq étiquettes la rendent trouvable.

Une route indique où se trouve quelque chose :

title:       VAT rounding
description: VAT rounding lives in shop/checkout/tax.py
paths:       shop/checkout/tax.py, tests/test_tax.py

Une note context=, écrite dans le même appel qu'une mise à jour de tâche, est stockée comme une mémoire liée à la tâche (importance 4 par défaut ; sous 40 caractères, elle n'est pas stockée) :

Rounded VAT per line, not per order; Spanish totals were a cent off on
multi-item orders.

Aucun champ ne remplace un enregistrement. L'agent enregistre la nouvelle note et oublie l'ancienne. Une personne peut aussi remplacer une note depuis la page du cerveau, qui relie le nouvel enregistrement à l'ancien et retire l'ancien du rappel.

Ce qui tourne mal avec un hook de mémoire

Notre contrôle a échoué deux fois, dans des sens opposés : une fois il a laissé passer des modifications en silence, une autre fois il a bloqué indéfiniment. Vérifiez les deux cas sur votre propre hook.

Il a laissé passer des modifications. Le seul contrôle « rien enregistré » attendait qu'une session dépasse une longueur minimale. Une courte session Copperfern modifie le modèle d'étiquette d'expédition et se termine proprement sans rien noter ; la session suivante refait la même enquête. La règle qui en est sortie : les modifications sans enregistrement sont signalées au contrôle suivant, sans cette attente. Le plancher de 3 appels et l'intervalle s'appliquent toujours.

Il a bloqué indéfiniment. Le contrôle « enregistrement avant rappel » comparait le premier enregistrement au premier rappel sur toute la session. Une session enregistre une note avant sa première consultation, puis consulte correctement, et elle est quand même renvoyée au travail à chaque arrêt, jusqu'à être abandonnée. La règle qui en est sortie : chaque contrôle ne regarde que ce qui s'est passé depuis le contrôle précédent, si bien qu'un faux pas initial est signalé au contrôle qui le couvre, et non à chaque arrêt ultérieur.

Notre commentaire de code dit pourquoi : « un signalement qu'aucun comportement ultérieur ne peut satisfaire est une rengaine, pas un garde-fou ». Cette règle a désormais un test qui pilote le vrai hook avec une transcription synthétique, un faux journal de session.

Avant le correctif, un seul enregistrement précoce bloquait chaque arrêt suivant ; désormais, chaque contrôle ne regarde que ce qui s'est passé depuis le précédent, et le faux pas est signalé dans sa propre fenêtre.

Nous avons resserré la règle de consultation. Elle s'appliquait à chaque message. Elle s'applique désormais avant d'explorer ou de travailler sur un sujet qui n'est pas déjà connu ; enregistrer après chaque action reste obligatoire. Une session à qui l'on demande « quelle heure est-il à Madrid ? » ne lance aucune consultation ; une session sur le point de lire le code du paiement en lance toujours une.

Construire votre propre boucle de mémoire dans Claude Code

Commencez par une règle que le hook peut compter : si une session a modifié des fichiers, elle note quoi et pourquoi avant de se terminer.

D'abord, connectez la base de mémoire. Nous utilisons ConvOps ; une seule commande l'ajoute à Claude Code :

claude mcp add --transport http convops https://mcp.convops.app/

Ajoutez ensuite ces deux lignes à votre CLAUDE.md. Gardez ce fichier court (ce qu'il faut couper d'un CLAUDE.md trop long) : le hook porte le contrôle, le fichier porte l'habitude.

Before exploring or working on anything you don't already know, query the memory store first. Known answers and chat skip the lookup.
After every action, store what you learned and why, with a type, an honest importance and two to five tags. To replace a note, store the new one, then forget the old one.

Cette version réduite de notre hook (Claude Code 2.1.301) conserve la garde anti-boucle, le plancher de 3 appels, l'intervalle, le contrôle des modifications et la consultation au premier contrôle. Enregistrez-la sous ~/.claude/hooks/memory-gate.py :

"""Stop hook: send the agent back when it edited files and stored nothing."""
import json, os, sys, tempfile

MIN_TOOL_CALLS = 3
INTERVAL = 2
EDIT_TOOLS = ("Edit", "Write", "MultiEdit", "NotebookEdit")

hook = json.load(sys.stdin)
if hook.get("stop_hook_active"):
    sys.exit(0)  # the retry after a block is not checked
names, entries = [], 0
with open(hook["transcript_path"]) as f:
    for line in f:
        entry = json.loads(line)
        if entry.get("type") != "assistant":
            continue
        entries += 1
        for block in entry.get("message", {}).get("content", []):
            if isinstance(block, dict) and block.get("type") == "tool_use":
                names.append(block["name"])

if len(names) < MIN_TOOL_CALLS:
    sys.exit(0)
counter = os.path.join(tempfile.gettempdir(), f"memory_gate_{hook['session_id']}")
last = int(open(counter).read()) if os.path.exists(counter) else 0
if entries - last < INTERVAL:
    sys.exit(0)
open(counter, "w").write(str(entries))
edits = sum(n in EDIT_TOOLS for n in names)
stores = sum("memory_store" in n for n in names)
lookups = sum("context_query" in n or "route_query" in n for n in names)
problems = []
if edits and not stores:
    problems.append(f"Modified {edits} file(s) but stored nothing. Store the change and why.")
if last == 0 and not lookups:
    problems.append("No lookup at the first check. Query the memory store first.")
if problems:
    print("KNOWLEDGE CHECK: " + " | ".join(problems) + " This is mandatory.", file=sys.stderr)
    sys.exit(2)

Déclarez-le sous Stop dans .claude/settings.json :

{
  "hooks": {
    "Stop": [
      {
        "hooks": [
          { "type": "command", "command": "python3 ~/.claude/hooks/memory-gate.py", "timeout": 15 }
        ]
      }
    ]
  }
}

Testez-le avec une transcription synthétique avant de vous y fier. Celle-ci contient une consultation et deux modifications, elle doit donc renvoyer le code 2 :

printf '%s\n' \
  '{"type":"assistant","message":{"content":[{"type":"tool_use","name":"context_query"}]}}' \
  '{"type":"assistant","message":{"content":[{"type":"tool_use","name":"Edit"}]}}' \
  '{"type":"assistant","message":{"content":[{"type":"tool_use","name":"Edit"}]}}' \
  > copperfern-test.jsonl
echo '{"session_id":"test-001","transcript_path":"copperfern-test.jsonl"}' \
  | python3 ~/.claude/hooks/memory-gate.py; echo "exit $?"

Utilisez un nouveau session_id à chaque exécution, car le fichier compteur retient le dernier contrôle. Ajoutez ensuite une ligne memory_store : le code attendu est alors 0.

La mémoire d'OpenCode entre les sessions

Les sessions OpenCode 1.18.31 démarrent elles aussi à vide. Nous leur donnons le même texte et la même base de mémoire.

Nos fichiers AGENTS.md sont des liens symboliques vers CLAUDE.md : OpenCode lit donc les mêmes règles de rappel et d'enregistrement (un seul fichier pour les deux). Notre opencode.json fait pointer son bloc mcp vers la même base ConvOps, si bien qu'une note enregistrée depuis Claude Code revient lors d'une consultation dans OpenCode. Nous n'exécutons aucun hook de mémoire dans OpenCode. Il dispose pourtant d'une interface de plugins qui le permettrait (plugins(s’ouvre dans un nouvel onglet)) ; notre protection contre la suppression en montre la forme.

La mémoire de Kimi Code entre les sessions

Kimi Code 0.31.1 reçoit le même texte et la même base de mémoire. Il lit l'AGENTS.md en lien symbolique, et notre .kimi-code/mcp.json déclare le même serveur ConvOps : ses consultations renvoient donc ce que Claude Code et OpenCode ont enregistré. Nous n'exécutons aucun hook de mémoire dans Kimi Code. Il accepte des entrées [[hooks]] dans sa configuration utilisateur (hooks de Kimi Code(s’ouvre dans un nouvel onglet)), et le guide sur la protection contre la suppression en montre un.

Créez un compte ConvOps gratuit et connectez Claude Code, OpenCode ou Kimi Code à une mémoire unique(s’ouvre dans un nouvel onglet), puis ajoutez la règle de consultation, la règle d'enregistrement et le hook Stop.