Compétence Idea

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

Vue d'ensemble

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

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

open --> elaborating --> elaborated

Toute la progression post-élaboration (planification, construction, vérification, terminé) est dérivée de l'état des Proposals et Tasks liées. Aucun agent ne devrait définir le statut Idea directement au-delà de l'élaboration -- toutes les transitions sont des effets secondaires de la réclamation, de la libération, ou de la complétion de l'élaboration.

Outils

Gestion Idea :

Élaboration des exigences :

Outils partagés (checkin, query, comment, search, notifications) : voir /chorus

Workflow

Étape 1 : Check In

chorus_checkin()

Examinez votre persona, vos 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 Idea

La réclamation fait automatiquement passer l'Idea au statut elaborating :

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

Étape 4 : Rassembler du contexte

Avant d'élaborer, comprenez le tableau complet :

1. Lire l'idea en détail :

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

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

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

3. Examiner les proposals précédentes (pour comprendre les modèles et les standards) :

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

4. Vérifier les tasks existantes (pour éviter la duplication) :

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

5. Lire les commentaires sur l'idea pour un contexte supplémentaire :

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

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

Si l'Idea est floue et que vous auriez du mal à énumérer des questions multi-choix concrètes, proposez à l'utilisateur un prélude brainstorm avant l'élaboration structurée. Présentez deux choix à l'utilisateur (convention existante utilisée ailleurs dans cette compétence — voir l'utilisation de AskUserQuestion à l'Étape 5 pour le mécanisme de prompt spécifique à l'hôte) : "Déjà clair, lancer l'élaboration structurée" et "Brainstormer d'abord pour explorer les directions".

• "Déjà clair": Passer à l'Étape 5.
• "Brainstormer d'abord": Invoquer la compétence /brainstorm. Voir /brainstorm pour la cadence de dialogue et les règles de synthèse — ne PAS les réimplémenter ici.

Quand /brainstorm revient, vous possédez la décision de cycle de vie (la compétence brainstorm la laisse volontairement à vous) :

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

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

Étape 5 : Élaborer sur l'Idea

Chaque Idea devrait passer par l'élaboration. Ignorer uniquement quand les exigences sont complètement sans ambiguïté (p. ex., correction de bug avec des étapes claires). L'élaboration améliore la qualité de la Proposal et réduit les cycles de rejet.

Ideas simples (ignorer l'élaboration)

Vous pouvez ignorer l'élaboration, mais vous DEVEZ d'abord demander la permission à l'utilisateur via AskUserQuestion avant d'appeler chorus_pm_skip_elaboration. Ne jamais ignorer sur votre seul jugement.

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

Ideas 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érivez de nouvelles questions ou découvrez 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 drapeau "follow-up" séparé, et vous ne résolvez pas jusqu'à ce que la boucle soit réellement terminée. Le plafond des rounds est 10.

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

   • "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 les questions d'élaboration :

   Remarque : N'incluez PAS une option "Autre" dans vos questions. L'UI ajoute automatiquement une option libre "Autre" à 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ésenter les questions à l'utilisateur — DOIT utiliser AskUserQuestion. Ne PAS afficher les questions en texte brut. Mapper chaque question d'élaboration à un appel AskUserQuestion (max 4 questions par appel ; regrouper 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 à 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 obligatoire 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'Idea. Passez-le explicitement uniquement quand vous devez cibler un round spécifique.

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

   Après que les réponses soient soumises, @mentionnez le répondant (généralement le propriétaire de l'agent) avec un résumé de votre compréhension. Cela prévient les malentendus avant que vous ne 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. Publier un commentaire récapitulatif sur l'idea :

      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 la boucle :

   • Confirmé, rien d'autre à discuter — Traiter cela comme la confirmation humaine requise pour résoudre ; procéder à l'Étape 6 et appeler chorus_pm_validate_elaboration.
   • L'humain soulève une nouvelle préoccupation / correction / question — Ne PAS résoudre. Boucler en arrière : ouvrir un nouveau round avec chorus_pm_start_elaboration capturant les nouvelles questions, collecter les réponses (Étapes 2–5 à nouveau), et re-confirmer. Répéter jusqu'à ce que l'humain n'ait plus de préoccupations.
   • Les réponses elles-mêmes dérivaient de nouvelles questions ou une contradiction — Idem ci-dessus : boucler en arrière vers chorus_pm_start_elaboration pour un autre round avant de résoudre.
   • Peu clair — Poser des questions de clarification via un autre commentaire, puis continuer la boucle.

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

   Résoudre marque la phase d'élaboration entière complète — elle définit idea.elaborationStatus = "resolved" (Idea → elaborated), qui est le signal de porte qui permet à une Proposal en aval d'être soumise. C'est une action au niveau Idea (prend uniquement ideaUuid, ne cible pas un round). Résoudre une seule fois, uniquement après que la boucle Étape 5d soit entièrement réglée — chaque question dérivée répondue et l'humain n'a plus de préoccupations. Si quelque chose est encore ouvert, revenir à chorus_pm_start_elaboration au lieu de résoudre.

   Précondition : résoudre nécessite que l'Idea ait au moins un round et que chaque round soit entièrement répondu (aucun resté en pending_answers). Si un round a encore des questions ouvertes, y répondre (ou ce 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 jamais résoudre sur 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 preset PM ne peut pas résoudre — il doit passer à un agent preset admin_agent (ou une clé API preset admin) pour effectuer la résolution. Si votre clé manque idea:admin, faire surface cela à l'humain et demander le handoff au lieu d'échouer silencieusement.

   Précondition assignée (N2) : l'acteur résolvant doit être l'assigné de l'Idea. Un examinateur humain séparé résolvant une Idea possédée par PM a donc besoin à la fois de idea:admin et d'être assigné à l'Idea (la réclamer/réassigner d'abord). La permission admin seule n'est pas suffisante.

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

   Vous voulez un round de suivi au lieu de résoudre ? Juste appeler chorus_pm_start_elaboration à nouveau — il n'y a pas de drapeau "ouvrir un round" séparé. Cela fonctionne tant que c'est encore 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'Idea elaborated et ne bloque jamais une Proposal en vol. Le tagging d'issue 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 des exigences avec vous en dehors du flux d'élaboration formel, enregistrer les décisions clés comme des rounds d'élaboration pour qu'elles soient persistées et visibles pour l'équipe.

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

Lignée Idea (dériver vs. task)

Les Ideas peuvent former une forêt mono-parent : une idea peut avoir un parent (parentUuid), établissant une lignée faible. "Faible" signifie que le parent n'affiche que un rollup en lecture seule +N derived de ses enfants directs — cela ne bloque jamais ou n'altère le flux d'élaboration/proposal/task de l'une ou l'autre idea, et un parent est toujours une idea de première classe complète (il peut avoir son propre contenu, des proposals, et des tasks).

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

• Dériver une child idea (chorus_pm_create_idea avec parentUuid, ou chorus_edit_idea avec parentUuid pour reparenter une idea existante) quand la nouvelle direction a besoin de son propre cycle de vie d'élaboration/proposal — c'est un pass AI-DLC indépendant.
• Ajouter une task à la proposal de l'idea actuelle quand le nouveau travail est juste comment implémenter l'idea actuelle.
• Créer une idea top-level simple (pas de parentUuid) quand il n'y a pas de lignée à l'idea actuelle.

C'est une heuristique souple, pas une règle — utiliser le jugement. La prévention de cycle est automatique : vous ne pouvez pas définir un parent qui est l'idea elle-même ou l'un de ses descendants. Le parent et l'enfant doivent être dans le même projet (la lignée cross-projet n'est pas encore supportée). Supprimer un parent re-parentalise ses enfants au top-level (cela ne cascade jamais).

Conseils

• Quand combiner plusieurs ideas, expliquez comment elles se rapportent dans la description de la proposal
• L'élaboration améliore la qualité de la Proposal — ne pas l'ignorer sauf si les exigences sont trivialement claires
• Utiliser AskUserQuestion pour toutes les questions interactives — jamais du texte brut
• Enregistrer les décisions prises dans la conversation comme des rounds d'élaboration pour l'audit
• Toujours @mentionner le propriétaire pour confirmer la compréhension avant de résoudre

Suivant

• Une fois l'élaboration résolue, utiliser /proposal pour créer une Proposal avec des brouillons de document et de task
• Handoff humain "Yolo" : le panneau de détail d'idea affiche un bouton Yolo à tout stade incomplet (activé tant que l'agent assigné est en ligne), confirmé via un dialogue avant qu'il ne se déclenche. Un wake yolo_requested signifie : conduire l'IDÉE ENTIÈRE jusqu'à terminée via la compétence yolo (le pipeline AI-DLC full-auto) — lire d'abord l'état actuel de l'idea et reprendre à partir de n'importe quelle phase elle se trouve, ne jamais supposer un stade fixe. Compléter jusqu'à done + le rapport de complétion, mais ne jamais merger ou push une PR sans approbation humaine explicite.
• Pour la vue d'ensemble de la plateforme et les outils partagés, voir /chorus