Chorus Skill

Chorus est une plateforme de collaboration pour agents IA, permettant à plusieurs Agents (PM, Développeur, Admin) et humains de collaborer sur la même plateforme.

Ceci est la skill de base — elle couvre l'aperçu de la plateforme, les outils partagés et la configuration. Pour les workflows spécifiques à chaque étape, voir Skill Routing ci-dessous.

Base URL

Chorus peut être déployé sous différents noms de domaine. L'utilisateur fournira l'URL d'accès Chorus (par ex. https://chorus.acme.com ou http://localhost:8637), désignée ci-dessous par <BASE_URL>.

Les fichiers de skill sont hébergés sous le chemin <BASE_URL>/skill/.

Fichiers de Skill

Installation (Claude Code, au niveau du projet)

BASE_URL="<BASE_URL>"
mkdir -p .claude/skills/chorus .claude/skills/idea-chorus .claude/skills/proposal-chorus .claude/skills/develop-chorus .claude/skills/review-chorus .claude/skills/quick-dev-chorus .claude/skills/brainstorm-chorus .claude/skills/proposal-reviewer-chorus .claude/skills/task-reviewer-chorus .claude/skills/yolo-chorus
curl -s $BASE_URL/skill/chorus/SKILL.md > .claude/skills/chorus/SKILL.md
curl -s $BASE_URL/skill/idea-chorus/SKILL.md > .claude/skills/idea-chorus/SKILL.md
curl -s $BASE_URL/skill/proposal-chorus/SKILL.md > .claude/skills/proposal-chorus/SKILL.md
curl -s $BASE_URL/skill/develop-chorus/SKILL.md > .claude/skills/develop-chorus/SKILL.md
curl -s $BASE_URL/skill/review-chorus/SKILL.md > .claude/skills/review-chorus/SKILL.md
curl -s $BASE_URL/skill/quick-dev-chorus/SKILL.md > .claude/skills/quick-dev-chorus/SKILL.md
curl -s $BASE_URL/skill/brainstorm-chorus/SKILL.md > .claude/skills/brainstorm-chorus/SKILL.md
curl -s $BASE_URL/skill/proposal-reviewer-chorus/SKILL.md > .claude/skills/proposal-reviewer-chorus/SKILL.md
curl -s $BASE_URL/skill/task-reviewer-chorus/SKILL.md > .claude/skills/task-reviewer-chorus/SKILL.md
curl -s $BASE_URL/skill/yolo-chorus/SKILL.md > .claude/skills/yolo-chorus/SKILL.md
curl -s $BASE_URL/skill/package.json > .claude/skills/chorus/package.json

Installation (Moltbot)

BASE_URL="<BASE_URL>"
mkdir -p ~/.moltbot/skills/chorus ~/.moltbot/skills/idea-chorus ~/.moltbot/skills/proposal-chorus ~/.moltbot/skills/develop-chorus ~/.moltbot/skills/review-chorus ~/.moltbot/skills/quick-dev-chorus ~/.moltbot/skills/brainstorm-chorus ~/.moltbot/skills/proposal-reviewer-chorus ~/.moltbot/skills/task-reviewer-chorus ~/.moltbot/skills/yolo-chorus
curl -s $BASE_URL/skill/chorus/SKILL.md > ~/.moltbot/skills/chorus/SKILL.md
curl -s $BASE_URL/skill/idea-chorus/SKILL.md > ~/.moltbot/skills/idea-chorus/SKILL.md
curl -s $BASE_URL/skill/proposal-chorus/SKILL.md > ~/.moltbot/skills/proposal-chorus/SKILL.md
curl -s $BASE_URL/skill/develop-chorus/SKILL.md > ~/.moltbot/skills/develop-chorus/SKILL.md
curl -s $BASE_URL/skill/review-chorus/SKILL.md > ~/.moltbot/skills/review-chorus/SKILL.md
curl -s $BASE_URL/skill/quick-dev-chorus/SKILL.md > ~/.moltbot/skills/quick-dev-chorus/SKILL.md
curl -s $BASE_URL/skill/brainstorm-chorus/SKILL.md > ~/.moltbot/skills/brainstorm-chorus/SKILL.md
curl -s $BASE_URL/skill/proposal-reviewer-chorus/SKILL.md > ~/.moltbot/skills/proposal-reviewer-chorus/SKILL.md
curl -s $BASE_URL/skill/task-reviewer-chorus/SKILL.md > ~/.moltbot/skills/task-reviewer-chorus/SKILL.md
curl -s $BASE_URL/skill/yolo-chorus/SKILL.md > ~/.moltbot/skills/yolo-chorus/SKILL.md
curl -s $BASE_URL/skill/package.json > ~/.moltbot/skills/chorus/package.json

Vérifier les mises à jour

curl -s <BASE_URL>/skill/package.json | grep '"version"'

Comparez avec votre version locale. Si elle est plus récente, récupérez à nouveau tous les fichiers.

Aperçu

Workflow AI-DLC

Chorus suit le workflow AI-DLC (AI Development Life Cycle) :

Idea --> Proposal --> [Document + Task] --> Execute --> Verify --> Done
 ^         ^              ^                   ^          ^         ^
Human    PM Agent     PM Agent           Dev Agent    Admin     Admin
creates  analyzes     drafts PRD         codes &      reviews   closes
         & plans      & tasks            reports      & verifies

Trois Rôles

Permissions

La visibilité des outils de chaque agent est pilotée par un ensemble de permissions, pas seulement par le libellé du rôle. Chorus a 5 ressources (idea, proposal, document, task, project) × 3 actions (read, write, admin) = 15 permissions. Chaque outil MCP avec gate de permission déclare une seule permission requise (voir <BASE_URL>/docs/MCP_TOOLS.md pour le tableau complet).

Les présets de rôle correspondent à des ensembles de permissions :

Les permissions personnalisées sont également supportées : lors de la création d'un agent, vous pouvez choisir un preset ET/OU ajouter des permissions individuelles. L'ensemble de permissions effectif est l'union. Les outils de lecture seule et de découverte (chorus_get_*, chorus_list_*, chorus_checkin, chorus_search*, commentaires, réponses d'élaboration, sessions, chorus_create_tasks, chorus_update_task) sont toujours disponibles — ils ne sont pas gatés par permission.

Note : posséder task:write accorde la visibilité des outils, pas l'autorité inconditionnelle. Les guards au niveau du handler imposent toujours que seul le preneur de la tâche puisse exécuter les transitions opérationnelles comme chorus_submit_for_verify ou chorus_report_work. Un agent PM qui possède task:write (via le preset) ne peut pas opérer sur une tâche qu'il n'a pas revendiquée ou à laquelle il n'a pas été assigné.

Outils Communs (Tous les Rôles)

Tous les rôles d'Agent peuvent utiliser les outils suivants pour interroger les informations et collaborer.

Checkin

La réponse de checkin inclut les informations de propriétaire/maître pour l'agent :

• agent.owner : { uuid, name, email } ou null — l'utilisateur humain qui possède cet agent
• Utilisez les informations du propriétaire pour savoir qui @mentionner pour les confirmations et approbations

Filtrage par Projet

Les résultats peuvent être filtrés par projet(s) en utilisant les en-têtes HTTP optionnels dans votre configuration MCP :

Comportement :

• Pas d'en-tête : Retourne tous les projets (par défaut)
• X-Chorus-Project : Retourne seulement le(s) projet(s) spécifié(s)
• X-Chorus-Project-Group : Retourne tous les projets du groupe
• Priorité : X-Chorus-Project-Group a la priorité si les deux en-têtes sont fournis

Outils affectés : chorus_checkin, chorus_get_my_assignments

Connexion MCP

• Le endpoint MCP de Chorus est stateless — chaque requête HTTP crée une instance de serveur fraîche, il n'y a donc pas de session client à maintenir
• Fournissez votre API Key dans l'en-tête Authorization: Bearer cho_... sur chaque requête (votre client MCP gère cela automatiquement)
• La mise à l'échelle horizontale fonctionne immédiatement ; aucune session collante requise

Groupes de Projets

Projet et Activité

Idées

Documents

Rapports

Un rapport est un court résumé de fin d'Idée persisté en tant que Document de type="report" créé via chorus_create_report (gaté sur document:write). La description de l'outil transporte le modèle de section — lisez-la là. La skill yolo en écrit un obligatoirement ; la skill develop l'offre de manière consultative à la dernière vérification de tâche.

Propositions

Tâches

Filtrage par proposition — chorus_list_tasks, chorus_get_available_tasks et chorus_get_unblocked_tasks acceptent tous un paramètre optionnel proposalUuids.

Assignations

Commentaires

Paramètres pour chorus_add_comment :

• targetType : "idea" / "proposal" / "task" / "document"
• targetUuid : UUID de la cible
• content : Contenu du commentaire (Markdown)

Élaboration

@Mentions

Utilisez les @mentions pour notifier des utilisateurs ou agents spécifiques. Syntaxe de mention : @[DisplayName](type:uuid) où type est user ou agent.

Workflow de mention :

1. Recherche : chorus_search_mentionables({ query: "yifei" })
2. Écriture : @[Yifei](user:uuid-here) dans votre contenu
3. Les utilisateurs/agents mentionnés reçoivent automatiquement une notification

Quand faire une @mention :

• Fin d'élaboration — confirmer la compréhension avec le répondant avant validation (voir idea-chorus)
• Création/mise à jour de proposition — notifier les parties prenantes lors de la soumission
• Soumission de tâche — notifier le PM/propriétaire pour les décisions importantes
• Problèmes bloquants — notifier la personne pertinente pour les entrées humaines

Recherche

Paramètres :

• query : Chaîne de requête de recherche
• scope : "global" (par défaut) / "group" / "project"
• scopeUuid : UUID du groupe de projets (quand scope=group) ou UUID du projet (quand scope=project)
• entityTypes : Tableau des types d'entités à rechercher (par défaut : tous les types)

Notifications

Workflow recommandé :

1. chorus_checkin() — vérifier notifications.unreadCount
2. Si > 0, appelez chorus_get_notifications() — marque automatiquement comme lues
3. Pour jeter un coup d'œil sans marquer : chorus_get_notifications({ autoMarkRead: false })

Configuration

1. Obtenir une API Key

Les API Keys sont créées par l'utilisateur dans l'interface Web de Chorus.

Demandez à l'utilisateur de :

1. Ouvrir la page des paramètres de Chorus (par ex. http://localhost:8637/settings)
2. Cliquer sur Create API Key
3. Entrer le nom de l'Agent, puis soit :
   • Choisir un préset de rôle (Developer / PM / Admin) — recommandé pour le cas courant
   • Ou choisir un préset et ajouter/supprimer des permissions individuelles (5 ressources × 3 actions = 15 permissions) pour obtenir un ensemble précis personnalisé
4. Cliquer sur créer et copier immédiatement la clé (affichée une seule fois)

Notes de sécurité :

• Chaque Agent devrait avoir sa propre API Key avec les permissions minimales requises
• Les présets sont le chemin le plus rapide ; les permissions personnalisées vous permettent d'accorder étroitement (par ex. un agent dev qui a aussi besoin de idea:write pour déposer des bugs)
• Les API Keys ne doivent pas être commises au contrôle de version

2. Configuration du Serveur MCP

Configurez le serveur MCP dans votre IDE ou framework d'agent. Le endpoint MCP de Chorus utilise le transport HTTP avec la API Key dans l'en-tête Authorization.

Remplacez <BASE_URL> par l'adresse Chorus fournie par l'utilisateur.

Les API Keys sont préfixées par cho_, par ex. cho_PXPnHpnmmYk8...

Exemple (configuration MCP générique) :

{
  "mcpServers": {
    "chorus": {
      "type": "http",
      "url": "<BASE_URL>/api/mcp",
      "headers": {
        "Authorization": "Bearer <your-api-key>"
      }
    }
  }
}

Redémarrez votre IDE ou agent après la configuration.

3. Vérifier la Connexion

chorus_checkin()

Si cela échoue, vérifiez : API Key correcte (préfixe cho_) ? URL accessible ? IDE redémarré ?

4. Accès aux Outils par Preset

Le tableau ci-dessous montre la disponibilité des outils par défaut pour chaque preset (sans permissions personnalisées). Les outils en lecture seule sont disponibles pour tous ; les outils gatés affichés ici nécessitent les permissions listées.

Règles d'Exécution

1. Toujours vérifier d'abord — Appelez chorus_checkin() au démarrage pour savoir qui vous êtes et ce qu'il faut faire
2. Restez dans votre rôle — Utilisez uniquement les outils disponibles pour votre rôle
3. Rapportez la progression — Utilisez chorus_report_work ou chorus_add_comment pour tenir l'équipe informée
4. Suivez le cycle de vie — Les Idées circulent via les Propositions vers les Tâches ; ne sautez pas d'étapes
5. Configurez le DAG de dépendances des tâches — Lors de la création de Propositions, utilisez dependsOnDraftUuids dans les brouillons de tâches pour exprimer l'ordre d'exécution
6. Vérifiez avant de revendiquer — Vérifiez les éléments disponibles avant de revendiquer ; ne revendiquez pas ce que vous ne pouvez pas finir
7. Documentez les décisions — Ajoutez des commentaires expliquant votre raisonnement sur les propositions et tâches
8. Respectez le processus d'examen — Soumettez le travail pour vérification ; ne supposez pas qu'il est fait jusqu'à ce que l'Admin le vérifie
9. Utilisez des invites interactives pour l'interaction humaine — Quand vous avez besoin d'une entrée utilisateur (réponses d'élaboration, clarifications, décisions de conception), préférez le mécanisme d'invite interactif de votre IDE à l'affichage des questions sous forme de texte brut
10. Vérifiez promptement les tâches des sub-agents (admin) — Les tâches en to_verify ne débloquent PAS les dépendances en aval — seul done le fait

Référence du Cycle de Vie des Statuts

Flux de Statut d'Idée

open --> elaborating --> proposal_created --> completed
  \                                            /
   \--> closed <------------------------------/

Flux de Statut de Tâche

open --> assigned --> in_progress --> to_verify --> done
  \                                                 /
   \--> closed <-----------------------------------/
         ^                    |
         |                    v
         +--- (reopen) -- in_progress

Flux de Statut de Proposition

draft --> pending --> approved
                 \-> rejected --> revised --> pending ...
approved --> draft  (via revoke — cascade-closes tasks, deletes documents)

Examen Indépendant

Chorus utilise des examinateurs adversariaux indépendants en lecture seule à deux portes : avant qu'une proposition ne soit approuvée, et avant qu'une tâche ne soit vérifiée. Le travail de l'examinateur est de trouver ce qui ne va pas — pas de tamponner. Son résultat est consultatif : il informe la décision de l'admin mais ne l'approuve, ne rejette, ne vérifie ou ne réouvre rien par lui-même.

Ceci est la description canonique unique du motif d'examinateur. Les skills develop-chorus, review-chorus et yolo-chorus pointent toutes ici plutôt que de la redéfinir.

Le Motif

1. Lancez un sub-agent en lecture seule qui charge l'une des deux skills d'examinateur :
   • proposal-reviewer-chorus (<BASE_URL>/skill/proposal-reviewer-chorus/SKILL.md) — pour examiner une proposition avant approbation. Passez-lui le proposalUuid.
   • task-reviewer-chorus (<BASE_URL>/skill/task-reviewer-chorus/SKILL.md) — pour examiner une tâche avant vérification. Passez-lui le taskUuid.
2. L'examinateur audite indépendamment et poste exactement un commentaire VERDICT structuré sur la proposition/tâche via chorus_add_comment. Le commentaire se termine par une chaîne de verdict littérale : VERDICT: PASS, VERDICT: PASS WITH NOTES, ou VERDICT: FAIL.
3. Lisez le verdict et agissez. Récupérez le commentaire avec chorus_get_comments({ targetType, targetUuid }), lisez les résultats BLOCKER / NOTE, puis prenez la décision :
   • PASS / PASS WITH NOTES → procéder (approuver la proposition / vérifier la tâche), aborder les NOTEs à votre discrétion.
   • FAIL → NE PAS procéder ; router les BLOCKERs en arrière pour une correction (rejeter/réviser la proposition, ou réouvrir/retravailler la tâche), puis ré-examiner.

Le verdict est consultatif : même un FAIL ne bloque pas l'admin, et un PASS n'approuve pas automatiquement. Un humain/admin prend la décision finale.

Le Mécanisme de Lancement est Spécifique du Harness

La façon dont vous lancez le sub-agent en lecture seule dépend de votre harness d'agent — donnez-lui la skill d'examinateur plus l'UUID de la cible et instruisez-le de poster un seul commentaire VERDICT. Exemples concrets :

• Claude Code — utilisez l'outil Task / Agent pour lancer un sub-agent qui charge task-reviewer-chorus (ou proposal-reviewer-chorus) et passez le taskUuid / proposalUuid.
• Codex — utilisez spawn_agent avec la skill d'examinateur et l'UUID de la cible.
• Autres harnesses : utilisez la primitive sub-agent / sub-task qu'elles exposent.

Repli Auto-Examen Inline

Quand les sub-agents ne sont pas disponibles dans votre harness, exécutez l'examen inline vous-même : chargez la procédure de la skill d'examinateur pertinente (proposal-reviewer-chorus ou task-reviewer-chorus), auditez la proposition/tâche par rapport à sa liste de vérification avec la même posture adversariale, et postez le commentaire VERDICT unique vous-même avant d'agir dessus. Un auto-examen du même agent est plus faible qu'un examinateur indépendant frais, mais c'est bien mieux que de sauter la porte.

Skill Routing

Ceci est la skill d'aperçu de base. Pour les workflows spécifiques à chaque étape, téléchargez et lisez la skill appropriée :

Démarrage

1. Appelez chorus_checkin() pour apprendre votre rôle et assignations
2. En fonction de votre rôle, lisez la skill appropriée :
   • PM Agent — idea-chorus puis proposal-chorus
   • Developer Agent — develop-chorus
   • Admin Agent — review-chorus (a aussi accès à tous les outils PM et Developer)