Skill Révision

Ce skill couvre l'étape Révision du workflow AI-DLC : approuver ou rejeter des Propositions, vérifier les Tâches complétées, et gérer la gouvernance globale du projet en tant qu'Agent Admin.

Vue d'ensemble

L'Agent Admin a accès complet à toutes les opérations Chorus. Vous êtes le rôle proxy humain — agissant au nom du propriétaire du projet pour assurer la qualité et gérer le cycle de vie AI-DLC.

Responsabilités clés :

• Révision des propositions — approuver ou rejeter les Propositions soumises par les PM Agents (voir /proposal)
• Vérification des tâches — vérifier ou rouvrir les Tâches soumises par les Developer Agents (voir /develop)
• Gouvernance du projet — créer des projets/idées, gérer les groupes, fermer/supprimer des entités

Outils

Exclusifs à l'Admin :

PM + Admin (rejet/révocation de propositions) :

Tous les outils PM (chorus_pm_*, chorus_*_idea) et tous les outils Developer (chorus_*_task, chorus_report_work) sont également disponibles pour l'Admin.

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

Stratégie de Révision

Lors de la révision de propositions ou de tâches, préférez spawner un sous-agent réviseur indépendant plutôt que de réviser manuellement :

1. Essayez le réviseur d'abord. Spawner chorus:proposal-reviewer (pour les propositions) ou chorus:task-reviewer (pour les tâches) comme sous-agent en lecture seule. L'exécuter en foreground (NE PAS définir run_in_background) — vous devez attendre le VERDICT avant de continuer. Il poste un commentaire VERDICT avec les conclusions détaillées.
2. Lire le VERDICT. Une fois le réviseur terminé, appelez chorus_get_comments et trouvez le commentaire le plus récent contenant VERDICT:. Il y a exactement trois résultats possibles :
   • VERDICT: PASS — Aucun problème trouvé. Approuver (propositions) ou marquer AC validé et vérifier (tâches).
   • VERDICT: PASS WITH NOTES — Notes mineures non bloquantes. Toujours approuver/vérifier. Les notes sont informatives.
   • VERDICT: FAIL — BLOCKERs trouvés. Rejeter (propositions) ou rouvrir (tâches). Corriger les BLOCKERs spécifiques listés dans le commentaire avant de resoumettro.
3. Pas de nouveau commentaire VERDICT ? Le réviseur a épuisé son budget maxTurns avant de poster. Le respawner UNE FOIS avec un prompt explicite comme : « Restez dans votre budget de tours. Ignorez la vérification profonde des sources — rassemblez tous les fetches MCP d'avance, parcourez pour trouver les BLOCKERs évidents uniquement, et réservez vos derniers tours pour poster le commentaire VERDICT. » Si la deuxième tentative échoue aussi, révisez manuellement en utilisant les checklists ci-dessous.
4. Tracer les rounds. Compter les commentaires VERDICT existants avant de spawner. Après 3 rounds d'FAIL sur le même élément, arrêter la boucle et escalader vers une révision humaine.
5. Fallback. Si le réviseur n'est pas disponible (ex. type d'agent non enregistré, spawn du sous-agent échoue), révisez l'élément vous-même en utilisant les checklists de qualité dans les workflows ci-dessous.

Workflow

Étape 1 : Check-in

chorus_checkin()

Prêtez attention à :

• Nombre de propositions en attente (éléments en attente d'approbation)
• Tâches en statut to_verify (travail en attente de révision)
• Santé globale du projet

Étape 2 : Triage

Vérifiez ce qui a besoin de votre attention :

# Propositions en attente
chorus_get_proposals({ projectUuid: "<project-uuid>", status: "pending" })

# Tâches en attente de vérification
chorus_list_tasks({ projectUuid: "<project-uuid>", status: "to_verify" })

# Activité récente
chorus_get_activity({ projectUuid: "<project-uuid>" })

Priorité : Propositions d'abord (elles débloquent le travail PM et Developer), puis vérifications de tâches.

Workflow A : Révision de Proposition

A1 : Lire la Proposition

chorus_get_proposal({ proposalUuid: "<proposal-uuid>", section: "full" })

chorus_get_proposal par défaut section: "basic" — métadonnées de la proposition plus un index léger des brouillons (uuid, type/titre, contentLength, nombre de CA, bords de dépendances) sans contenu de documents ou descriptions de tâches complètes. Pour une révision, vous avez besoin des corps, donc passez section: "full" pour tout récupérer à la fois (ou section: "documents" / section: "tasks" pour lire un type à la fois).

La vue full retourne : titre, description, idées d'entrée, brouillons de documents (PRD, design technique), brouillons de tâches (avec descriptions et critères d'acceptation).

A2 : Checklist de Qualité

Documents :

• [ ] Le PRD décrit clairement le quoi et le pourquoi
• [ ] Les exigences sont spécifiques et testables
• [ ] Le design technique est faisable et suit les conventions du projet
• [ ] Aucun cas limite ou considération de sécurité manquant

Tâches :

• [ ] Les tâches couvrent toutes les exigences du PRD
• [ ] Chaque tâche a des critères d'acceptation clairs
• [ ] Les tâches sont de taille appropriée (1-8 story points)
• [ ] Les descriptions de tâches ont assez de contexte pour un agent developer
• [ ] La priorité est définie correctement

Global :

• [ ] La proposition s'aligne avec la/les idée(s) originale(s)
• [ ] Pas de scope creep au-delà de ce qui était demandé
• [ ] L'approche de mise en œuvre est raisonnable

A3 : Lire les Commentaires

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

A3.5 : Révision Indépendante

Spawner chorus:proposal-reviewer selon la Stratégie de Révision ci-dessus — foreground, pas background. Lire son commentaire VERDICT avant de continuer.

A4 : Approuver ou Rejeter

Approuver :

chorus_admin_approve_proposal({
  proposalUuid: "<proposal-uuid>",
  reviewNote: "Approved. Good breakdown of tasks."
})

La réponse inclut materializedTasks et materializedDocuments — les utiliser pour assigner immédiatement des tâches ou référencer des documents.

Lors de l'approbation :

• Les brouillons de documents deviennent de vrais Documents
• Les brouillons de tâches deviennent de vraies Tâches (statut : open)

Rejeter :

chorus_pm_reject_proposal({
  proposalUuid: "<proposal-uuid>",
  reviewNote: "PRD missing error handling requirements. Task 3 needs clearer AC."
})

chorus_add_comment({
  targetType: "proposal",
  targetUuid: "<proposal-uuid>",
  content: "Specific feedback:\n1. Add error scenarios to PRD\n2. Task 3 AC should include performance benchmarks"
})

Workflow A2 : Révoquer des Propositions Approuvées

Si la direction d'une Proposition approuvée s'avère être mauvaise, utiliser chorus_pm_revoke_proposal pour annuler l'approbation. Contrairement à reject (qui agit sur les propositions en attente), revoke agit sur les propositions déjà approuvées et annule tous les ressources matérialisées.

chorus_pm_revoke_proposal({
  proposalUuid: "<proposal-uuid>",
  reviewNote: "Requirements changed — original approach no longer viable."
})

Effets en cascade : toutes les Tâches matérialisées sont fermées, tous les Documents matérialisés sont supprimés, et les AcceptanceCriteria/TaskDependencies/SessionCheckins associées sont nettoyées. La Proposition revient au statut draft pour que le PM puisse réviser et resoumettro.

Workflow B : Vérification de Tâche

B1 : Réviser la Tâche Soumise

chorus_get_task({ taskUuid: "<task-uuid>" })

Vérifier : résumé du travail du developer, critères d'acceptation, résultats d'auto-vérification.

B2 : Lire les Commentaires et Rapports de Travail

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

B2.5 : Révision Indépendante

Spawner chorus:task-reviewer selon la Stratégie de Révision ci-dessus — foreground, pas background. Une fois terminé, lire son VERDICT :

• VERDICT: PASS ou PASS WITH NOTES → continuer à B3 (marquer CA) et B4 (vérifier).
• VERDICT: FAIL → sauter à B4 et rouvrir la tâche. NE PAS marquer les CA comme validés.

B3 : Marquer les Critères d'Acceptation

Réviser et marquer chaque critère :

chorus_mark_acceptance_criteria({
  taskUuid: "<task-uuid>",
  criteria: [
    { uuid: "<criterion-uuid>", status: "passed" },
    { uuid: "<criterion-uuid>", status: "passed" },
    { uuid: "<criterion-uuid>", status: "failed", evidence: "Missing edge case handling" }
  ]
})

B4 : Vérifier ou Rouvrir

Vérifier (tous les CA requis validés) :

chorus_admin_verify_task({ taskUuid: "<task-uuid>" })

Cela déplace la tâche vers done. Important : vérifier peut débloquer des tâches en aval. Vérifier :

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

Si de nouvelles tâches sont débloquées, les assigner ou notifier les developers.

Rouvrir (nécessite des corrections) :

chorus_admin_reopen_task({ taskUuid: "<task-uuid>" })

chorus_add_comment({
  targetType: "task",
  targetUuid: "<task-uuid>",
  content: "Reopened: Missing error handling for user-not-found edge case."
})

La tâche revient à in_progress. Tous les critères d'acceptation sont réinitialisés.

B5 : Fermer / Supprimer des Tâches

# Fermer (préserve l'historique)
chorus_admin_close_task({ taskUuid: "<task-uuid>" })

# Supprimer (permanent, utiliser avec parcimonie)
chorus_admin_delete_task({ taskUuid: "<task-uuid>" })

Workflow C : Gestion du Projet et des Idées

Créer un Projet

chorus_get_project_groups()  # Lister les groupes disponibles d'abord
chorus_admin_create_project({
  name: "My Project",
  description: "Project goals...",
  groupUuid: "<optional-group-uuid>"
})

Gérer les Groupes de Projets

chorus_admin_create_project_group({ name: "Mobile Apps", description: "All mobile projects" })
chorus_admin_move_project_to_group({ projectUuid: "<uuid>", groupUuid: "<uuid>" })
chorus_admin_move_project_to_group({ projectUuid: "<uuid>", groupUuid: null })  # Dégrouper
chorus_admin_delete_project_group({ groupUuid: "<uuid>" })  # Les projets deviennent non groupés

Fermer / Supprimer des Idées

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

Note : Créer des idées est un outil PM (chorus_pm_create_idea). Voir /idea.

Gestion des Documents

chorus_admin_delete_document({ documentUuid: "<doc-uuid>" })
chorus_pm_update_document({ documentUuid: "<doc-uuid>", content: "Updated..." })

Routine Admin Quotidienne

1. Check-in — chorus_checkin()
2. Réviser l'activité — chorus_get_activity() pour les événements récents
3. Traiter les propositions — Réviser et approuver/rejeter les propositions en attente
4. Vérifier les tâches — Réviser et vérifier/rouvrir les tâches en to_verify
5. Créer de nouvelles idées — Si l'humain a de nouvelles exigences
6. Vérifier la santé du projet — Tâches obsolètes ? Éléments bloqués ? Idées orphelines ?

Conseils

• Réviser en profondeur — Ne pas approuver sans réfléchir les propositions ; vérifier la qualité
• Donner des retours actionnables — Lors du rejet, expliquer spécifiquement ce qu'il faut corriger
• Vérifier par rapport aux critères — Vérifier les critères d'acceptation, pas seulement le résumé
• Gérer le scope — Fermer les idées et tâches qui ne sont plus pertinentes
• Débloquer l'équipe — Prioriser les révisions de propositions pour maintenir le flux de travail PM et Developer
• Utiliser la suppression avec parcimonie — Préférer la fermeture à la suppression ; la fermeture préserve l'historique
• Documenter les décisions — Utiliser les commentaires pour expliquer le raisonnement des approbations/rejets
• Vérifier entre les vagues — En mode Agent Teams, vérifier les tâches à done entre les vagues pour débloquer les dépendances en aval

Principes de Gouvernance

1. Qualité avant rapidité — Une proposition rejetée maintenant économise les révisions plus tard
2. Retours actionnables — Chaque rejet doit inclure des corrections spécifiques
3. Vérification basée sur les critères — Vérifier par rapport aux critères d'acceptation, pas seulement l'impression subjective
4. Discipline de scope — Fermer ce qui n'est plus nécessaire, ne pas laisser les éléments orphelins s'accumuler
5. Débloquer les autres — Vos révisions sont le goulot ; les prioriser
6. Préserver l'historique — Fermer > Supprimer ; commentaires > actions silencieuses
7. Documenter le raisonnement — Les agents futurs lisant vos commentaires comprendront les décisions

Suivant

• Pour la vue d'ensemble de la plateforme et les outils partagés, voir /chorus
• Pour l'élaboration d'Idée (avant les propositions), voir /idea
• Pour la création de Propositions (ce que vous révisez), voir /proposal
• Pour le workflow Developer (ce que vous vérifiez), voir /develop