Reelier

---

Votre agent redérive le même workflow à chaque exécution — brûlant des tokens et dérivant silencieusement. Reelier compile une exécution qui a fonctionné en un fichier SKILL.md qui se rejoue de manière déterministe (pas de LLM, 0 token, chaque étape vérifiée dans un reçu), puis diff les exécutions pour détecter le jour où ça ne correspond plus. Pour les agents sur des workflows de production récurrents — où "ça a tourné" n'est pas une preuve.

Installer → votre premier reçu en 60 secondes

npm i -g reelier && reelier init

reelier init analyse d'abord le travail que vous avez déjà fait — sur Claude Code, Codex, Windsurf et OpenClaw — et propose de transformer une session passée réelle en une compétence rejouable. Pas d'historique ? Il lance une démo sans configuration et se termine par un vrai reçu :

Your receipt:
  skill:        reelier-init-demo
  steps:        2 total, 2 passed, 0 unchecked, 0 failed
  replay time:  44ms  [measured]
  LLM tokens:   0     [measured]

  An agent doing a comparable task re-reasons every run (~2.8s, ~18k tokens on
  our benchmark). Your replay: 44ms, 0 tokens.

Ou exécutez-le avec Docker — pas d'installation Node

docker run --rm ghcr.io/seldonframe/reelier --help

# Replay a skill from the current directory:
docker run --rm -v "$PWD:/work" -w /work ghcr.io/seldonframe/reelier run my.skill.md

# Record from your agent history (mount it read-only):
docker run --rm -v "$HOME/.claude:/root/.claude:ro" -v "$PWD:/work" -w /work \
  ghcr.io/seldonframe/reelier scan

Pourquoi

• Votre agent réapprend le travail à chaque exécution — puis dérive silencieusement. Chaque exécution redérive le workflow, et chaque petite correction "rationnelle" s'accumule — ce que les opérateurs de longue date appellent le tissu cicatriciel. Une compétence compilée ne réapprend jamais et ne peut pas dériver.
• Le vrai problème, c'est la facture. "Combien ça a coûté ?" est la première réponse que chaque longue exécution d'agent reçoit. Reelier rejoue pour 0 token, avec un reçu.
• Ce n'est pas de la RPA fragile. Rejoue les appels d'outils (JSON typé en entrée/sortie), pas les pixels — et chaque étape porte sa propre assertion, donc une étape cassée échoue bruyamment, ne passe jamais silencieusement.
• Modèle mis à niveau ? Une relecture est épinglée — réenregistrez sur le nouveau modèle et reelier diff par rapport à votre référence gelée : IDENTIQUE ou DÉRIVÉ, par étape, avant que ça n'atteigne la production.
• "Tout ce qui est déterministe devrait juste être du code." D'accord — votre agent l'a déjà écrit. Reelier capture son exécution réelle et fonctionnelle dans un fichier testé. Le déterminisme sans le codage manuel.

Comment ça marche — enregistrer → compiler → rejouer → diff → reçu

reelier init                        # 60s: record → compile → replay → your receipt
reelier run  <name>.skill.md        # replay deterministically — 0 tokens (read-only by default)
reelier diff <name>                 # SAME or DRIFTED, per step — exit 1 on drift
reelier push <name>.skill.md        # sync receipts to your ledger (opt-in)

1. Enregistrer — trois façons : reelier mcp --wrap "<your mcp server>" (un proxy sans perte devant les outils de votre agent), directement depuis une session existante (reelier scan / reelier from-session), ou le reelier init guidé.
2. Compiler — reelier compile transforme une trace en un SKILL.md de manière déterministe (0 appel LLM) — une recette avec une assertion à chaque étape, et les lacunes honnêtes du compilateur imprimées comme Questions ouvertes (y compris les dates littérales, UUID et horodatages qu'il signale comme "cela devrait-il être une variable ?") plutôt que devinées.
3. Rejouer — reelier run l'exécute au Niveau 0 : pas de LLM, millisecondes, identique octet par octet. Lecture seule par défaut — une étape d'écriture (idempotent-write) ne se redéclenche jamais sauf si vous passez --allow-writes.
4. Diff — reelier diff compare deux exécutions d'une compétence et rapporte IDENTIQUE ou DÉRIVÉ par étape, avec l'assertion défaillante comme pourquoi. Code de sortie 1 en cas de dérive, donc cela bloque une relecture planifiée.
5. Reçu — chaque exécution est un reçu (résultats par étape, chronométrage, 0 token). reelier push les synchronise optionnellement vers un registre de reçus pour un lien permanent partageable + un badge de relecture vérifiée intégrable.

Convertir une compétence d'agent

Transformez une compétence d'instruction + une exécution enregistrée en une relecture déterministe — votre compétence, moins le modèle :

reelier mcp --wrap "<your mcp server>"                 # record: agent runs the skill's task once
reelier compile trace.jsonl --from-skill ./my-skill/SKILL.md
# → my-skill.skill.md — name + description carried from your SKILL.md,
#   steps ONLY from the recorded run (never generated from instruction text)

Importer des sessions depuis n'importe quel agent

Vous avez déjà des workflows rejouables dans les journaux de session de votre propre agent. reelier scan les trouve ; reelier from-session transforme l'un d'eux en compétence. Le format est détecté à partir du contenu du fichier — aucun drapeau nécessaire pour les agents pris en charge :

reelier scan                                          # discovers sessions from every known agent under your home dir
reelier from-session ~/.claude/projects/*/*.jsonl      # Claude Code
reelier from-session ~/.codex/sessions/**/rollout-*.jsonl   # Codex CLI
reelier from-session ~/.openclaw/agents/*/sessions/*.jsonl  # OpenClaw

Agent	Emplacement de la session	Statut
Claude Code	~/.claude/projects/<project>/<uuid>.jsonl	pris en charge
Codex CLI	~/.codex/sessions/YYYY/MM/DD/rollout-*.jsonl	pris en charge
OpenClaw	~/.openclaw/agents/<agentId>/sessions/<sessionId>.jsonl	pris en charge
Cursor	.../User/globalStorage/state.vscdb (SQLite, non documenté)	détecté, pas encore analysable
Windsurf	.../User/globalStorage/state.vscdb (SQLite, non documenté)	détecté, pas encore analysable

Seuls les appels rejouables (les fonctions intégrées de Reelier, ou les appels mcp__<server>__<tool>) sont compilés en compétence — les actions natives fichier/shell/recherche sont signalées comme ignorées, jamais fabriquées en étape. Passez --agent <claude-code|codex|openclaw> pour forcer un format au lieu de la détection automatique ; reelier scan / reelier from-session --agent cursor (ou --agent windsurf) rapportent honnêtement ce qui est sur le disque plutôt que de deviner un format binaire non documenté.

Trois tests, une compétence

Une compétence enregistrée vous donne trois questions différentes à lui poser, pas une seule :

• Déterminisme — reelier run <skill.md> rejoue par rapport aux assertions que vous avez enregistrées. Mêmes étapes, mêmes assertions, 0 token. Répond : est-ce que ça fait toujours ce que ça faisait ?
• Récupération — reelier run <skill.md> --fail N[=status] injecte une défaillance synthétique à l'étape N (statut par défaut 500 ; remplacez par --fail N=429, répétable) au lieu de distribuer le véritable appel d'outil de cette étape, puis exécute la MÊME échelle d'escalade qu'une vraie défaillance rencontrerait. Rien en dehors du réseau ne se produit réellement — une étape simulée n'appelle jamais son outil, vous pouvez donc tester la récupération d'une étape d'écriture sans --allow-writes et sans effet de bord. Répond : si ça cassait, la compétence le remarquerait-elle et guérirait-elle ? (Une exécution simulée est un test local uniquement — reelier push refuse d'en publier une ; voir ci-dessous.)
• Dérive — reelier run <skill.md> --wrap "<your mcp server>" rejoue par rapport à vos dépendances en direct et en lecture seule au lieu de la trace enregistrée. Associé à reelier manifest (ci-dessous), c'est ainsi que vous détectez le schéma d'un outil qui bouge sous vos pieds avant qu'une vraie relecture ne le fasse.

Taxonomie due à la revue du post de lancement par Mads Hansen.

Dérive du schéma d'outil : reelier manifest

Les étapes d'une compétence appellent des outils spécifiques avec des formes d'arguments spécifiques. Si le schéma d'outil d'un serveur MCP enveloppé change depuis que vous avez enregistré, la relecture doit refuser bruyamment, et non remplir silencieusement les mauvais arguments. reelier manifest estampe un condensat de schéma pour chaque outil que les étapes de la compétence utilisent réellement :

reelier manifest <skill.md> --wrap "<your mcp server>"   # stamp/refresh the manifest from live servers
reelier run <skill.md> --wrap "<your mcp server>"         # preflight checks the manifest BEFORE step 1 runs

Si le schéma d'un outil estampillé a dérivé (ou si l'outil a disparu), reelier run échoue en mode fermé — MANIFEST DRIFT — refusing to replay — avant que quoi que ce soit ne s'exécute. --ignore-manifest est le contournement explicite de sécurité pour quand vous savez que la dérive est acceptable ; c'est toujours enregistré sur l'exécution (manifestIgnored: true), donc ce n'est jamais un contournement silencieux. Une compétence sans aucun manifeste reçoit juste une note consultative — chaque compétence pré-manifeste continue de fonctionner sans modification.

Approbation d'écriture par étape : reelier approve

--allow-writes/--yes sont des drapeaux globaux — ils disent "cette exécution peut écrire", pas "cette écriture exacte est examinée". reelier approve lie par hachage l'approbation à l'outil + modèle d'argument d'une étape spécifique :

reelier approve <skill.md>          # walk each write/destructive step, y/N to approve
reelier approve <skill.md> --all    # approve every write step non-interactively

Une étape approuvée dont l'outil/les arguments correspondent toujours à son hachage estampillé s'exécute sans aucun drapeau. Si l'outil ou les arguments de l'étape ont changé depuis l'approbation, la relecture échoue en mode fermé — Approval mismatch — et aucun drapeau ne la contourne ; vous réexaminez et réapprouvez. Une étape d'écriture sans champ approve: conserve le comportement exact actuel de --allow-writes/--yes, inchangé.

Vérifier la valeur, pas seulement la forme

Les assertions d'une compétence sont ce qui fait d'une relecture une preuve. La grammaire vérifie le statut, la structure, et la valeur :

- assert: status == 200
- assert: json.results is array
- assert: json.count >= 1              # numeric range
- assert: json.plan is string          # type
- assert: json.id matches /^usr_/      # value pattern
- assert: body contains "ok"

Utilisez-le dans votre agent de codage (MCP)

reelier serve expose les propres commandes de Reelier en tant qu'outils MCP, afin que Claude Code / Cursor / Windsurf / Codex puisse les appeler en cours de session :

{ "mcpServers": { "reelier": { "command": "npx", "args": ["-y", "reelier", "serve"] } } }

L'agent obtient reelier_scan, reelier_from_session, reelier_replay, reelier_diff et reelier_push — avec des descriptions qui lui indiquent exactement quand utiliser chacun (et quand ne pas le faire). Il enregistre une tâche déterministe une fois, puis rejoue au lieu de re-raisonner.

Outils

• reelier_scan — analyser l'historique des sessions d'agent (Claude Code, Codex, Windsurf, OpenClaw) pour les workflows d'appels d'outils rejouables
• reelier_from_session — compiler une session enregistrée en un SKILL.md rejouable avec une assertion à chaque étape
• reelier_replay — rejouer une compétence de manière déterministe à 0 token LLM (lecture seule par défaut ; écritures bloquées derrière --allow-writes)
• reelier_diff — comparer deux exécutions : IDENTIQUE ou DÉRIVÉ par étape, avec l'assertion défaillante comme pourquoi ; sortie 1 en cas de dérive
• reelier_push — synchroniser un reçu d'exécution vers le registre pour un lien permanent partageable (opt-in)

La preuve mesurée

À partir d'un benchmark réel en tête-à-tête (agent vs. Reelier, même tâche, mêmes données) — tableaux complets + méthodologie dans examples/benchmark :

• 1 000 / 1 000 relectures identiques octet par octet (test de variance de queue N=1000)
• 0 token par relecture — vérifié à partir de l'enregistrement d'exécution, pas supposé
• ~50× moins cher (0,000000 $/relecture contre 0,019068 $/exécution en moyenne sur le bras agent)
• ~59× plus rapide (48 ms contre 2 842 ms de latence moyenne)
• une dérive réelle auto-guérie pour ~0,001 $, une fois, puis gratuite à chaque relecture ensuite

La latence varie selon le réseau — la relecture de Niveau 0 réexécute les appels d'outils de la compétence, donc le temps réel dépend de votre connexion. Ce qui ne varie pas : 0 token LLM, les mêmes étapes à chaque exécution, et le reçu. Corroboré indépendamment — arXiv 2605.14237 a trouvé une réduction de tokens de 93,3 à 99,98 % pour le même modèle enregistrer-et-rejouer.

Fonctionne avec n'importe quel modèle (BYOK)

La relecture de Niveau 0 (par défaut) n'appelle jamais de modèle — 0 token, par construction. L'escalade (--max-level 1|2) est optionnelle et passe par une surface BYOK étroite (--llm-base-url + --llm-model) : un adaptateur natif Anthropic Messages, et un adaptateur compatible OpenAI pour tout le reste (OpenRouter, Ollama, le point de terminaison OpenAI de Gemini, Groq, vLLM, LM Studio, Kimi, …). Pointez-le vers un modèle plus fort et la prochaine auto-guérison de chaque compétence devient plus intelligente gratuitement.

Possédez-le — MIT, BYOK, local d'abord

Utilisez-le n'importe où, intégrez-le dans n'importe quoi — pas de contraintes copyleft, pas d'examen juridique nécessaire. Vos compétences, traces et enregistrements d'exécution sont vos données — partir, c'est copier un dossier. Les formats sont spécifiés dans SPEC.md, une référence normative de style RFC pour que n'importe qui puisse les émettre ou les consommer sans lire la source.

Contribuer

Issues et PR bienvenus — voir SPEC.md pour les formats (la spec l'emporte sur le code ; corrigez le code, pas la spec). npm test exécute la suite complète ; npm run build && npx tsc --noEmit avant une PR.

git clone https://github.com/seldonframe/reelier && cd reelier
npm install && npm test

Historique des étoiles

Licence

MIT — libre de forker, intégrer, auditer et auto-héberger pour toujours. (Les versions ≤0.16.0 ont été publiées sous AGPL-3.0 et le restent.)