# Récupérer une sortie repliée

> Chaque repli affiche un hash. tokenade expand-ref interroge la sortie rangée, y cherche des lignes ou rend les octets exacts, sans relancer la commande.

Source: https://tokenade.net/fr/docs/expand-ref-disclose · Updated: 2026-10-07

Quand Tokenade replie une grosse sortie, l'original complet part dans un stash local et le bandeau affiche un hash. `tokenade expand-ref <hash>` vous permet d'en tirer ce dont vous avez besoin : l'interroger, y chercher des lignes, ou parcourir les octets exacts. Rien n'est relancé.

## D'où vient le hash

Chaque repli se termine par un bandeau comme celui-ci :

```text
[tokenade:find 443263 tokens folded away; the stash holds the COMPLETE output — this blob is ~444645 tokens — too large to dump whole. recover with `tokenade expand-ref 6f961168e46c` · `--prompt "q1, q2"` to ask (RAG, several at once) · `--grep <pat>` exact lines. Any other hash above covers only what was shown.]
```

Le hash compte 12 caractères hexadécimaux. Votre agent lit le bandeau et peut appeler `expand-ref` lui-même ; vous aussi.

## expand-ref

```text
tokenade expand-ref <hash> [--prompt "q1, q2"] [--grep <pat>…] [--raw]
```

Alias : `xref`.

| Option | Effet |
| --- | --- |
| `--prompt "q1, q2"` | Pose plusieurs questions en un appel et ne renvoie que les passages qui répondent. L'option la moins chère en tokens. Aussi `--question`, `-q` |
| `--grep <pat>` | Lignes exactes correspondantes, répétable. Le motif est une expression régulière appliquée ligne par ligne. Affiche `N matching line(s) of M total` pour qu'un résultat partiel ne passe jamais pour la sortie entière |
| `--ignore-case`, `-i` | Ignore la casse des deux côtés de `--grep` |
| `--raw`, `--full` | Les octets, tels quels, par pages bornées |
| `--from-line N` | Avec `--raw` : reprend à la ligne N |
| `--budget N` | Avec `--raw` : porte le plafond à N tokens ; `--budget 0` le supprime |

Commencez par `--prompt` ou `--grep`. `--raw` remet les octets stockés dans le contexte, ce que le repli visait justement à éviter ; il s'arrête donc à un budget et vous indique exactement comment continuer.

```text
$ tokenade expand-ref f6351f5ead9a --grep '^1999[0-2]$'
19990:19990
19991:19991
19992:19992
[tokenade:expand-ref] 3 matching line(s) of 20000 held under this hash
```

```text
$ tokenade expand-ref f6351f5ead9a --raw
1
2
…
12399
[tokenade: lines 1-12399 of 20000 (~59997 tokens). 7601 line(s) left — continue with `tokenade expand-ref f6351f5ead9a --raw --from-line 12400`, narrow with `--grep <pattern>`, or take the rest in one go with `--budget 0`.]
```

### Hash inconnu ou expiré

```text
$ tokenade expand-ref 000000000000 --grep x
expand-ref: hash '000000000000' not found in dedup cache or stash
  …
  the bytes are gone, so there is no second way back to THEM: re-run the command that printed this hash (`tokenade raw <cmd>` re-runs it uncompacted)
```

Code de sortie `1`. Les entrées inutilisées depuis 7 jours sont supprimées (voir [maintenance](https://tokenade.net/fr/docs/maintenance)), et le répertoire du stash est plafonné à 2 Gio, les plus anciennes partant en premier. Passé ce délai, relancez la commande.

## expand-fold

```text
tokenade expand-fold <id> [hash] [--max N]
```

Alias : `xfold`. Certains replis raccourcissent une série de lignes de log répétitives et affichent un identifiant pour elle dans le bandeau. `expand-fold` redéploie cette série en lignes brutes. Sans hash, il prend le repli le plus récent pour cet identifiant ; `--max N` limite le nombre de lignes renvoyées.

## disclose : ranger vous-même n'importe quelle sortie

`disclose` applique le même principe « ranger puis interroger » à toute sortie envoyée par un pipe.

```text
<cmd> | tokenade disclose stash [--source web|shell|mcp|graphql]
tokenade disclose read <hash>
tokenade disclose search <hash> <query>
```

| Sous-commande | Effet |
| --- | --- |
| `stash` | Lit l'entrée standard. Sous le seuil de taille, laisse passer l'entrée inchangée et ne range rien. Au-dessus, écrit le contenu dans le stash et affiche un aperçu replié avec un bandeau indiquant le fichier, une estimation en tokens et le hash |
| `read <hash>` | Rend les octets rangés |
| `search <hash> <query>` | Ne rend que les passages qui correspondent |

`--source` indique au lecteur d'où vient le contenu ; sans lui, le contenu est analysé pour le deviner.

```text
$ seq 1 30000 | tokenade disclose stash --source shell
1
…
30000
[stashed: ~/.cache/tokenade/stash/5bc81dbc42fe.txt · ~129290 tokens · folded summary (omits middle lines) · recover with `tokenade expand-ref 5bc81dbc42fe` · …]
```

Un hash inconnu est signalé et sort en `1`, au lieu de ne rien renvoyer avec un code `0`.

## Où se trouve le stash

| Élément | Valeur |
| --- | --- |
| Répertoire | `~/.cache/tokenade/stash/` sous Linux (le répertoire de cache de la plateforme ailleurs) ; modifiable avec `TOKENADE_STASH_DIR` |
| Seuil de rangement | Environ 5 000 tokens pour une sortie de commande (`TOKENADE_DISCLOSE_THRESHOLD`), 25 000 pour une lecture de fichier |
| Plafond | 2 Gio au total, les plus anciennes entrées supprimées d'abord (`TOKENADE_STASH_MAX_DIR_BYTES`) |
| Durée de vie | 7 jours depuis la dernière utilisation |

Tout ce qui est dans le stash est déjà passé par le masquage des secrets. Détails dans [Compaction des sorties et stash](https://tokenade.net/fr/docs/compaction).

## Voir aussi

- [Compaction des sorties et stash](https://tokenade.net/fr/docs/compaction)
- [wrap, raw et filter](https://tokenade.net/fr/docs/wrap-raw-filter)
- [Lire documents et médias](https://tokenade.net/fr/docs/read-documents-media)
- [Commandes de maintenance](https://tokenade.net/fr/docs/maintenance)
