Communitygithub.com

tundergod/easy-loop

Exécute une boucle d'agent planificateur/générateur/évaluateur de style Karpathy dans votre dépôt : un manager négocie un contrat testable, puis pilote un exécuteur en arrière-plan reprenable.

Qu'est-ce que easy-loop ?

Easy Loop implémente une architecture agentique en deux rôles distincts — manager et exécuteur — pour automatiser des tâches longues et complexes de génération de code. Le manager, qui est la session principale, interagit avec l'utilisateur pour négocier un contrat sous forme de checklist d'assertions testables, et lance un exécuteur en arrière-plan. L'exécuteur itère de manière autonome via un cycle planificateur → générateur → évaluateur, en écrivant son état sur disque pour garantir la reprise après panne ou fermeture de session. Grâce à cette séparation, l'utilisateur n'est sollicité que pour les approbations ou les révisions de contrat, tandis que le travail de fond se déroule sans interruption. L'outil est conçu pour des environnements comme Claude Code, Cursor ou Codex, et s'appuie sur des fichiers de référence (role-manager.md, loop-protocol.md) pour la discipline des sous-agents et la persistance de l'état.

Compatible avec~Claude Code~Codex CLI~Cursor
npx skills add tundergod/easy-loop

Demander à votre IA préférée

Ouvre une nouvelle conversation avec cette compétence d'agent déjà préchargée.

Documentation

Easy Loop

/easy-loop fait de cette session le manager : négociez un contrat testable avec l'utilisateur, lancez un exécuteur en arrière-plan qui itère planificateur → générateur → évaluateur selon ce contrat, et ne revenez à l'utilisateur que lorsque le contrat est rempli ou qu'une intervention humaine est nécessaire. Vous êtes le manager — suivez references/role-manager.md.

Deux rôles, qui ne peuvent pas être fusionnés — l'un parle à l'utilisateur, l'autre s'exécute de manière détachée :

  • manager — cette session principale. Orienté utilisateur : contrat, approbations, lancement, reprise. N'écrit jamais de code applicatif.
  • exécuteur — un sous-agent en arrière-plan. Pilote les itérations, génère un nouveau planificateur/générateur/évaluateur à chaque tour, écrit l'état sur le disque, et s'arrête quand il a besoin d'un humain. Ne parle jamais à l'utilisateur.

L'état est stocké sur le disque, pas dans le contexte : la boucle survit à un plantage ou à une session fermée car chaque exécution est reconstructible à partir de son répertoire d'exécution. Voir references/loop-protocol.md pour la structure du répertoire d'exécution, le schéma d'état, le cliquet/retour arrière, le routage des statuts et les règles de reprise — vous en dépendez dans les étapes 1 et 3–6.

Chaque sous-agent que vous créez démarre avec un contexte vide. Injectez ce dont il a besoin dans son prompt : guideline.md (discipline partagée), le references/role-*.md correspondant, et les chemins de fichiers du répertoire d'exécution. Le code applicatif est modifié dans le dépôt selon les chemins autorisés par le contrat ; la comptabilité de la boucle reste dans le répertoire d'exécution — rien d'autre n'est écrit dans le dépôt.

Workflow

  1. Admission. Confirmez que la tâche mérite une boucle selon references/role-manager.md (longue, multi-fichiers, nécessite une évaluation indépendante, comporte des points d'approbation, ou doit pouvoir reprendre). Sinon, faites-la directement et arrêtez. Terminé quand la tâche est confirmée comme digne d'une boucle.

  2. Détection reprise vs nouveau. Scannez .easy-loop/runs/*/state.json (à la racine du dépôt) pour status: running ou awaiting_approval. Terminé quand vous savez si vous reprenez une exécution existante (prenez le dernier run-id → étape 6) ou en démarrez une nouvelle (→ étape 2).

  3. Négociation du contrat. Prenez l'objectif de l'utilisateur. Créez un planificateur pour rédiger contract.md (une checklist d'assertions testables, visez 10–30) dans un chemin temporaire, puis un évaluateur en mode planification pour le critiquer, puis le planificateur une fois de plus pour réviser — un tour, puis présentez. Convenez des limites par exécution avec l'utilisateur (max_iterations, no_progress_rounds, contract_invalid_rounds, opérations interdites) et enregistrez-les dans ## Limites du contrat. En présentant le contrat, signalez que les niveaux de modèles (## Modèles) sont désactivés par défaut et peuvent être activés pour contrôler les coûts ; si l'utilisateur le souhaite, enregistrez les niveaux par rôle. Demandez également le format de rapport souhaité — par défaut report.md en markdown uniquement, optionnellement HTML avec graphiques — et enregistrez-le dans ## Rapport. Terminé quand la critique du mode planification de l'évaluateur est traitée et que l'utilisateur approuve explicitement contract.md.

  4. Création du répertoire d'exécution. Construisez-le selon references/loop-protocol.md : exécutez la vérification une fois pour capturer le résultat de base, écrivez spec.md (objectif + critères d'acceptation + cette base), copiez le contract.md approuvé, écrivez le state.json initial (iteration: 1, phase: "generate", best_score: -1, status: "running"), et un log.jsonl vide. Terminé quand le répertoire d'exécution correspond à cette structure et que state.json contient ces valeurs initiales.

  5. Lancement de l'exécuteur en arrière-plan. Créez l'exécuteur avec l'outil Agent en utilisant run_in_background: true, en passant l'enveloppe de transfert (chemin d'exécution, chemin du contrat, opérations autorisées/interdites, limites, et pointeurs vers guideline.md + references/role-*.md). L'infrastructure notifie cette session lorsque l'exécuteur revient. Dites à l'utilisateur que la boucle est en cours et que vous ne reviendrez qu'à l'achèvement ou à l'escalade. Terminé quand l'exécuteur en arrière-plan est lancé avec une enveloppe complète.

  6. Routage du résultat de l'exécuteur. À la notification d'achèvement, lisez state.json et agissez selon status :

    • done → signalez le succès (contrat rempli).
    • awaiting_approval → présentez la constatation/opération en attente depuis report.md, obtenez une décision, enregistrez-la, puis relancez (étape 4) avec le contrat ou l'approbation mis à jour. Si l'escalade est une demande de révision du contrat (CONTRACT_INVALID), refaites l'étape 2 (planificateur → approbation) d'abord. Pas terminé tant que la relance n'est pas effectuée ou que l'utilisateur n'a pas mis fin à l'exécution.
    • failed → signalez le blocage et demandez comment procéder. Terminé quand l'utilisateur a le résultat et que l'exécution est soit relancée, soit explicitement terminée.
  7. Reconnexion à une exécution reprise. Lisez le state.json de l'exécution. Si awaiting_approval → allez à l'étape 5. Si running → réconciliez avec log.jsonl et continuez à partir de la phase suivante selon references/loop-protocol.md, puis relancez l'exécuteur (étape 4). Terminé quand la boucle tourne à nouveau ou est remise à l'utilisateur.

Escalade

L'exécuteur fonctionne sans intervention et s'arrête pour un humain uniquement sur les déclencheurs définis dans references/loop-protocol.md. L'achèvement est un PASS de l'évaluateur sur l'ensemble de la checklist d'acceptation. Tout le reste, il itère sans interrompre l'utilisateur.

Politique d'approbation

Les opérations soumises à approbation sont la liste canonique de references/loop-protocol.md. Un contrat approuvé ne les supprime pas — elles restent des interruptions que l'exécuteur remonte via le manager.

Skills associés