Skill Idée

Cette skill couvre l'étape Idéation du workflow 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.

Vue d'ensemble

Les Idées sont le point de départ du pipeline AI-DLC. Les humains (ou 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 procède à la création d'une Proposition avec des brouillons de documents et de tâches (voir la skill proposal-chorus — <BASE_URL>/skill/proposal-chorus/SKILL.md).

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

open --> elaborating --> elaborated

Tous les progrès post-élaboration (planification, construction, vérification, terminé) sont dérivés de l'état des Propositions et Tâches liées. Aucun agent ne doit définir le statut 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 la fin d'élaboration.

Tools

Gestion des Idées :

Élaboration des Exigences :

Tools partagés (checkin, query, comment, search, notifications) : voir la skill chorus (<BASE_URL>/skill/chorus/SKILL.md)

Workflow

Étape 1 : Check In

chorus_checkin()

Examinez votre persona, vos affectations actuelles et vos compteurs 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 : Réclamer une Idée

Réclamer transite automatiquement l'Idée au statut elaborating :

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

Étape 4 : Rassembler le Contexte

Avant d'élaborer, comprenez l'image 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 stack technique, les conventions) :

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

3. Examiner les propositions passées (pour comprendre les modèles et standards) :

   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 un contexte supplémentaire :

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

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

Si l'Idée est floue et que vous auriez du mal à énumérer des questions à choix multiples concrètes, proposez à l'utilisateur un prélude brainstorm avant l'élaboration structurée. Utilisez le mécanisme d'invite interactive de votre IDE si disponible, ou présentez les options sous forme de texte — la même convention utilisée ailleurs dans cette skill. Deux choix : "Already clear, run structured elaboration" et "Brainstorm first to explore directions".

• "Already clear" : Allez à l'Étape 5.
• "Brainstorm first" : Invoquez la skill brainstorm-chorus (<BASE_URL>/skill/brainstorm-chorus/SKILL.md). Consultez cette skill pour le cadence du dialogue et les règles de synthèse — NE les ré-implémentez PAS ici.

Quand la skill brainstorm revient, vous possédez la décision du cycle de vie (la skill brainstorm vous la laisse intentionnellement) :

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

Chaque résultat termine l'Étape 4.5 ; passer 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é (par 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 confirmez d'abord avec l'utilisateur avant d'appeler chorus_pm_skip_elaboration. Préférez ne pas ignorer 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 seul 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 ré-entrez la boucle quand :

• les réponses à un round dérivent de nouvelles questions ou surface 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 aucun flag "follow-up" séparé, et vous ne résolvez pas jusqu'à ce que la boucle soit vraiment terminée. Le cap des rounds est 10.

1. Déterminer la profondeur basée sur 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 :

   Note : N'INCLUEZ PAS une option "Autre" dans vos questions. L'UI ajoute automatiquement une option "Autre" de 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. Utilisez le mécanisme d'invite interactive de votre IDE si disponible, ou présentez les options sous forme de texte. Mappez chaque question d'élaboration à une invite destinée à l'utilisateur (regroupez si nécessaire) :

   Format d'invite d'exemple :

   Question: Which new locales should be prioritized for V1?
   Category: Scope
   
   Options:
     a) Japanese only — Single locale for initial release
     b) Japanese + Korean — Two East Asian locales
     c) Other (free text)

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

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"
   • 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 seul 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 que les réponses sont soumises, @mention le répondeur (généralement le propriétaire de l'agent) avec un résumé de votre compréhension. Cela empêche les malentendus avant que vous résolviez.

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

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

   b. Poster un commentaire de 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. Attendez une confirmation via les commentaires.

   d. Basé sur la réponse — ceci est le point de décision de la boucle :

   • Confirmé, rien de plus à discuter — Traitez ceci comme la confirmation humaine requise pour résoudre ; procédez à l'Étape 6 et appelez chorus_pm_validate_elaboration.
   • L'humain soulève une nouvelle préoccupation / correction / question — NE résolvez PAS. Bouclez de nouveau : 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 aucune préoccupation restante.
   • Les réponses elles-mêmes ont dérivé de nouvelles questions ou une contradiction — Pareil que ci-dessus : bouclez de nouveau vers chorus_pm_start_elaboration pour un autre round avant de résoudre.
   • Peu clair — Posez des questions de clarification via un autre commentaire, puis continuez la boucle.

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

   Résoudre marque la phase d'élaboration entière complète — cela définit idea.elaborationStatus = "resolved" (Idée → elaborated), qui est le signal de porte 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 de l'Étape 5d soit complètement réglée — chaque question dérivée répondue et l'humain n'a aucune préoccupation restante. Si quelque chose est encore ouvert, retournez à chorus_pm_start_elaboration à la place de résoudre.

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

   ⚠️ Confirmation humaine requise. En dehors de l'automation YOLO vous DEVEZ obtenir une confirmation humaine explicite avant de résoudre. 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 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 avec preset admin) pour effectuer la résolution. Si votre clé manque idea:admin, surfacez ceci à l'humain et demandez le passage au lieu de rester silencieux.

   Précondition d'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 possédée par PM a donc besoin à la fois de idea:admin et d'être assigné l'Idée (réclame/réassignez-la d'abord). La permission admin seule ne suffit pas.

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

   Voulez-vous un round suivi au lieu de résoudre ? Appelez simplement chorus_pm_start_elaboration à nouveau — il n'y a aucun flag "open a round" séparé. Cela fonctionne tant qu'encore elaborating (un round 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. Le tagging de problème par question n'existe plus.

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

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

Élaboration comme piste d'audit : Même si l'utilisateur discute des exigences avec vous en dehors du flux d'élaboration formel, envisagez d'enregistrer les décisions clés en tant que 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

• En combinant plusieurs idées, expliquez comment elles se rapportent dans la description de la proposition
• L'élaboration améliore la qualité de la Proposition — préférez ne pas l'ignorer à moins que les exigences ne soient trivialement claires
• Utilisez le mécanisme d'invite interactive de votre IDE si disponible pour les questions destinées à l'utilisateur ; sinon présentez les options sous forme de texte
• Enregistrez les décisions prises dans la conversation en tant que rounds d'élaboration pour l'auditabilité
• Envisagez @mentionner le propriétaire pour confirmer la compréhension avant de résoudre

Suivant

• Une fois l'élaboration résolue, utilisez la skill proposal-chorus (<BASE_URL>/skill/proposal-chorus/SKILL.md) pour créer une Proposition avec des brouillons de documents et de tâches
• Pour l'aperçu de la plateforme et les tools partagés, voir la skill chorus (<BASE_URL>/skill/chorus/SKILL.md)