Conserver les sessions et les reprendre

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102

# Conserver les sessions et les reprendre

Ce guide montre comment faire enregistrer par `mm` chaque conversation d'un projet et en retrouver une plus tard, dans le terminal et depuis un éditeur. Il suppose que `mm` tourne avec un fichier de configuration que vous pouvez modifier.

## Étapes

1. Activez la fonctionnalité dans le fichier YAML :

   ```yaml
   sessions:
     enabled: true
     dir: .mm/sessions
   ```

   `dir` est relatif au projet : le répertoire d'où vous lancez `mm` dans le terminal, le projet ouvert dans l'éditeur en mode ACP. Ajoutez `.mm/` au `.gitignore` du projet : un fichier de session contient toutes les sorties de commandes que le modèle a lues.

2. Lancez `mm` depuis le répertoire du projet. La bannière se termine maintenant par une ligne `sessions:` :

   ```text
   sessions: saved under /work/project/.mm/sessions · 2 earlier — /resume to continue the latest, /sessions to list
   ```

   Ce lancement est une nouvelle session. Son fichier apparaît avec la première question et est réécrit après chaque tour, après `/compact` et après `/new`.

3. Listez les sessions du projet quand vous en cherchez une :

   ```text
   > /sessions
   3 session(s) in /work/project/.mm/sessions — /resume <id> to continue one, /resume for the latest
   * 20260916-101530-4f2a9c1e  2026-09-16 10:15  2 turn(s)  add a /new command
     20260916-093012-77be01d3  2026-09-16 09:41  5 turn(s)  fix the skills loader
     20260915-181200-0a1b2c3d  2026-09-15 18:20  1 turn(s)  list the files
   ```

   Le `*` marque la session courante. Les identifiants se trient par date de création.

4. Reprenez-en une :

   ```text
   > /resume
   ↩️ resumed 20260916-093012-77be01d3 — 14 message(s), started with "fix the skills loader"
   ```

   Un `/resume` seul prend la conversation la plus récemment mise à jour autre que la courante, en ignorant les sessions vides ; `/resume <id>` en désigne une. À partir de là, le modèle voit l'historique repris — sous le prompt système actuel — et chaque nouveau tour est enregistré dans le fichier de cette session. Rien n'est rejoué à l'écran : la ligne dit ce qui est revenu.

## Comprendre pourquoi une exécution a échoué

1. Repérez la session dans la liste : une session qui a affiché au moins une erreur termine sa ligne par ` · ⚠️ N error(s)`. La même queue apparaît dans le compte rendu `↩️ resumed …`.

   ```text
   > /sessions
   2 session(s) in /work/project/.mm/sessions — /resume <id> to continue one, /resume for the latest
   * 20260918-141321-db582a3d  2026-09-18 16:13  1 turn(s)  say just: ok
     20260918-141225-02790c82  2026-09-18 16:12  0 turn(s)   · ⚠️ 1 error(s)
   ```

2. Lisez le tableau `errors` de son fichier. Chaque enregistrement dit quand, à quel tour, sur quelle question, ce que l'écran a montré (`message`), quand l'erreur brute en dit plus, ce qu'elle était (`detail`), et quel `model` a échoué ; `where` vaut `generation`, `compaction` ou `resume` :

   ```bash
   jq .errors .mm/sessions/20260918-141225-02790c82.json
   ```

   ```json
   [
     {
       "at": "2026-09-18T14:12:25Z",
       "turn": 1,
       "where": "generation",
       "message": "dmr: \"no/such-model:none\" not found at http://localhost:12434/engines/v1 — docker model pull no/such-model:none",
       "detail": "failed to create completion: POST \"http://localhost:12434/engines/v1/chat/completions\": 404 Not Found",
       "question": "hello",
       "model": "no/such-model:none"
     }
   ]
   ```

3. Pour faire analyser l'échec, confiez le fichier à un agent de code (Claude Code, ou `mm` lui-même dans un autre projet) et demandez ce qui s'est passé et quoi changer — dans le code, ou dans `agent.yaml` (`watchdogTimeout`, `maxOutput`, `model`, `context.*`). L'historique du même fichier donne le contexte qu'avait le modèle ; le tableau `errors` donne ce qu'il n'a jamais vu.

   Une session dont le seul contenu est une erreur n'a aucun tour : un `/resume` seul la saute, `/resume <id>` l'atteint.

## Depuis un éditeur (ACP)

1. Gardez `sessions.enabled: true` dans le fichier désigné par `AGENT_CONFIG`. Chaque fil ouvert par l'éditeur est une session, enregistrée sous `<projet>/.mm/sessions/<id>.json` dès sa création.

2. Utilisez **Reload Agent** (Zed) quand l'agent a redémarré ou que vous avez changé sa configuration. L'éditeur envoie `session/load` avec l'identifiant du fil ; `mm` relit le fichier et rejoue toute la conversation — vos questions, les réponses, chaque appel d'outil avec l'entrée qu'il a reçue et la sortie qu'il a renvoyée à l'époque. Rien n'est réexécuté. Le fil continue ensuite comme avant.

3. `/new` dans un fil garde le fil (l'identifiant de session de l'éditeur), mais la conversation écoulée est conservée sur disque sous un nouvel identifiant, et le fichier du fil repart vide. `/sessions` et `/resume` n'existent pas en ACP : c'est l'éditeur qui liste les fils.

## Variantes

- **Un seul dépôt pour tous les projets.** Donnez un chemin absolu à `dir`. Les sessions de différents projets partagent alors un répertoire ; chaque fichier enregistre son `cwd`.
- **Un projet en lecture seule.** La bannière ou le journal `[acp]` indique `not saved` avec la raison ; la conversation continue sans être enregistrée.
- **Compression.** Un `/compact` ou une compression automatique réécrit le fichier avec l'historique raccourci ; une session reprise ou rechargée repart du résumé, comme la session en direct. Le tableau `errors` reste tel quel.
- **Erreurs en ACP.** L'éditeur montre l'échec à sa manière ; l'enregistrement va quand même dans le fichier du fil, et `/new` le déplace dans la conversation archivée avec l'historique auquel il appartient.
- **Repartir de zéro volontairement.** Rien à faire : chaque lancement est une nouvelle session. Les anciennes ne reviennent que sur `/resume` ou sur un rechargement depuis l'éditeur.

## Voir aussi

- [Référence de la configuration](../reference/configuration.md) — les clés `sessions`
- [Référence des commandes slash](../reference/slash-commands.md) — `/sessions`, `/resume`, `/new`
- [Référence ACP](../reference/acp.md) — `session/load` et ce qu'il rejoue
- [Pourquoi les sessions fonctionnent ainsi](../explanation/persistent-sessions.md)