Skill Idea

Cette skill 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 Proposal.

Espace de noms des outils : Les outils Chorus sont exposés par le serveur MCP connecté sous un préfixe mcp__chorus__ sur dsh (p. ex. mcp__chorus__chorus_get_idea). Les noms bruts sont utilisés ci-dessous pour la lisibilité — préfixez avec mcp__chorus__ lors de l'invocation. Voir chorus pour la règle complète.

Aperçu

Les Ideas sont le point de départ du pipeline AI-DLC. Des humains (ou des 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-chorus 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 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, la libération ou l'accomplissement de l'élaboration.

Outils

Gestion des Ideas :

Élaboration des exigences :

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

Workflow

Étape 1 : Checkin

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

Réclamer bascule automatiquement l'Idea au statut elaborating :

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

Étape 4 : Rassembler le contexte

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

1. Lire l'idea en détail :

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

2. Lire les documents du projet existants (pour contexte, stack technologique, conventions) :

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

3. Examiner les proposals antérieures (pour comprendre les patterns et 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 le contexte supplémentaire :

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

Étape 4.4 : Attacher les références externes

Faire l'attachement des références externes un réflexe, pas une pensée tardive. En rassemblant le contexte, vous découvrirez souvent des liens externes qui sont des preuves pour cette Idea — un problème ou PR précédent, une implémentation de référence, la documentation officielle, un article ou un blog post. 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 véhiculent donc le « pourquoi » vers quiconque reprend la proposal ou la task ensuite. (Les noms d'outils sont bruts ici selon la note d'espace de noms ci-dessus — préfixez avec mcp__chorus__ lors de l'invocation sur dsh.)

Préférez attacher 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 a posteriori. 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 émerge après que l'entité existe déjà.

Choisissez le type qui correspond au lien :

Exemple — une nouvelle Idea de localisation, attachant la PR précédente et la documentation 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)" }
  ]
})

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

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

Note dsh : utilisez ask_user_question dans les sessions interactives. Quand CHORUS_DAEMON_HEADLESS=1, enregistrez ce choix comme une question d'élaboration, ajoutez un commentaire @mention, et terminez le tour.

« Cette idea est toujours floue. Voulez-vous (A) réfléchir ensemble aux directions d'abord, ou (B) aller directement à l'élaboration structurée ? Répondez A ou B. »

• « C'est déjà clair » (B) : Allez à l'étape 5.
• « Brainstorm d'abord » (A) : Invoquez le skill brainstorm-chorus. Voir brainstorm-chorus pour le rythme du dialogue et les règles de synthèse — N'implémentez PAS les redéfinir ici.

Quand brainstorm-chorus retourne, vous possédez la décision de 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 de l'humain, puis appelez chorus_pm_validate_elaboration pour marquer l'élaboration complète. (Nécessite idea:admin — voir étape 5.6 si votre clé est pm_agent-preset.)
• Si des lacunes subsistent → appelez chorus_pm_start_elaboration à nouveau pour ouvrir un Round 2 structuré. Choisissez la profondeur vous-même — N'interrogez PAS à nouveau l'utilisateur.

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

Étape 5 : Élaborer sur l'Idea

Chaque Idea devrait passer par l'élaboration. Sautez seulement quand les exigences sont complètement sans ambiguïté (p. ex., correction de bug avec é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 obtenir la permission de l'humain d'abord avant d'appeler chorus_pm_skip_elaboration. Utilisez ask_user_question interactivement. En mode daemon-headless, ajoutez un commentaire @mention demandant la décision et terminez le tour. Ne sautez jamais selon 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 à rebouclé sur chorus_pm_start_elaboration (un nouveau round) jusqu'à ce que toute question ouverte soit réglée, puis résolvez une seule fois à l'étape 6. Vous réentrez dans la boucle quand :

• les réponses à un round dérivez 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 aucun flag « follow-up » séparé, et vous ne résolvez pas jusqu'à ce que la boucle soit véritablement terminée. Le cap de rounds est 10.

1. Déterminez la profondeur basée sur la complexité de l'idea :

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

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

   Note : N'INCLUEZ PAS une option « Autre » dans vos questions. Traitez le chemin de 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. Collectez les réponses. Dans dsh interactif, présentez les choix avec ask_user_question. Quand CHORUS_DAEMON_HEADLESS=1, ajoutez un commentaire @mention dirigeant le demandeur vers le round d'élaboration créé, terminez le tour, et continuez seulement après qu'un réveil ultérieur rapporte les réponses.

   J'ai quelques questions pour clarifier cette idea. S'il vous plaît, répondez avec votre choix pour chacune (vous pouvez aussi écrire une réponse en texte libre) :
   
   1. Quelles nouvelles locales devraient être prioritaires pour V1 ?
      a) Japonais uniquement — locale unique pour la version initiale
      b) Japonais + Coréen — deux locales d'Asie de l'Est
      (ou décrivez le vôtre)
   
   2. ...

   Après que l'utilisateur réponde, mappez ses réponses aux 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. 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"
   • Texte libre (aucune option ne correspond) : 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 round actif (pending_answers) unique de l'Idea. Passez-le explicitement seulement quand vous devez cibler un round spécifique.

5. Examinez les réponses et confirmez auprès du propriétaire (flux @mention) :

   Après que les réponses sont soumises, @mentionnez le répondeur (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 validiez.

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

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

   b. Postez un commentaire de 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. Basé sur la réponse — c'est le point de décision de la boucle :

   • Confirmé, rien de plus à discuter — Traitez ceci comme la confirmation de l'humain 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. Rebouclé : 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 — Identique à ce qui précède : rebouclé sur 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 l'étape d'élaboration entière complète — cela définit idea.elaborationStatus = "resolved" (Idea → elaborated), qui est le signal d'accès qui permet à une Proposal en aval d'être soumise. C'est une action au niveau Idea (prend seulement ideaUuid, ne cible pas un round). Résolvez une fois, seulement après que la boucle de l'étape 5d soit complètement réglée — toute question dérivée répondue et l'humain n'a plus de préoccupations. Si quelque chose est encore ouvert, retournez à chorus_pm_start_elaboration à la place de résoudre.

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

   ⚠️ Confirmation de l'humain requise. En dehors de l'automatisation YOLO, vous DEVEZ obtenir la confirmation explicite de l'humain avant de résoudre. Utilisez ask_user_question interactivement ; en mode daemon-headless, demandez la confirmation via un commentaire @mention et terminez le tour. 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 PM-preset ne peut pas résoudre — il doit remettre à un agent admin_agent-preset (ou une clé API de preset admin) pour effectuer la résolution. Si votre clé manque idea:admin, surfacez ceci à l'humain et demandez la remise au lieu d'échouer silencieusement.

   Précondition assignataire (N2) : l'acteur résolvant doit être l'assignataire de l'Idea. Un examinateur humain séparé résolvant une Idea possédée par PM donc a besoin à la fois de idea:admin et d'être assigné à l'Idea (réclame/réassigner 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 tout en étant elaborating (un round 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. L'étiquetage de problème par question n'existe plus.

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

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

Élaboration en tant que 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 afin qu'elles soient persistées et visibles pour l'équipe.

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

Lignée des Ideas (dériver vs. task)

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

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

• Dérivez une idea enfant (chorus_pm_create_idea avec parentUuid, ou chorus_edit_idea avec parentUuid pour reparenter une idea existante) quand la nouvelle direction a besoin de sa propre cycle de vie d'élaboration/proposal — c'est un passe AI-DLC indépendante.
• 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 simple au niveau supérieur (aucun parentUuid) quand il n'y a pas de lignée à l'idea actuelle.

C'est une heuristique souple, 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 lui-même ou l'un de ses descendants. Le parent et l'enfant doivent être dans le même projet (la lignée entre projets n'est pas encore supportée). Supprimer un parent re-parenté ses enfants au niveau supérieur (cela ne s'en cascade jamais). (Rappel : invoquez ces outils comme mcp__chorus__chorus_pm_create_idea / mcp__chorus__chorus_edit_idea — voir la note d'espace de noms au haut du skill chorus.)

Ideas thème

Un thème est une idea qui groupe seulement les enfants associés sous une direction partagée — ce n'est pas une livrable elle-même. Définissez isContainer: true sur chorus_pm_create_idea / chorus_edit_idea (ou le toggle du panneau de détail) pour en créer un ; c'est librement réversible. La seule règle qui compte : un thème ne peut pas créer une proposal — pour livrer sa direction, dérivez une idea enfant (parentUuid = <theme>) et écrivez la proposal sur l'enfant. Un thème peut toujours élaborer (son élaboration est un contexte partagé pour les enfants), et son statut/progrès remonte à partir de ses enfants. Tout le reste est auto-documenté sur les params de l'outil.

Décomposer un thème (daemon-assisté)

Quand un thème est créé via l'entrée conversationnelle « aidez-moi à le décomposer en ideas enfants », ne créez pas immédiatement les enfants — proposez puis créez : (1) modifiez le thème + optionnellement un court round d'élaboration de portée ; (2) proposez les ideas enfants candidates comme un round d'élaboration (chorus_pm_start_elaboration), une question à choix unique par candidat, pour que l'utilisateur accepte/refuse dans le panneau ; (3) à la réponse re-wake, créez chaque enfant accepté avec chorus_pm_create_idea (parentUuid = <theme>, laissé en open).

Conseils

• En combinant plusieurs ideas, expliquez comment elles se rapportent dans la description de la proposal
• L'élaboration améliore la qualité de la Proposal — ne la sautez pas sauf si les exigences sont triviales et claires
• Utilisez ask_user_question interactivement ; dans les sessions daemon-headless, routez les décisions via Chorus et terminez le tour
• Enregistrez les décisions prises en conversation comme des rounds d'élaboration pour l'auditabilité
• Toujours @mentionnez le propriétaire pour confirmer la compréhension avant de résoudre

Suivant

• Une fois l'élaboration résolue, utilisez proposal-chorus pour créer une Proposal avec des brouillons de documents et de tasks
• Remise humaine « Yolo » : le panneau de détail de l'idea affiche un bouton Yolo à n'importe quel stade incomplet (activé tant que l'agent assignataire est en ligne), confirmé via un dialogue avant le déclenchement. Un réveil yolo_requested signifie : pilotez l'ENTIÈRE idea à terminé via le skill yolo (le pipeline AI-DLC entièrement automatique) — lisez l'état actuel de l'idea d'abord et reprenez à partir de n'importe quelle phase où elle se trouve, ne supposant jamais un stade fixe. Complétez jusqu'à terminé + le rapport de complétion, mais ne fusionnez jamais ou n'envoyez jamais une PR sans approbation humaine explicite.
• Pour l'aperçu de la plateforme et les outils partagés, voir chorus