Chorus Idea Skill

Cette skill couvre l'étape Ideation du workflow AI-DLC : revendiquer des Ideas, lancer des rounds d'élaboration structurés pour clarifier les exigences, et préparer la création de Proposal.

Overview

Les Ideas sont le point de départ du pipeline AI-DLC. Les humains (ou les agents Admin) créent des Ideas décrivant leurs besoins. L'agent PM revendique une Idea, lance l'élaboration pour clarifier les exigences, puis passe à /chorus-proposal pour créer une Proposal avec des brouillons de documents et de tâches.

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

open --> elaborating --> elaborated

Toute progression post-élaboration (planification, construction, vérification, done) est dérivée de l'état des Proposals et Tasks liées. Aucun agent ne doit définir le statut d'Idea directement au-delà de l'élaboration — toutes les transitions sont des effets secondaires de la revendication, de la libération ou de l'achèvement de l'élaboration.

Tools

Idea Management:

Requirements Elaboration:

Shared tools (checkin, query, comment, search, notifications) : voir le doc de steering chorus.

Workflow

Step 1: Check In

chorus_checkin()

Examinez votre persona, les assignations actuelles et les décomptes de travail en attente.

Step 2: Find Work

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

Ou vérifiez les assignations existantes :

chorus_get_my_assignments()

Step 3: Claim an Idea

Revendiquer une idea bascule automatiquement vers le statut elaborating :

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

Step 4: Gather Context

Avant d'élaborer, comprenez l'image complète :

1. Lisez l'idea en détail :

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

2. Lisez 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. Examinez les proposals passées (pour comprendre les patterns et standards) :

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

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

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

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

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

Step 4.4: Attach External References

Faire l'attachement de références externes un réflexe, pas une pensée tardive. En rassemblant le contexte, vous surfacerez souvent des liens externes qui sont des preuves pour cette Idea — un issue ou PR de précédent, une implémentation de référence, de la documentation officielle, un article ou un blog. Au moment où vous en voyez un, attachez-le en tant qu'artifact de référence. Les références sont relues en ligne par chorus_get_idea / chorus_get_proposal / chorus_get_task, elles portent donc le "pourquoi" en avant vers quiconque reprend la proposal ou la task ensuite.

Préférez l'attachement au moment de la création via le param inline references[] sur chorus_pm_create_idea (et plus tard chorus_pm_create_proposal / chorus_create_tasks) plutôt qu'un chorus_add_reference après coup. Attacher à la création signifie que la preuve est présente dès la première lecture ; utilisez chorus_add_reference seulement quand le lien apparaît après que l'entité existe déjà.

Choisissez le type qui correspond au lien :

Exemple — une nouvelle Idea de localisation, attachant le PR de précédent et les docs du framework en ligne à la création :

chorus_pm_create_idea({
  projectUuid: "<project-uuid>",
  title: "Add Portuguese (pt) locale",
  content: "...",
  references: [
    { type: "issue_pr", url: "https://github.com/org/repo/pull/411",
      title: "PR #411 — prior locale work (precedent to mirror)" },
    { type: "docs", url: "https://next-intl.dev/docs/routing",
      title: "next-intl routing docs (locale registration)" }
  ]
})

Step 4.5: Brainstorm Mode (Optional Prelude)

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 de brainstorm avant l'élaboration structurée. Posez une seule fois à l'utilisateur — une seule question interactive (header "Brainstorm", deux options : "Already clear, run structured elaboration" et "Brainstorm first to explore directions") — et attendez la réponse.

• "Already clear": Passez à Step 5.
• "Brainstorm first": Invoquez la skill /chorus-brainstorm. Voir /chorus-brainstorm pour le cadence de dialogue et les règles de synthèse — N'E-IMPLÉMENTEZ PAS ici.

Quand /chorus-brainstorm retourne, vous possédez la décision du cycle de vie (la skill brainstorm l'intentionnellement vous la laisse) :

• 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 — voir Step 5.6 si votre clé est pm_agent-preset.)
• Si des lacunes restent → appelez chorus_pm_start_elaboration à nouveau pour ouvrir un Round 2 structuré. Choisissez la profondeur vous-même — NE RE-PROMPTEZ PAS l'utilisateur.

Chaque résultat termine Step 4.5 ; ignorez Step 5.

Step 5: Elaborate on the Idea

Chaque Idea devrait passer par l'élaboration. Ignorez seulement quand les exigences sont complètement non ambiguës (par ex., bug fix avec des étapes claires). L'élaboration améliore la qualité de la Proposal et réduit les cycles de rejet.

Simple Ideas (skip elaboration)

Vous pouvez ignorer l'élaboration, mais vous DEVEZ d'abord demander la permission à l'utilisateur — une question interactive explicite, attendez sa réponse — avant d'appeler chorus_pm_skip_elaboration. Ne l'ignorez jamais sur la base de votre seul jugement.

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

Standard/Complex Ideas (run elaboration)

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 en Step 6. Vous entrez à nouveau dans la boucle chaque fois que :

• les réponses à un round dérivent de nouvelles questions ou surfacent une contradiction/lacune, ou
• à la porte de résolution (Step 5d / Step 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 tant que la boucle n'est pas vraiment terminée. Le cap de round est 10.

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

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

2. Créez les questions d'élaboration :

   Note : N'INCLUEZ PAS une option "Other" dans vos questions. L'UI ajoute automatiquement une option "Other" 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 de manière interactive. N'AFFICHEZ PAS les questions comme un mur de texte brut indifférencié. Posez-les comme des questions claires et à but unique (une décision à la fois, en offrant les labels des options que vous avez définis), et attendez les sélections de l'humain avant de continuer.

   Après que l'utilisateur réponde, mappez ses sélections en retour aux IDs d'options et appelez chorus_answer_elaboration. Si l'utilisateur choisit une réponse en texte libre qui ne correspond à aucune option, définissez selectedOptionId: null et mettez leur entrée dans customText.

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 "Other" (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. Omis et le service localise automatiquement le round actif unique (pending_answers) de l'Idea. Passez-le explicitement seulement quand vous devez 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 l'auteur de la réponse (typiquement le propriétaire de l'agent) avec un résumé de votre compréhension. Cela prévient la mauvaise interprétation avant que vous résolviez.

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

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

   b. Postez un commentaire résumé 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. Attendez 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 — Traitez ceci comme la confirmation humaine requise pour résoudre ; passez à Step 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 (Steps 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 — 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 porte de commit unique — seulement quand la boucle est terminée) :

   Résoudre marque l'étape d'élaboration entière complète — cela définit idea.elaborationStatus = "resolved" (Idea → elaborated), ce qui est le signal de porte qui permet à une Proposal aval d'être soumise. C'est une action au niveau de l'Idea (prend seulement ideaUuid, ne cible pas un round). Résolvez une seule fois, seulement après que la boucle de Step 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 au lieu de résoudre.

   Précondition : résoudre nécessite que l'Idea ait au moins un round et 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. La réponse "Confirmed" en step 5d ci-dessus compte comme cette confirmation. Ne résolvez jamais sur la base de 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 de preset PM ne peut pas résoudre — il doit passer à un agent de preset admin_agent (ou une clé API de preset admin) pour effectuer la résolution. Si votre clé n'a pas idea:admin, surfacez ceci à l'humain et demandez la remise au lieu d'échouer silencieusement.

   Précondition d'assigné (N2) : l'acteur qui résout 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 (revendiquez/réassignez-la en premier). La permission admin seule ne suffit pas.

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

   Voulez un round follow-up au lieu de résoudre ? Appelez simplement chorus_pm_start_elaboration à nouveau — il n'y a pas de drapeau "open a round" séparé. Cela fonctionne toujours en elaborating (un round follow-up 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 de question par issue n'existe plus.

7. Vérifiez l'état de l'é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 formel d'élaboration, enregistrez les décisions clés comme des rounds d'élaboration pour qu'elles soient persistantes et visibles à l'équipe.

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

Idea Lineage (derive vs. task)

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

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

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

C'est une heuristique douce, pas une règle — utilisez 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 un de ses descendants. Le parent et l'enfant doivent être dans le même projet (la lignée inter-projets n'est pas encore supportée). Supprimer un parent re-parente ses enfants au top-level (ça ne cascade jamais).

Theme ideas

Un theme est une idea qui seulement groupe les enfants liés sous une direction partagée — ce n'est pas un livrable lui-même. Définissez isContainer: true sur chorus_pm_create_idea / chorus_edit_idea (ou le toggle du detail-panel) pour en créer un ; c'est librement réversible. La seule règle qui importe : un theme ne peut pas créer de proposal — pour livrer sa direction, dérivez une idea enfant (parentUuid = <theme>) et écrivez la proposal sur l'enfant. Un theme peut toujours élaborer (son élaboration est un contexte partagé pour les enfants), et son status/progress roule depuis ses enfants. Tout le reste est auto-documenté sur les params des tools.

Theme decompose (daemon-assisted)

Quand un theme est créé via l'entrée conversationnelle "help me break this into child ideas", ne créez pas immédiatement les enfants — proposez puis créez : (1) éditez le theme + optionnellement un round d'élaboration de scope court ; (2) proposez les enfants candidats comme un round d'élaboration (chorus_pm_start_elaboration), une question single-select par candidat, pour que l'utilisateur accepte/decline dans le panel ; (3) à la re-réveil de la réponse, créez chaque enfant accepté avec chorus_pm_create_idea (parentUuid = <theme>, laissé en open).

Tips

• Quand vous combinez plusieurs ideas, expliquez comment elles se rapportent dans la description de la proposal
• L'élaboration améliore la qualité de la Proposal — ne l'ignorez pas à moins que les exigences soient trivialement claires
• Posez des questions interactives et à but unique pour toutes les décisions humaines — ne les enterrez jamais dans un mur de 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

Next

• Une fois l'élaboration résolue, utilisez /chorus-proposal pour créer une Proposal avec des brouillons de documents et de tâches
• Remise humaine "Verify Elaborate": quand un humain clique Verify Elaborate sur le panel idea-detail, Chorus résout l'élaboration et réveille l'agent daemon assigné de l'Idea pour écrire la proposal — donc l'agent réveillé reprend cette remise idea→proposal automatiquement (aucune proposal écrite par humain nécessaire).
• Remise humaine "Start Development": une fois la proposal approuvée et les tasks inachevées restantes, le panel idea-detail affiche un bouton Start Development (activé tandis que l'agent assigné est en ligne). Un réveil start_development signifie : revendiquer et exécuter TOUTES les tasks restantes inachevées de la proposal approuvée de l'idea en ordre de dépendance jusqu'à aucune n'étant revendicable — pas juste une task.
• Remise humaine "Yolo": le panel idea-detail affiche aussi un bouton Yolo à TOUT stade incomplet (activé tandis que l'agent assigné est en ligne), confirmé via un dialog avant qu'il ne tire. Un réveil yolo_requested signifie : conduire l'idea ENTIÈRE à done via la skill /chorus-yolo (le pipeline AI-DLC full-auto) — lisez l'état actuel de l'idea en premier et reprenez de quelque phase qu'il soit dedans (auto-élaborer + écrire la proposal si pas encore résolue ; exécuter si une proposal est approuvée avec des tasks ouvertes ; etc.), ne jamais en supposant une étape fixe. Complétez jusqu'à done + le rapport de completion, mais ne mergez ni pushez jamais une PR sans approbation humaine explicite.
• Pour la vue d'ensemble de la plate-forme et les tools partagés, voir le doc de steering chorus.