Compétence Idée

Cette compétence couvre l'étape Idéation du flux de travail AI-DLC : réclamer des Idées, exécuter des rounds d'élaboration structurés pour clarifier les exigences, et préparer la création de Propositions.

Espace de noms des outils : Les outils Chorus sont exposés par le serveur MCP connecté sous un préfixe chorus__ sur OpenClaw (par ex. chorus__chorus_get_idea). Les noms simples sont utilisés ci-dessous pour la lisibilité — ajoutez chorus__ lors de l'invocation. Voir /chorus pour la règle complète.

Aperçu

Les Idées sont le point de départ du pipeline AI-DLC. Les humains (ou les agents Admin) créent des Idées décrivant ce dont ils ont besoin. L'Agent PM réclame une Idée, exécute l'élaboration pour clarifier les exigences, puis passe à /proposal pour créer une Proposition avec des brouillons de documents et de tâches.

Cycle de vie du statut d'Idée (3 états stockés) :

open --> elaborating --> elaborated

Toute progression post-élaboration (planification, construction, vérification, terminé) est dérivée de l'état des Propositions et Tâches liées. Aucun agent ne doit définir le statut d'Idée directement au-delà de l'élaboration — toutes les transitions sont des effets secondaires de la réclamation, de la libération ou de l'achèvement de l'élaboration.

Outils

Gestion des Idées :

Élaboration des Exigences :

Outils partagés (checkin, requête, commentaire, recherche, notifications) : voir /chorus

Flux de travail

Étape 1 : Checkin

chorus_checkin()

Vérifiez votre persona, les assignations actuelles et les comptages de travail en attente.

Étape 2 : Trouver du travail

chorus_get_available_ideas({ projectUuid: "<project-uuid>" })

Ou vérifiez les assignations existantes :

chorus_get_my_assignments()

Étape 3 : Réclamer une Idée

La réclamation effectue automatiquement la transition de l'Idée au statut elaborating :

chorus_claim_idea({ ideaUuid: "<idea-uuid>" })

Étape 4 : Rassembler le contexte

Avant l'élaboration, comprendre la situation complète :

1. Lire l'idée en détail :

   chorus_get_idea({ ideaUuid: "<idea-uuid>" })

2. Lire les documents de projet existants (pour le contexte, la pile technologique, les conventions) :

   chorus_get_documents({ projectUuid: "<project-uuid>" })
   chorus_get_document({ documentUuid: "<doc-uuid>" })

3. Vérifier les propositions passées (pour comprendre les modèles et les normes) :

   chorus_get_proposals({ projectUuid: "<project-uuid>", status: "approved" })

4. Vérifier les tâches existantes (pour éviter la duplication) :

   chorus_list_tasks({ projectUuid: "<project-uuid>" })

5. Lire les commentaires sur l'idée pour plus de contexte :

   chorus_get_comments({ targetType: "idea", targetUuid: "<idea-uuid>" })

Étape 4.5 : Mode Brainstorming (Prélude optionnel)

Si l'Idée est floue et vous auriez du mal à énumérer des questions multi-choix concrètes, offrez à l'utilisateur un prélude de brainstorming avant l'élaboration structurée.

Remarque OpenClaw : il n'existe pas de primitive AskUserQuestion. Posez à l'utilisateur une seule fois en tant que prompt en texte brut s'il souhaite d'abord brainstormer ou passer directement à l'élaboration structurée, par ex. :

« Cette idée est encore floue. Voulez-vous (A) brainstormer ensemble les directions, ou (B) passer directement à l'élaboration structurée ? Répondez A ou B. »

• « Déjà clair » (B) : Passez à l'Étape 5.
• « Brainstormer d'abord » (A) : Invoquez la compétence /brainstorm. Voir /brainstorm pour la cadence du dialogue et les règles de synthèse — N'implémentez PAS ces règles ici.

Lorsque /brainstorm retourne, vous possédez la décision de cycle de vie (la compétence brainstorm la laisse intentionnellement à vous) :

• Si les réponses du round synthétisé couvrent tout → obtenez une confirmation humaine, puis appelez chorus_pm_validate_elaboration pour marquer l'élaboration comme complète. (Nécessite idea:admin — voir Étape 5.6 si votre clé est pm_agent-preset.)
• Si des lacunes demeurent → appelez chorus_pm_start_elaboration à nouveau pour ouvrir un Round 2 structuré. Choisissez la profondeur vous-même — NE redemandez PAS à l'utilisateur.

L'un ou l'autre résultat termine l'Étape 4.5 ; ignorez l'Étape 5.

Étape 5 : Élaborer sur l'Idée

Chaque Idée doit passer par l'élaboration. Ignorez-la uniquement quand les exigences sont complètement sans ambiguïté (par ex., correction de bogue avec étapes claires). L'élaboration améliore la qualité de la Proposition et réduit les cycles de rejet.

Idées simples (ignorer l'élaboration)

Vous pouvez ignorer l'élaboration, mais vous DEVEZ d'abord demander la permission à l'utilisateur avant d'appeler chorus_pm_skip_elaboration. Sur OpenClaw, posez la question en tant que prompt en texte brut (par ex. « Cette idée a des étapes de reproduction claires. OK pour ignorer l'élaboration ? Répondez oui/non. »). N'ignorez jamais selon votre seul jugement.

chorus_pm_skip_elaboration({
  ideaUuid: "<idea-uuid>",
  reason: "Bug fix with clear reproduction steps"
})

Idées standard/complexes (exécuter l'élaboration)

L'élaboration est une boucle, pas une ligne droite. Les Étapes 2–5 ci-dessous constituent un round. Continuez à faire boucler vers chorus_pm_start_elaboration (un nouveau round) jusqu'à ce que chaque question ouverte soit réglée, puis résolvez une seule fois à l'Étape 6. Vous réentrez dans la boucle chaque fois que :

• les réponses à un round dérivent de nouvelles questions ou découvrent une contradiction/lacune, ou
• à la porte de résolution (Étape 5d / Étape 6) l'humain soulève une nouvelle préoccupation ou correction (une réponse en texte brut sur OpenClaw).

Chaque nouveau round est juste un autre appel chorus_pm_start_elaboration — il n'existe pas de drapeau « suivi » distinct, et vous ne résolvez pas avant que la boucle soit véritablement terminée. Le plafond de rounds est 10.

1. Déterminer la profondeur en fonction de la complexité de l'idée :

   • "minimal" — 2-4 questions (petites fonctionnalités, améliorations mineures)
   • "standard" — 5-10 questions (nouvelles fonctionnalités typiques)
   • "comprehensive" — 10-15 questions (grandes fonctionnalités, changements architecturaux)

2. Créer des questions d'élaboration :

   Remarque : N'incluez PAS une option « Autre » dans vos questions. Traitez le chemin en texte libre comme toujours disponible — un utilisateur peut répondre à n'importe quelle question avec du texte libre au lieu de choisir une option.

   chorus_pm_start_elaboration({
     ideaUuid: "<idea-uuid>",
     depth: "standard",
     questions: [
       {
         id: "q1",
         text: "What user roles should have access to this feature?",
         category: "functional",
         options: [
           { id: "a", label: "All users" },
           { id: "b", label: "Admin only" },
           { id: "c", label: "Role-based (configurable)" }
         ]
       }
     ]
   })

3. Présenter les questions à l'utilisateur en texte brut (OpenClaw n'a pas de AskUserQuestion). Restituez chaque question d'élaboration et ses options comme un prompt numéroté/lettré lisible et demandez à l'utilisateur de répondre avec ses sélections (et notes en texte libre). Exemple :

   J'ai quelques questions pour clarifier cette idée. Veuillez répondre avec votre choix pour chacune (vous pouvez aussi écrire une réponse en texte libre) :
   
   1. Quelles nouvelles locales devraient être prioritaires pour la V1 ?
      a) Japonais uniquement — locale unique pour la version initiale
      b) Japonais + Coréen — deux locales d'Asie de l'Est
      (ou décrivez votre propre réponse)
   
   2. ...

   Après que l'utilisateur répond, mappez ses réponses retour vers les IDs d'option et appelez chorus_answer_elaboration. Si l'utilisateur a donné une réponse en texte libre qui ne correspond pas à une option, définissez selectedOptionId: null et mettez son texte dans customText.

4. Soumettre les réponses :

   chorus_answer_elaboration({
     ideaUuid: "<idea-uuid>",
     roundUuid: "<round-uuid>",
     answers: [
       { questionId: "q1", selectedOptionId: "c", customText: null },
       { questionId: "q2", selectedOptionId: null, customText: "Custom hybrid approach" }
     ]
   })

   Format de réponse :

   • Sélectionner une option : selectedOptionId: "a", customText: null
   • Sélectionner une option + ajouter une note : selectedOptionId: "a", customText: "additional context"
   • Texte libre (aucune option correspondante) : selectedOptionId: null, customText: "your answer" — customText est nécessaire quand aucune option n'est sélectionnée

   roundUuid est optionnel sur chorus_answer_elaboration. Omettez-le et le service localise automatiquement le round actif (pending_answers) unique de l'Idée. Passez-le explicitement uniquement quand vous devez cibler un round spécifique.

5. Vérifier les réponses et confirmer avec le propriétaire (flux @mention) :

   Après que les réponses sont soumises, @mentionnez le répondeur (généralement le propriétaire de l'agent) avec un résumé de votre compréhension. Cela empêche les erreurs d'interprétation avant la validation.

   a. Obtenir les infos du propriétaire à partir de la réponse checkin (agent.owner) ou recherchez :

      chorus_search_mentionables({ query: "owner-name" })

   b. Publier un commentaire résumé sur l'idée :

      chorus_add_comment({
        targetType: "idea",
        targetUuid: "<idea-uuid>",
        content: "@[Owner Name](user:owner-uuid) I've reviewed the elaboration answers. Here's my understanding:\n\n- Key requirement 1: ...\n- Key requirement 2: ...\n\nDoes this match your intent?"
      })

   c. Attendre la confirmation via les commentaires.

   d. En fonction de la réponse — c'est le point de décision de boucle :

   • Confirmé, rien de plus à discuter — Traitez cela comme la confirmation humaine nécessaire pour résoudre ; passez à l'Étape 6 et appelez chorus_pm_validate_elaboration.
   • L'humain soulève une nouvelle préoccupation / correction / question — NE résolvez PAS. Faites boucler : ouvrez un nouveau round avec chorus_pm_start_elaboration capturant les nouvelles questions, collectez les réponses (Étapes 2–5 à nouveau), et re-confirmez. Répétez jusqu'à ce que l'humain n'ait plus de préoccupations.
   • Les réponses elles-mêmes ont dérivé de nouvelles questions ou une contradiction — Idem : faites boucler vers chorus_pm_start_elaboration pour un autre round avant de résoudre.
   • Flou — Posez des questions clarificatrices via un autre commentaire, puis continuez la boucle.

6. Résoudre l'élaboration (la porte de commit unique — uniquement quand la boucle est terminée) :

   La résolution marque la phase d'élaboration entière comme complète — elle définit idea.elaborationStatus = "resolved" (Idée → elaborated), qui est le signal de gating qui permet à une Proposition en aval d'être soumise. C'est une action au niveau Idée (prend seulement ideaUuid, ne cible pas un round). Résolvez une seule fois, uniquement après que la boucle de l'Étape 5d s'est complètement réglée — chaque question dérivée répondue et l'humain n'a pas de préoccupations restantes. S'il y a quelque chose qui est encore ouvert, retournez à chorus_pm_start_elaboration au lieu de résoudre.

   Précondition : résoudre nécessite que l'Idée ait au moins un round et que chaque round soit complètement répondu (aucun laissé dans pending_answers). Si un round a encore des questions ouvertes, répondez-y (ou il sera rejeté).

   ⚠️ Confirmation humaine requise. En dehors de l'automatisation YOLO vous DEVEZ obtenir une confirmation humaine explicite avant de résoudre (un simple prompt oui/non en texte brut va bien sur OpenClaw). La réponse « Confirmé » à l'étape 5d ci-dessus compte comme cette confirmation. Ne résolvez jamais selon votre seul jugement.

   Permission (N1) : chorus_pm_validate_elaboration nécessite idea:admin. Le preset pm_agent accorde seulement idea:write, donc un agent preset PM ne peut pas résoudre — il doit déléguer à un agent preset admin_agent (ou une clé API admin) pour effectuer la résolution. Si votre clé manque idea:admin, signalez cela à l'humain et demandez la délégation au lieu d'échouer silencieusement.

   Précondition d'assigné (N2) : l'acteur qui résout doit être l'assigné de l'Idée. Un réviseur humain distinct résolvant une Idée appartenant à PM doit donc avoir à la fois idea:admin et être assigné à l'Idée (réclamez/réassignez-la en premier). La permission d'admin seule ne suffit pas.

   chorus_pm_validate_elaboration({
     ideaUuid: "<idea-uuid>"
   })

   Voulez un round suivi au lieu de résoudre ? Appelez juste chorus_pm_start_elaboration à nouveau — il n'existe pas de drapeau « ouvrir un round » distinct. Cela fonctionne tandis que toujours elaborating (un round suivi normal) et, après que vous ayez déjà résolu, en tant que round ajouté (isAppended: true) qui garde l'Idée elaborated et ne bloque jamais une Proposition en cours. L'étiquetage de problèmes par question n'existe plus.

7. Vérifier l'état d'élaboration à tout moment :

   chorus_get_elaboration({ ideaUuid: "<idea-uuid>" })

Élaboration comme piste d'audit : Même si l'utilisateur discute les exigences avec vous en dehors du flux d'élaboration formel, enregistrez les décisions clés comme des rounds d'élaboration pour qu'elles soient conservées et visibles à l'équipe.

Catégories de questions : functional, non_functional, business_context, technical_context, user_scenario, scope

Lignée d'Idée (dériver vs. tâche)

Les Idées peuvent former une forêt à parent unique : une idée peut avoir un parent (parentUuid), établissant une lignée faible. « Faible » signifie que le parent affiche seulement un cumul +N dérivées en lecture seule de ses enfants directs — il ne bloque ni n'altère jamais le flux d'élaboration/proposition/tâche de l'une ou l'autre idée, et un parent est toujours une idée complète de première classe (il peut avoir son propre contenu, propositions et tâches).

Quand une nouvelle direction émerge (pendant l'élaboration, le brainstorm ou l'examen), décidez où elle appartient :

• Dériver une idée enfant (chorus_pm_create_idea avec parentUuid, ou chorus_edit_idea avec parentUuid pour réorganiser une idée existante) quand la nouvelle direction a besoin de son propre cycle de vie d'élaboration/proposition — c'est un passage AI-DLC indépendant.
• Ajouter une tâche à la proposition de l'idée actuelle quand le nouveau travail est juste comment implémenter l'idée actuelle.
• Créer une idée simple au niveau supérieur (pas de parentUuid) quand il n'y a pas de lignée vers l'idée actuelle.

C'est une heuristique molle, pas une règle — utilisez le jugement. La prévention de cycles est automatique : vous ne pouvez pas définir un parent qui est l'idée elle-même ou l'un de ses descendants. Le parent et l'enfant doivent être dans le même projet (la lignée interprojet n'est pas encore supportée). Supprimer un parent réorganise ses enfants au niveau supérieur (il ne cascade jamais). (Rappel : invoquez-les en tant que chorus__chorus_pm_create_idea / chorus__chorus_edit_idea — voir la remarque d'espace de noms au haut de la compétence chorus.)

Conseils

• Quand combinez plusieurs idées, expliquez comment elles se rapportent dans la description de la proposition
• L'élaboration améliore la qualité de la Proposition — ne l'ignorez pas sauf si les exigences sont trivialement claires
• Présentez les questions interactives en texte brut et collectez les réponses en texte libre — OpenClaw n'a pas de primitive AskUserQuestion
• Enregistrez les décisions prises dans la conversation en tant que rounds d'élaboration pour l'auditabilité
• Toujours @mentionner le propriétaire pour confirmer la compréhension avant la résolution

Suivant

• Une fois l'élaboration résolue, utilisez /proposal pour créer une Proposition avec des brouillons de documents et de tâches
• Délégation humaine « Yolo » : le panneau de détail d'idée affiche un bouton Yolo à n'importe quel stade incomplet (activé tandis que l'agent assigné est en ligne), confirmé via un dialogue avant son exécution. Un wake yolo_requested signifie : conduire l'Idée ENTIÈRE à la fin via la compétence yolo (le pipeline AI-DLC entièrement automatique) — lire l'état actuel de l'idée d'abord et reprendre à partir de quelle que soit la phase où elle est, ne jamais supposer un stade fixe. Complétez jusqu'à fait + le rapport de completion, mais ne fusionnez ni ne poussez jamais une PR sans approbation humaine explicite.
• Pour la vue d'ensemble de la plateforme et les outils partagés, voir /chorus