Skill Idée

Ce skill couvre l'étape Idéation du workflow AI-DLC : revendiquer des Idées, exécuter des rounds d'élaboration structurés pour clarifier les exigences, et préparer la création de Propositions.

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 revendique une Idée, exécute l'élaboration pour clarifier les exigences, puis passe à /proposal pour créer une Proposition avec des brouillons de document et de tâches.

Cycle de vie du statut 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 directement le statut Idée au-delà de l'élaboration -- toutes les transitions sont des effets secondaires de la revendication, de la libération ou de la fin d'élaboration.

Outils

Gestion des Idées :

Élaboration des Exigences :

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

Workflow

Étape 1 : Check In

chorus_checkin()

Examinez votre persona, vos affectations actuelles et les comptages de travail en attente.

Étape 2 : Trouver du Travail

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

Ou vérifiez les affectations existantes :

chorus_get_my_assignments()

Étape 3 : Revendiquer une Idée

La revendication bascule automatiquement l'Idée au statut elaborating :

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

Étape 4 : Rassembler le Contexte

Avant d'élaborer, comprenez le tableau complet :

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

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

2. Lisez les documents existants du projet (pour le contexte, la stack technique, les conventions) :

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

3. Examinez les propositions antérieures (pour comprendre les patterns et standards) :

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

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

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

5. Lisez les commentaires sur l'idée pour un contexte supplémentaire :

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

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

Si l'Idée est floue et que vous auriez du mal à énumérer des questions concrètes à choix multiples, proposez à l'utilisateur une prélude de brainstorming avant l'élaboration structurée. Posez la question une fois via AskUserQuestion (en-tête "Brainstorm", deux options : "Already clear, run structured elaboration" et "Brainstorm first to explore directions").

• "Already clear" : Passez à l'Étape 5.
• "Brainstorm first" : Invoquez le skill /brainstorm. Consultez /brainstorm pour le rythme du dialogue et les règles de synthèse -- NE LES RÉ-IMPLÉMENTEZ PAS ici.

Quand /brainstorm revient, vous possédez la décision du cycle de vie (le skill brainstorm le laisse délibérément à vous) :

• Si les réponses du round synthétisé couvrent tout → obtenez la confirmation humaine, puis appelez chorus_pm_validate_elaboration pour résoudre l'élaboration. (Résoudre nécessite idea:admin -- voyez l'Étape 5.6 si votre clé est preset pm_agent.)
• Si des lacunes subsistent → appelez chorus_pm_start_elaboration à nouveau pour ouvrir un Round 2 structuré. Choisissez la profondeur vous-même -- NE DEMANDEZ PLUS À L'UTILISATEUR.

Les deux résultats terminent 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 seulement quand les exigences sont complètement sans ambiguïté (ex : correction de bug 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 demander la permission à l'utilisateur d'abord via AskUserQuestion avant d'appeler chorus_pm_skip_elaboration. Ne l'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 sont un round. Continuez à 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 re-entrez la boucle chaque fois que :

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

Chaque nouveau round est juste un autre appel chorus_pm_start_elaboration -- il n'y a pas de flag "follow-up" séparé, et vous ne résolvez pas tant que la boucle n'est pas véritablement terminée. Le cap de rounds est 10.

1. Déterminez 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éez des questions d'élaboration :

   Remarque : N'INCLUEZ PAS d'option "Autre" dans vos questions. L'interface utilisateur ajoute automatiquement une option "Autre" en texte libre à chaque question.

   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ésentez les questions à l'utilisateur -- VOUS DEVEZ utiliser AskUserQuestion. N'AFFICHEZ PAS les questions en texte brut. Mappez chaque question d'élaboration à un appel AskUserQuestion (max 4 questions par appel ; regroupez si nécessaire) :

   AskUserQuestion({
     questions: [
       {
         question: "Which new locales should be prioritized for V1?",
         header: "Scope",
         options: [
           { label: "Japanese only", description: "Single locale for initial release" },
           { label: "Japanese + Korean", description: "Two East Asian locales" }
         ],
         multiSelect: false
       }
     ]
   })

   Après que l'utilisateur réponde, mappez ses sélections aux IDs d'option et appelez chorus_answer_elaboration. Si l'utilisateur a sélectionné "Autre", définissez selectedOptionId: null et customText à son entrée.

4. Soumettez 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"
   • Choisir "Autre" (texte libre) : selectedOptionId: null, customText: "your answer" -- customText est requis quand aucune option n'est sélectionnée

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

5. Examinez les réponses et confirmez avec le propriétaire (flux @mention) :

   Après soumission des réponses, @mention celui qui a répondu (généralement le propriétaire de l'agent) avec un résumé de votre compréhension. Cela prévient les malentendus avant de résoudre.

   a. Obtenez l'info du propriétaire à partir de la réponse checkin (agent.owner) ou recherchez :

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

   b. Postez un commentaire de synthèse 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. Attendez la confirmation via commentaires.

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

   • Confirmé, rien d'autre à discuter -- Traitez ceci comme la confirmation humaine requise pour résoudre ; allez à l'Étape 6 et appelez chorus_pm_validate_elaboration.
   • L'humain soulève une nouvelle préoccupation / correction / question -- NE résolvez PAS. Bouclez en arrière : 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 pas de préoccupations restantes.
   • Les réponses elles-mêmes dérivent de nouvelles questions ou une contradiction -- Même chose que ci-dessus : bouclez en arrière vers chorus_pm_start_elaboration pour un autre round avant de résoudre.
   • Flou -- Posez des questions de clarification via un autre commentaire, puis continuez la boucle.

6. Résolvez l'élaboration (la seule porte commit -- seulement quand la boucle est terminée) :

   Résoudre marque la phase d'élaboration entière comme complète -- cela 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, seulement après que la boucle d'Étape 5d se soit complètement stabilisée -- chaque question dérivée a reçu une réponse et l'humain n'a pas de préoccupations restantes. Si quoi que ce soit est encore ouvert, retournez à chorus_pm_start_elaboration à la place de résoudre.

   Précondition : résoudre requiert que l'Idée ait au moins un round et que chaque round soit complètement répondu (aucun resté 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 la confirmation humaine explicite avant de résoudre. La réponse "Confirmée" à 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 n'accorde que idea:write, donc un agent avec preset PM ne peut pas résoudre -- il doit passer à un agent avec preset admin_agent (ou une clé API admin) pour effectuer la résolution. Si votre clé manque de idea:admin, surfacez ceci à l'humain et demandez la passation plutôt que d'échouer silencieusement.

   Précondition assigné (N2) : l'acteur qui résout doit être l'assigné de l'Idée. Un examinateur humain séparé résolvant une Idée appartenant à PM a donc besoin à la fois de idea:admin et d'être assigné à l'Idée (la revendiquer/la réassigner d'abord). La permission admin seule ne suffit pas.

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

   Vous voulez un round de suivi au lieu de résoudre ? Appelez juste chorus_pm_start_elaboration à nouveau -- il n'y a pas de flag "open a round" séparé. Cela fonctionne tandis que still elaborating (un round de suivi normal) et, après que vous ayez déjà résolu, comme un round ajouté (isAppended: true) qui garde l'Idée elaborated et ne bloque jamais une Proposition en vol. L'étiquetage de problèmes par question n'existe plus.

7. Vérifiez le statut d'élaboration à tout moment :

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

L'élaboration comme piste d'audit : Même si l'utilisateur discute des 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 persistées et visibles à l'équipe.

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

Conseils

• Quand vous 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 à moins que les exigences soient trivialement claires
• Utilisez AskUserQuestion pour toutes les questions interactives -- jamais du texte brut
• Enregistrez les décisions prises dans la conversation comme des rounds d'élaboration pour l'auditabilité
• Mentionnez toujours @mention le propriétaire pour confirmer la compréhension avant de résoudre

Suivant

• Une fois l'élaboration résolue, utilisez /proposal pour créer une Proposition avec des brouillons de document et de tâches
• Pour l'aperçu de la plateforme et les outils partagés, voir /chorus