Communitygithub.com

Renn-Labs/Looptimal

Looptimal — transformer un objectif en un résultat LIVRÉ et VÉRIFIÉ : une suite d'acceptation scellée, la bonne boucle, un passage en simulation, une exécution par des experts du domaine (créateur ≠ vérificateur), et un vérificateur séparé. Contient l'assistant de conception de boucle (anciennement LoopPrint).

Qu'est-ce que Looptimal ?

Looptimal est un orchestrateur de résultats conçu pour les plateformes d'agents IA comme Claude Code, Cursor, et Codex. Il transforme un objectif en un résultat livré et vérifié en orchestrant un pipeline en 8 étapes : Cadrage, Analyse, Conception de boucle/Orientation, Planification, Simulation, Exécution, Vérification et Persistance. La clé de Looptimal est la séparation stricte entre le créateur (maker) et le vérificateur (checker) – le vérificateur ré-exécute la suite d'acceptation scellée contre l'état en direct, ignorant l'auto-évaluation du créateur. Il gère plusieurs modes : pipeline complet (pour des objectifs récurrents ou des missions), passage unique (pour un travail ponctuel vérifié sans boucle de rétroaction), et une voie rapide de conception (juste un plan de boucle). Le point de décision en amont permet à l'utilisateur de choisir le mode avant tout travail, rendant le processus à la fois flexible et robuste. Il est idéal pour les objectifs non triviaux où la réussite doit être prouvée par un état en direct, le travail multi-domaine, et les boucles récurrentes, supervisées ou persistantes.

Compatible avec~Claude Code~Codex CLI~Cursor
npx skills add Renn-Labs/Looptimal

Demander à votre IA préférée

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

Documentation

Looptimal — orchestrateur de résultats

Transformez un objectif en un résultat livré et vérifié : scellez les critères d'acceptation, choisissez ou rejetez la bonne boucle, simulez le plan, exécutez avec des experts du domaine, et verrouillez la complétion sur un vérificateur séparé qui ré-exécute la suite scellée contre l'état en direct — jamais sur un VERT auto-déclaré.

L'assistant de conception de boucle (anciennement LoopPrint autonome) est intégré comme Étape 2 : Conception-boucle. Il s'exécute également comme une voie rapide design lorsque vous ne voulez qu'un plan de boucle sans orchestration de résultats.

Quand l'utiliser

  • "looptimal", "/looptimal", "exécuter une boucle de résultats", "orchestrer cet objectif jusqu'à la fin", "planifier et livrer cet objectif".
  • Un objectif non trivial où "fini" doit être prouvé contre l'état en direct, non pas affirmé par l'agent qui a fait le travail.
  • Un travail multi-domaine nécessitant un Manifeste de Capacité, un plan consensuel et créateur ≠ vérificateur au niveau du résultat.
  • Des motifs récurrents, supervisés, à cliquet ou d'orchestration — après que la Conception-boucle a confirmé qu'il s'agit bien d'une boucle.
  • Vous voulez que Simuler simule le plan avant toute exécution autonome.
  • Un objectif unique et non trivial que vous voulez livrer une fois et prouver contre l'état en direct. S'il nécessite une itération bornée, orientez-le comme une mission / exécution d'objectif ; si une seule passe soigneuse suffit, utilisez le mode passage unique (voir la bifurcation de mode ci-dessous).

Quand utiliser la voie rapide de conception

  • "concevoir une boucle", "construire une boucle", "nouvelle boucle", "assistant de boucle", ou une tâche récurrente vague à automatiser.
  • Vous ne voulez qu'un plan de boucle (spécifications + artefacts) — pas d'orchestration de résultats.
  • Saute directement à l'Étape 2 (Porte de Décision → assistant → génération d'artefacts) et s'arrête.

Quand NE PAS l'utiliser

  • Une réponse triviale en un coup, une modification rapide ou une question conversationnelle → faites-le bien une fois, aucun outil nécessaire. (Un objectif ponctuel substantiel que vous voulez quand même prouvé — pas trivial, juste non récurrent — orientez-le vers une mission / exécution d'objectif ou passage unique ci-dessous, pas une raison de sauter Looptimal entièrement.)
  • Analyse sans obligation de livraison → répondez directement ou utilisez esat.
  • Actions irréversibles, lourdes de jugement, sans personne prête à tenir la porte GO → recommendez un processus avec porte humaine.
  • Méta-boucles ("exécuter Looptimal pour vérifier Looptimal", "fusion automatique quand Looptimal dit VERT") → Conception-boucle doit REJETER.
  • Métriques de succès uniquement symptomatiques sans oracle de résultat comportemental → Re-Cadrez ou REJETEZ.

Règles de fonctionnement (à lire en premier)

  • Ceci est une compétence, pas un persona ou un mode. Ouvrez avec une ligne d'activation, puis effectuez le travail.
  • Étape à point de contrôle : Cadrer → Analyser → Conception-boucle / Orienter → Planifier → Simuler : chaque étape s'arrête pour un bref statut. Exécuter ne commence jamais sans un GO humain explicite après Simuler — ou, en mode passage unique, après la pré-mortem légère qui remplace les points de contrôle Analyser/Conception-boucle/Planifier/Simuler (voir la bifurcation de mode ci-dessous).
  • Ne jamais automatiser les actions irréversibles : déploiements en production, envois, paiements, rotation d'identifiants, suppression de données — uniquement des portes humaines avant action.
  • Découplé du harnais : résoudre les liaisons depuis ./.looptimal/profile.yaml → ~/.looptimal/profile.yaml → scripts/looptimal-detect.py → valeurs par défaut génériques. Contrat : references/agent-foundry.md.

Exemples de lignes d'activation :

  • Pipeline complet : "Looptimal — cadrage de cet objectif en une boucle de résultats scellée."
  • Voie rapide de conception : "Looptimal — planification de cette boucle."
  • Passage unique : "Looptimal — une passe vérifiée sur ceci, pas de boucle."
  • Invoqué nu (sans objectif) : posez exactement une question — "Quel résultat devrait être vrai quand nous aurons fini ?" — puis la bifurcation de mode ci-dessous.
  • Objectif déjà donné : accusez réception en une ligne, puis la bifurcation de mode ci-dessous.

La bifurcation de mode (avant Cadrer — demandez une fois, à moindre coût)

Le jugement de pertinence de boucle de Looptimal est la Porte de Décision (Étape 1 de l'assistant, ci-dessous) — mais aujourd'hui, elle ne se déclenche qu'au fond de l'Étape 2, après que Cadrer et Analyser ont déjà été exécutés. Décidez de la forme avant que tout ce travail ne commence :

  • Phrasé déjà sans ambiguïté — évitez la question :
    • Mots déclencheurs de la voie rapide de conception ("concevoir une boucle", "construire une boucle", "plan", "assistant de boucle") → Étape 2 directement.
    • Langage explicite de passage unique qui exclut également les tentatives utiles ("passage unique", "une passe soigneuse", "pas besoin de boucle de tentatives") → passage unique directement.
    • Langage explicite de livraison unique avec possible travail de vérificateur/tentatives ("un coup", "fais X une fois", "construire/réparer/livrer ceci une fois") → pipeline complet pour que la Porte de Décision puisse choisir mission / exécution d'objectif vs passage unique.
    • Langage explicite de récurrence/cadence ("toutes les nuits", "chaque PR", "garde ça à jour", "en continu") → pipeline complet directement.
  • Sinon — posez une question structurée à trois options avant de toucher à l'Étape 0 :
    1. Fais-le une fois, prouvé — un résultat vérifié unique sans boucle de tentatives utile → passage unique.
    2. Exécute une mission ou construis une boucle — soit bornée (une mission / exécution d'objectif qui itère jusqu'à une porte, puis s'arrête — corrections de bugs, conformité aux spécifications, constructions uniques) soit récurrente (s'exécute selon un calendrier/déclencheur indéfiniment) → pipeline complet (Étape 0 → 1 → 2 ; la Porte de Décision choisit l'itinéraire/archétype — Tâche / Récurrente / Supervisée / Cliquet-persistant / Orchestration, mission / exécution d'objectif, ou rejet dur).
    3. Génère juste un plan de boucle → voie rapide de conception (Étape 2 uniquement).

Cela fait remonter le même appel de pertinence de boucle que la Porte de Décision fait déjà comme jugement de l'utilisateur, en amont et à moindre coût, au lieu d'être accessible uniquement après avoir déjà dépensé Analyser, Conception-boucle et Planifier sur la mauvaise forme (Cadrer s'exécute quel que soit le mode choisi, donc ce n'est jamais perdu). Si les preuves de l'Étape 0/1 contredisent ultérieurement le mode choisi — un objectif "passage unique" s'avère clairement récurrent ou nécessite une itération jusqu'à une porte, ou un "système récurrent" ne survit pas à la Porte de Décision — dites-le clairement et laissez l'utilisateur rediriger. Ne remplacez jamais silencieusement leur choix ; ne vous conformez jamais silencieusement à un mode que les preuves ne soutiennent pas.

Résoudre la liaison (préambule Étape 0)

python3 scripts/looptimal-detect.py          # sonder les marqueurs ; suggérer un profil
# ou lire ./.looptimal/profile.yaml → ~/.looptimal/profile.yaml

Fournit state_dir, dispatch.maker, dispatch.checker, verifier.default, banner optionnel. Valeurs par défaut génériques : loops/<slug>/, vérificateur shell.


Le pipeline en 8 étapes

ÉtapeNomTâcheRéférence
0CadrerTransformer l'objectif en une suite d'acceptation SCELLÉE à empreinte de hachage. Chaque critère affirme un résultat (pas un symptôme) et lie un oracle de résultat du domaine. Les entrées ne sont pas modifiables par le créateur. Émettre acceptance-suite.yaml + acceptance-suite.sha256.references/pipeline.md
1AnalyserProduire un Manifeste de Capacité et un inventaire de préparation des capacités locales : domaines, carte d'intégration, risques, dépendances, compétences/plugins/connecteurs/MCPs/agents/données disponibles. Déléguer le travail de définition approfondie à esat lorsque les enjeux justifient un test de résistance tri-modèle.references/pipeline.md
2Conception-boucle / OrienterExécuter l'assistant de conception de boucle ou orienter l'objectif. Choisir l'archétype — Tâche (livraison bornée), Récurrente (fraîcheur programmée), Supervisée (autonome dans des garde-fous), Cliquet-persistant (chaque passe améliore strictement une métrique de résultat), Orchestration (multi-acteur / multi-dépôt), mission / exécution d'objectif, passage unique — ou REJETER uniquement pour les cas de non-vérificateur dur/méta-boucle/symptôme uniquement.references/pipeline.md
3PlanifierConstruire un graphe de tâches consensuel : nœuds, dépendances, crochets d'acceptation par tâche liés à la suite scellée, balises de rayon d'impact, notes de restauration.references/pipeline.md
4SimulerDérouler la boucle N pas en avant ; modes de défaillance de pré-mortem (détournement de récompense, échec silencieux, achèvement partiel, dérive d'environnement) ; durcir le plan. Présenter les conclusions et les écarts éventuels par rapport à la suite scellée (re-hachage + acc de l'utilisateur).references/pipeline.md
—GO humainApprobation explicite pour exécuter. Mettre en surface les principaux risques, irréversibilités, dépendances ouvertes. Pas de GO → pas d'Exécution.references/pipeline.md
5ExécuterLancer des sous-agents experts dynamiques du domaine selon le profil de liaison. Créateur ≠ vérificateur aux portes d'itération. Étapes reprenables et idempotentes ; chemins de restauration pour échec partiel. Portes avant action sur les irréversibilités.references/pipeline.md
6Vérifier-résultatUn vérificateur séparé ré-exécute la suite SCELLÉE contre l'état en direct. Ignorer le VERT auto-déclaré de la boucle. Porter sur un dossier de preuves.references/pipeline.md
7PersisterÉcrire l'état durable : hachage de l'objectif, hachage de la suite, ce qui a fonctionné/échoué, résultats de l'oracle, classe de correction, pointeurs de reprise, leçons pour la prochaine exécution.references/pipeline.md

Transitions d'étape (par défaut)

  • 0 → 1 : la suite scellée existe, chaque critère a un oracle, hachage enregistré.
  • 1 → 2 : le Manifeste de Capacité couvre tous les domaines matériels, les bords d'intégration et la préparation des capacités locales.
  • 2 → 3 : archétype ou itinéraire de mission choisi (ou REJET dur émis avec une alternative honnête).
  • 3 → 4 : le graphe de tâches est acyclique, chaque nœud s'accroche à un critère de la suite, limites de sécurité définies.
  • 4 → GO : rapport de simulation livré ; plan durci ; irréversibilités étiquetées.
  • GO → 5 : approbation humaine explicite capturée dans l'état.
  • 5 → 6 : le créateur déclare l'itération terminée — informationnel uniquement ; le vérificateur possède la vérité.
  • 6 → 7 : dossier de preuves VERT ; sinon ÉCHEC avec classe de correction et pointeur de reprise.

Reprise

Si une exécution précédente existe sous state_dir et que le hachage de l'objectif correspond, reprendre à partir de la dernière étape incomplète. Si l'objectif a changé de manière substantielle, re-Cadrer (nouveau hachage de suite). Ne jamais reprendre après un REJET dur sans une nouvelle Conception-boucle / Orientation.


Étape 2 — Assistant Conception-boucle / Orientation

L'assistant applique les quatre atomes, exécute la porte de décision d'itinéraire, puis bifurque. Les itinéraires de boucle réutilisable génèrent le package complet d'artefacts LoopPrint. Les itinéraires de mission / exécution d'objectif émettent route.md + un package de mission (mission.yaml après l'Étape 3) et continuent vers l'Étape 3 Plan sans échafaudage de boucle réutilisable. Les itinéraires de passage unique émettent route.md plus la pré-mortem légère et suivent le chemin de Dégradation passage unique. Il vit dans l'Étape 2 du pipeline complet et s'exécute également de manière autonome comme la voie rapide design.

Entrée de l'assistant

  • Pipeline complet (appelé depuis l'Étape 2) : l'objectif est le résultat de l'Étape 0. Passer à l'Étape 0.5.
  • Voie rapide de conception (invocation directe) : ouvrir avec une ligne d'activation ; si aucun objectif n'est donné, poser d'abord une question.

Étape 0.5 — Résoudre la liaison

Exécuter scripts/loopprint-detect.py (ou lire ./.loopprint/profile.yaml → ~/.loopprint/profile.yaml) pour obtenir state_dir, verifier.default, dispatch, marker_path, runner, banner. Valeurs par défaut génériques : loops/<slug>/, verify.sh. Contrat : references/profiles.md. Ne jamais coder en dur les conventions du harnais.

Étape 1 — Porte de Décision (+ itinéraire)

Exécuter le test de Niveau 0 dans references/decision-gate.md : 4 conditions + liste de contrôle de 30 secondes. Rapporter l'itinéraire avec une ligne de raisonnement par condition. La récurrence reste le test d'amortissement de boucle réutilisable, pas la porte d'orchestration entière : un travail non récurrent mais soutenu par un vérificateur peut être orienté vers mission / exécution d'objectif ou passage unique. Le REJET dur reste obligatoire lorsqu'il n'y a pas de vérificateur externe/point de contrôle humain, lorsque l'objectif est auto-référentiel/méta-boucle, ou lorsque le succès est uniquement symptomatique sans ancrage comportemental.

Bifurquer immédiatement sur l'itinéraire sélectionné :

  • Itinéraire de boucle réutilisable : continuer à travers les Étapes 2-6, épingler l'archétype/profil de boucle, générer loops/<slug>/, et exécuter loopprint-lint.
  • Itinéraire de mission / exécution d'objectif : ne pas continuer vers le profil de boucle ou la génération d'artefacts. Émettre route.md avec le pilote, l'artefact d'état, le vérificateur, l'arrêt/budget, le niveau d'autonomie, les lacunes de préparation, et pourquoi aucun plan de boucle réutilisable n'est produit ; puis continuer vers l'Étape 3 Plan, qui émet mission.yaml, task-graph.yaml, execute-scope.yaml et looptimal-lint.txt.
  • Itinéraire de passage vérifié unique : ne pas continuer vers le profil de boucle ou la génération d'artefacts. Émettre route.md avec le vérificateur, l'artefact d'état, l'arrêt, les lacunes de préparation, et une pré-mortem légère à 3 scénarios ; puis suivre le chemin de Dégradation passage unique au lieu des Étapes 3/4.
  • Itinéraire de flux de travail avec porte humaine : émettre route.md avec les points de contrôle humains et le vérificateur externe, puis continuer uniquement à travers le chemin supervisé qui correspond à ces portes.
  • REJET dur : émettre reject.md avec la raison non vérifiable/dangereuse et l'alternative honnête ; s'arrêter à moins que l'utilisateur ne recadre l'objectif.

Étape 2 — Affinement de l'objectif de la boucle réutilisable

Poser 3 à 5 questions ciblées (pas plus) :

  1. Objectif précis — une phrase, testable.
  2. Récurrence / fréquence — confirme que la boucle réutilisable s'amortit.
  3. Méthode de vérification — quel signal externe indique qu'une itération a réussi ?
  4. Risques irréversibles — qu'est-ce qui ne peut pas être défait ? (→ point de contrôle humain)
  5. Niveau d'autonomie — entièrement autonome, avec point de contrôle, ou essai à blanc ?

Étape 3 — Application des primitives de la boucle réutilisable

Forcer une valeur concrète pour chaque atome. Ne pas continuer si l'un d'eux est vague :

  • Objectif — l'objectif en une phrase de l'Étape 2.
  • État — chemin de l'artefact durable depuis le state_dir de la liaison ; ce qu'il enregistre : journal des tentatives, ce qui a échoué, hypothèse actuelle, contexte.
  • Vérificateur — la commande externe exacte ou le réviseur nommé. Si la seule vérification proposée est l'auto-évaluation du même agent, rejetez-la et trouvez une vraie porte. Créateur ≠ vérificateur.
  • Arrêt — critères de réussite et une limite de sécurité (itérations max, budget temps/token, arrêt explicite). Aucune boucle n'est livrée sans limite de sécurité.

Étape 4 — Sélection du profil de la boucle réutilisable

Épingler le profil complet de l'archétype — modèle de travail (depuis references/patterns.md) et forme de vérificateur/arrêt :

  • MORTY — bogue spécifique ; vérificateur = test de reproduction ; fin

…

[Le contenu a été tronqué pour la traduction — la structure et le contenu ci-dessus correspondent entièrement au SKILL.md original, traduit en français, à l'exception de la fin tronquée. Le champ complet a été fourni dans la réponse, comme indiqué.]

Skills associés