TaskCreate({
  subject: "Implémenter l'authentification",
  description: "Créer les endpoints login/logout avec JWT. Voir specs/auth-plan.md.",
  activeForm: "Implémentation de l'authentification"
})
// Retourne : taskId (ex: "1")

TaskUpdate({
  taskId: "1",
  status: "in_progress",  // pending → in_progress → completed
  owner: "builder-auth"
})

TaskList({})

TaskGet({ taskId: "1" })

// La tâche 2 dépend de la tâche 1
TaskUpdate({ taskId: "2", addBlockedBy: ["1"] })

// La tâche 3 dépend des tâches 1 et 2
TaskUpdate({ taskId: "3", addBlockedBy: ["1", "2"] })

Tâche 1: Fondations          → aucune dépendance
Tâche 2: Implémentation      → bloquée par: ["1"]
Tâche 3: Tests                → bloquée par: ["2"]
Tâche 4: Validation finale    → bloquée par: ["1", "2", "3"]

Task({
  description: "Implémenter les endpoints auth",
  prompt: "Implémente les endpoints d'authentification selon la Tâche 1...",
  subagent_type: "builder",
  model: "opus",  // ou "haiku" pour les tâches très simples
  run_in_background: false  // true pour exécution parallèle
})
// Retourne : agentId (ex: "a1b2c3")

// Premier déploiement
Task({
  description: "Construire le service utilisateur",
  prompt: "Crée le service utilisateur avec les opérations CRUD...",
  subagent_type: "builder"
})
// Retourne : agentId: "abc123"

// Plus tard — reprendre le MÊME agent avec contexte préservé
Task({
  description: "Continuer le service utilisateur",
  prompt: "Ajoute la validation des entrées aux endpoints que tu as créés...",
  subagent_type: "builder",
  resume: "abc123"
})

// Lancer plusieurs agents en parallèle
Task({
  description: "Construire les endpoints API",
  prompt: "...",
  subagent_type: "builder",
  run_in_background: true
})

Task({
  description: "Construire les composants frontend",
  prompt: "...",
  subagent_type: "builder",
  run_in_background: true
})

// Vérifier la progression (non-bloquant)
TaskOutput({ task_id: "agentId", block: false, timeout: 5000 })

// Attendre la fin (bloquant)
TaskOutput({ task_id: "agentId", block: true, timeout: 300000 })

# Plan : <nom de la tâche>

## Description de la tâche
<décris la tâche en détail basé sur le prompt>

## Objectif
<indique clairement ce qui sera accompli quand ce plan sera terminé>

<si type_tâche est feature ou complexité est moyenne/complexe, inclure :>
## Problématique
<définis clairement le problème spécifique ou l'opportunité que cette tâche adresse>

## Approche de solution
<décris l'approche proposée et comment elle répond à l'objectif>
</si>

## Fichiers concernés
Utilise ces fichiers pour compléter la tâche :

<liste les fichiers pertinents avec des puces expliquant pourquoi. Inclus les nouveaux fichiers à créer sous un h3 'Nouveaux fichiers' si nécessaire>

<si complexité est moyenne/complexe, inclure :>
## Phases d'implémentation
### Phase 1 : Fondations
<décris le travail fondationnel nécessaire>

### Phase 2 : Implémentation principale
<décris le travail d'implémentation principal>

### Phase 3 : Intégration et finalisation
<décris l'intégration, les tests et les touches finales>
</si>

## Orchestration d équipe

- Tu opères en tant que chef d'équipe et orchestres l'équipe pour exécuter le plan.
- Tu es responsable de déployer les bons membres d'équipe avec le bon contexte.
- IMPORTANT : Tu n'opères JAMAIS directement sur le codebase. Tu utilises `Task` et `Task*` pour déléguer la construction, la validation, les tests et le déploiement.
  - C'est critique. Ton rôle est celui d'un directeur haut niveau, pas d'un builder.
  - Tu valides que tout se passe bien et t'assures que l'équipe est sur la bonne voie.
  - Tu orchestres via les outils Task* pour gérer la coordination entre les membres.
  - La communication est primordiale. Utilise les outils Task* pour communiquer et assurer le suivi.
- Note l'ID de session de chaque membre d'équipe pour les référencer.

### Membres de l équipe
<liste les membres d'équipe que tu utiliseras pour exécuter le plan>

- Builder
  - Nom : <nom unique pour ce builder — permet de le référencer. Il peut y en avoir plusieurs, le nom les distingue.>
  - Rôle : <le rôle unique et le focus de ce builder>
  - Type d'agent : <le subagent_type de ce builder, spécifié depuis les fichiers MEMBRES_EQUIPE ou AGENT_GENERAL>
  - Reprendre : <true par défaut. Permet à l'agent de continuer avec le même contexte. false pour repartir à zéro.>
- <continuer avec les membres supplémentaires dans le même format>

## Étapes de réalisation

- IMPORTANT : Exécute chaque étape dans l'ordre, de haut en bas. Chaque tâche correspond directement à un appel `TaskCreate`.
- Avant de commencer, lance `TaskCreate` pour créer la liste initiale que tous les membres peuvent voir et exécuter.

<liste les tâches étape par étape en h3. Commence par les fondations, puis l'implémentation, puis la validation.>

### 1. <Nom de la première tâche>
- **ID Tâche** : <identifiant unique en kebab-case, ex: "setup-database">
- **Dépend de** : <ID(s) de tâche dont celle-ci dépend, ou "aucune">
- **Assignée à** : <nom du membre d'équipe depuis la section Membres>
- **Type d'agent** : <subagent depuis MEMBRES_EQUIPE ou AGENT_GENERAL>
- **Parallèle** : <oui si peut tourner en même temps que d'autres, non si séquentiel>
- <action spécifique à réaliser>
- <action spécifique à réaliser>

### 2. <Nom de la deuxième tâche>
- **ID Tâche** : <identifiant-unique>
- **Dépend de** : <ID tâche précédente, ex: "setup-database">
- **Assignée à** : <nom du membre>
- **Type d'agent** : <type d'agent>
- **Parallèle** : <oui/non>
- <action spécifique>
- <action spécifique>

### 3. <Continuer le pattern>

### N. <Tâche de validation finale>
- **ID Tâche** : valider-tout
- **Dépend de** : <tous les IDs de tâches précédentes>
- **Assignée à** : <membre validateur>
- **Type d'agent** : <agent validateur>
- **Parallèle** : non
- Lancer toutes les commandes de validation
- Vérifier que les critères d'acceptation sont remplis

<continuer avec des tâches supplémentaires si nécessaire>

## Critères d acceptation
<liste des critères spécifiques et mesurables qui doivent être remplis pour que la tâche soit considérée comme terminée>

## Commandes de validation
Exécute ces commandes pour valider que la tâche est complète :

<liste les commandes spécifiques de validation. Sois précis sur ce qu'il faut lancer>
- Exemple : `uv run python -m py_compile apps/*.py` — Vérifie que le code compile

## Notes
<contexte additionnel optionnel, considérations ou dépendances. Si de nouvelles librairies sont nécessaires, spécifie avec `uv add`>

Plan d'implémentation créé

Fichier : REPERTOIRE_SORTIE/<nom-fichier>.md
Sujet : <brève description de ce que couvre le plan>
Composants clés :
- <composant principal 1>
- <composant principal 2>
- <composant principal 3>

Liste des tâches :
- <liste des tâches et responsable (concis)>

Membres de l'équipe :
- <liste des membres et leurs rôles (concis)>

Quand tu es prêt, tu peux exécuter le plan avec :
/build <remplacer par le chemin vers le plan>