Stratégies de Coordination des Tâches

Stratégies pour décomposer les tâches complexes en unités paraллélisables, concevoir des graphes de dépendances, rédiger des descriptions de tâches efficaces et surveiller la charge de travail dans les équipes d'agents.

Quand Utiliser Cette Compétence

• Décomposer une tâche complexe pour une exécution parallèle
• Concevoir les relations de dépendance entre tâches (blockedBy/blocks)
• Rédiger des descriptions de tâches avec des critères d'acceptation clairs
• Surveiller et rééquilibrer la charge de travail entre coéquipiers
• Identifier le chemin critique dans un workflow multi-tâches

Stratégies de Décomposition des Tâches

Par Couche

Répartir le travail par couche architecturale :

• Composants frontend
• Points d'accès API backend
• Migrations/modèles de base de données
• Suites de tests

Idéal pour : Fonctionnalités full-stack, tranches verticales

Par Composant

Répartir le travail par composant fonctionnel :

• Module d'authentification
• Module profil utilisateur
• Module de notifications

Idéal pour : Architectures microservices, architectures modulaires

Par Préoccupation

Répartir le travail par préoccupation transversale :

• Revue de sécurité
• Revue de performance
• Revue d'architecture

Idéal pour : Revues de code, audits

Par Propriété de Fichier

Répartir le travail par limites de fichiers/répertoires :

• src/components/ — Implémenteur 1
• src/api/ — Implémenteur 2
• src/utils/ — Implémenteur 3

Idéal pour : Implémentation parallèle, prévention des conflits

Conception du Graphe de Dépendances

Principes

1. Minimiser la profondeur de chaîne — Préférer les graphes larges et peu profonds aux chaînes profondes
2. Identifier le chemin critique — La chaîne la plus longue détermine le temps minimum d'exécution
3. Utiliser blockedBy avec parcimonie — N'ajouter que les dépendances vraiment requises
4. Éviter les dépendances circulaires — La tâche A bloque B qui bloque A est un deadlock

Motifs

Indépendant (Meilleur parallélisme) :

Task A ─┐
Task B ─┼─→ Integration
Task C ─┘

Séquentiel (Dépendances nécessaires) :

Task A → Task B → Task C

Diamant (Mixte) :

        ┌→ Task B ─┐
Task A ─┤          ├→ Task D
        └→ Task C ─┘

Utiliser blockedBy/blocks

TaskCreate: { subject: "Build API endpoints" }         → Task #1
TaskCreate: { subject: "Build frontend components" }    → Task #2
TaskCreate: { subject: "Integration testing" }          → Task #3
TaskUpdate: { taskId: "3", addBlockedBy: ["1", "2"] }  → #3 attend #1 et #2

Bonnes Pratiques pour la Description des Tâches

Chaque tâche doit inclure :

1. Objectif — Ce qui doit être réalisé (1-2 phrases)
2. Fichiers Possédés — Liste explicite des fichiers/répertoires que ce coéquipier peut modifier
3. Exigences — Livrables ou comportements spécifiques attendus
4. Contrats d'Interface — Comment ce travail se connecte au travail des autres coéquipiers
5. Critères d'Acceptation — Comment vérifier que la tâche est bien faite
6. Limites de Portée — Ce qui est explicitement hors de portée

Modèle

## Objectif
Construire les points d'accès API d'authentification utilisateur.

## Fichiers Possédés
- src/api/auth.ts
- src/api/middleware/auth-middleware.ts
- src/types/auth.ts (partagé — lecture seule, ne pas modifier)

## Exigences
- POST /api/login — accepte email/mot de passe, retourne JWT
- POST /api/register — crée un nouvel utilisateur, retourne JWT
- GET /api/me — retourne le profil utilisateur actuel (authentification requise)

## Contrat d'Interface
- Importer le type User depuis src/types/auth.ts (possédé par implémenteur-1)
- Exporter le type AuthResponse pour consommation frontend

## Critères d'Acceptation
- Tous les points d'accès retournent les codes HTTP appropriés
- Les jetons JWT expirent après 24 heures
- Les mots de passe sont hashés avec bcrypt

## Hors de Portée
- Authentification OAuth/réseaux sociaux
- Flux de réinitialisation de mot de passe
- Rate limiting

Surveillance de la Charge de Travail

Indicateurs de Déséquilibre

Étapes de Rééquilibrage

1. Appeler TaskList pour évaluer l'état actuel
2. Identifier les coéquipiers inactifs ou surchargés
3. Utiliser TaskUpdate pour réassigner les tâches
4. Utiliser SendMessage pour notifier les coéquipiers affectés
5. Surveiller l'amélioration du débit