Gérer les plans et les tâches

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450

---
title: Gérer les plans et les tâches
---

# Gérer les plans et les tâches

Mini-me inclut un outil intégré **plan** qui permet à l'agent de créer, suivre et gérer des listes de tâches multi-étapes. Lorsque vous donnez à l'agent une liste de tâches à effectuer, il crée automatiquement un plan et suit la progression, en vous montrant l'état actuel après chaque réponse.

## Exemple rapide

```
Vous : Fais ces 3 choses : 1. Créer un fichier README, 2. Ajouter une licence, 3. Valider les modifications

Agent : Je vais m'en occuper en 3 étapes. En commençant par : Créer un fichier README
📋 plan: create user-request-1

Agent : Fichier README créé.
📋 [2/3] 🔄 Tâche 2 : Ajouter une licence (in_progress)

Agent : Licence ajoutée.
📋 [3/3] 🔄 Tâche 3 : Valider les modifications (in_progress)

Agent : Toutes les modifications ont été validées.
📋 [3/3] ✅ Toutes les tâches sont terminées !
```

La ligne `📋` vous montre exactement où se trouve l'agent dans votre plan.

---

## Fonctionnement

### Cycle de vie d'un plan

1. **Vous formulez votre demande** sous forme de liste de tâches
2. **L'agent détecte le plan** et le crée en utilisant l'outil `plan`
3. **L'agent travaille sur les tâches** une par une, en mettant à jour l'état
4. **L'agent signale la progression** après chaque action
5. **Le plan est terminé** lorsque toutes les tâches sont terminées

### Icônes d'état

| Icône | Signification |
|-------|--------------|
| ⏳ | Tâche non démarrée (ouverte) |
| 🔄 | Tâche en cours |
| ✅ | Tâche terminée avec succès |
| ❌ | Tâche en échec |

### Format de la ligne d'état

```
📋 [courante/total] icône Tâche N : description (état)
```

Exemples :
- `📋 [1/5] ⏳ Tâche 1 : Analyser le code (open)` - Première tâche, non démarrée
- `📋 [2/5] 🔄 Tâche 2 : Corriger les bugs (in_progress)` - Deuxième tâche, en cours
- `📋 [5/5] ✅ Toutes les tâches sont terminées !` - Tout est terminé !
- `📋 [3/5] ❌ Tâche 3 : Exécuter les tests (failed: timeout de connexion)` - Tâche en échec avec erreur

---

## Scénarios utilisateur

### Scénario 1 : Liste numérotée

**Votre entrée :**
```
Fais ces 5 choses :
1. Vérifier la version actuelle
2. Mettre à jour les dépendances
3. Exécuter les tests
4. Corriger les échecs
5. Déployer en staging
```

**Ce qui se passe :**
- L'agent crée un plan avec 5 tâches
- Travaille sur chaque tâche séquentiellement
- Affiche la progression : `📋 [1/5]`, `📋 [2/5]`, etc.
- Termine avec : `📋 [5/5] ✅ Toutes les tâches sont terminées !`

---

### Scénario 2 : Tâches séparées par des virgules

**Votre entrée :**
```
Configurer le projet : créer le répertoire, initialiser git, et ajouter un README
```

**Ce qui se passe :**
- L'agent détecte qu'il s'agit d'une demande multi-étapes
- Crée un plan avec 3 tâches
- Exécute dans l'ordre

---

### Scénario 3 : Plusieurs plans

Vous pouvez avoir plusieurs plans actifs dans une seule session.

**Votre entrée :**
```
D'abord, corrige le module d'authentification : 1. Trouver le bug, 2. Écrire la correction, 3. Le tester
```

L'agent travaille sur le plan d'authentification, affiche : `📋 [2/3] 🔄 Tâche 2 : Écrire la correction (in_progress)`

**Ensuite vous dites :**
```
Aussi, mettre à jour la documentation : 1. Mettre à jour le README, 2. Mettre à jour le CHANGELOG
```

L'agent crée un deuxième plan et gère les deux indépendamment.

**Pour voir tous les plans actifs :**
```
Quels plans ai-je ?
```

---

## Interagir avec les plans

### Vérifier l'état actuel du plan

**Demandez :** "Quel est l'état de mon plan ?"

**L'agent répond :**
```
Plan actuel : [2/3] 🔄 Tâche 2 : Écrire la correction (in_progress). Suivant : Le tester
```

### Sauter une tâche

**Demandez :** "Saute l'étape de test, déploie directement"

**Agent :**
- Marque la tâche actuelle comme terminée
- Saute à la tâche suivante
- Confirme : "Je saute l'étape de test. Déploiement en staging..."

### Abandonner un plan

**Demandez :** "Peu importe, je n'en ai plus besoin"

**Agent :**
- Demande confirmation
- Si vous confirmez, supprime le plan
- Toute la progression est perdue

---

## Commandes de gestion des plans

Bien que l'outil plan soit principalement piloté par le modèle (l'agent l'utilise automatiquement), vous pouvez également interagir directement avec les plans :

### Lister tous les plans

**Commande :** `/plans` (pas encore implémenté en v1 - arrive en v2)

**Ce que cela affiche :**
```
Plans actifs :
1. configuration-projet (2/5 tâches terminées)
2. corriger-bugs (0/3 tâches terminées)
```

### Voir les détails d'un plan

**Demandez à l'agent :** "Montre-moi les détails du plan X"

**L'agent répond :** Liste complète des tâches avec l'état pour chaque tâche

### Supprimer un plan

**Demandez à l'agent :** "Supprime le plan X"

**Agent :** Confirme et supprime le plan

---

## Cycle de vie de la session

### Plans et commande /new

Lorsque vous démarrez une nouvelle session avec `/new` :
- Tous les plans actifs sont **supprimés**
- C'est intentionnel : une nouvelle session signifie un nouveau départ
- Si vous voulez continuer un ancien plan, ne pas utiliser `/new`

### Plans et redémarrage de l'agent

En v1 (version actuelle) :
- Les plans sont stockés **uniquement en mémoire**
- Les plans sont **perdus** lorsque l'agent redémarre
- Cela garde la v1 simple et rapide

En v2 (future) :
- Les plans seront persistés dans les fichiers de session
- Les plans survivront aux redémarrages de l'agent

---

## L'outil plan (pour les utilisateurs avancés)

L'outil `plan` est disponible pour que le modèle puisse l'appeler. Il prend en charge ces actions :

| Action | Objectif | Paramètres requis |
|--------|----------|-------------------|
| `create` | Créer un nouveau plan | `tasks` (tableau de `{description}`) |
| `get` | Obtenir les détails d'un plan | `name` |
| `update` | Mettre à jour l'état d'une tâche | `name`, `taskId`, `status` |
| `next` | Passer à la tâche suivante | `name` |
| `list` | Lister tous les plans | aucun |
| `delete` | Supprimer un plan | `name` |
| `status` | Obtenir la ligne d'état | `name` |

### Valeurs d'état

- `open` - Tâche non démarrée
- `in_progress` - Tâche actuellement en cours
- `done` - Tâche terminée avec succès
- `failed` - Tâche en échec

---

## La compétence plan-manager

L'agent utilise la compétence `plan-manager` pour savoir **quand et comment** utiliser l'outil plan. Cette compétence inclut :

- **Modèles de détection** : Comment reconnaître quand un utilisateur donne une demande multi-étapes
- **Directives d'utilisation** : Quand créer des plans, mettre à jour des tâches, passer entre les tâches
- **Format d'affichage** : Comment montrer l'état du plan à l'utilisateur
- **Gestion des erreurs** : Que faire quand les choses tournent mal

Vous n'avez pas besoin de charger manuellement cette compétence - l'agent le fait automatiquement lorsque cela est approprié.

---

## Exemples

### Exemple 1 : Workflow de correction de bug

```
Vous : Corrige ces problèmes dans le module d'authentification :
     1. Vérifier les exceptions de pointeur nul
     2. Ajouter la validation des entrées
     3. Écrire des tests unitaires
     4. Mettre à jour la documentation

Agent : Je vais m'en occuper en 4 étapes. En commençant par : Vérifier les exceptions de pointeur nul
📋 plan: create user-request-1

... (l'agent vérifie le code) ...

Agent : 3 problèmes de pointeur nul potentiels trouvés.
📋 [2/4] 🔄 Tâche 2 : Ajouter la validation des entrées (in_progress)

... (l'agent ajoute la validation) ...

Agent : Validation des entrées ajoutée à auth.go.
📋 [3/4] 🔄 Tâche 3 : Écrire des tests unitaires (in_progress)

... (l'agent écrit les tests) ...

Agent : Tests écrits et réussis.
📋 [4/4] 🔄 Tâche 4 : Mettre à jour la documentation (in_progress)

... (l'agent met à jour les docs) ...

Agent : Documentation mise à jour avec les nouvelles exigences de validation.
📋 [4/4] ✅ Toutes les tâches sont terminées !
```

---

### Exemple 2 : Configuration d'un projet

```
Vous : Configure un nouveau projet Go avec :
     1. Initialisation du module
     2. Structure des répertoires
     3. Fichier main
     4. Fichier de test

Agent : Je vais configurer cela en 4 étapes. En commençant par : Initialisation du module
📋 plan: create user-request-1

Agent : Module initialisé avec go mod
📋 [2/4] 🔄 Tâche 2 : Structure des répertoires (in_progress)

Agent : Répertoires créés (cmd, internal, pkg, tests)
📋 [3/4] 🔄 Tâche 3 : Fichier main (in_progress)

Agent : Fichier main créé avec la structure de base
📋 [4/4] 🔄 Tâche 4 : Fichier de test (in_progress)

Agent : Fichier de test créé avec des tests exemples
📋 [4/4] ✅ Toutes les tâches sont terminées !
```

---

### Exemple 3 : Revue de code

```
Vous : Revoir cette PR et :
     1. Vérifier les problèmes de sécurité
     2. Vérifier que les tests passent
     3. Revoir la documentation
     4. Laisser des commentaires

Agent : Je vais revoir cette PR en 4 étapes. En commençant par : Vérifier les problèmes de sécurité
📋 plan: create user-request-1

Agent : Aucun problème de sécurité trouvé.
📋 [2/4] 🔄 Tâche 2 : Vérifier que les tests passent (in_progress)

Agent : Tous les tests passent.
📋 [3/4] 🔄 Tâche 3 : Revoir la documentation (in_progress)

Agent : La documentation a l'air bonne, il faut juste corriger une faute de frappe.
📋 [4/4] 🔄 Tâche 4 : Laisser des commentaires (in_progress)

Agent : Commentaires laissés sur la PR.
📋 [4/4] ✅ Toutes les tâches sont terminées !
```

---

### Exemple 4 : Avec un échec de tâche

```
Vous : Fais ceci :
     1. Se connecter à la base de données
     2. Exécuter la migration
     3. Importer les données

Agent : Je vais m'en occuper en 3 étapes. En commençant par : Se connecter à la base de données
📋 plan: create user-request-1

Agent : Connexion à la base de données établie.
📋 [2/3] 🔄 Tâche 2 : Exécuter la migration (in_progress)

Agent : Migration terminée.
📋 [3/3] 🔄 Tâche 3 : Importer les données (in_progress)

Agent : Erreur : timeout de connexion à la source de données
📋 plan: update user-request-1

Agent : ⚠️ La tâche 3 a échoué : timeout de connexion à la source de données
📋 [3/3] ❌ Tâche 3 : Importer les données (failed: connection timeout)

Agent : 2 des 3 tâches sont terminées. L'import des données a échoué en raison d'un timeout de connexion. Voulez-vous que je réessaye, ou que je saute cette tâche ?
```

---

## Configuration

L'outil plan peut être activé ou désactivé via le fichier de configuration YAML :

```yaml
# Dans votre fichier agent.yaml
planTool: true  # Activé par défaut
```

Pour désactiver :
```yaml
planTool: false
```

Lorsque désactivé, l'agent n'aura pas accès à l'outil `plan` et ne créera pas automatiquement de plans.

---

## Résolution des problèmes

### L'agent ne crée pas de plans

Si l'agent ne crée pas de plans pour vos demandes multi-étapes :

1. **Rendez votre demande plus claire** - Utilisez des listes numérotées
   - ❌ "Corrige quelques choses"
   - ✅ "Fais ceci : 1. Corrige A, 2. Corrige B, 3. Corrige C"

2. **Soyez plus explicite** - Utilisez des mots comme "plan", "étapes", "puis"
   - ✅ "Mon plan est de d'abord faire X, puis faire Y"

3. **Vérifiez que la compétence est chargée** - L'agent devrait automatiquement charger la compétence `plan-manager` lorsqu'il détecte une demande de type plan

### L'agent appelle `plan update` en boucle

`update` change l'état d'une tâche ; il ne peut pas modifier les tâches d'un plan. Un modèle qui envoie un `update` sans `status` valide — souvent avec une liste `tasks`, pour essayer de modifier le plan — reçoit une réponse qui cite son appel, nomme le champ manquant, précise que `tasks` n'est lu que par `create`, et donne un appel valide :

```
[error: plan update changes the status of ONE task, and "status" is missing. You sent: {…}. "status" must be one of: open, in_progress, done, failed. "tasks" is ignored by update (only create reads it): to change a plan's tasks, delete the plan and create it again. A valid call: {"action":"update","name":"user-request-1","taskId":1,"status":"done"}]
```

Si un petit modèle répète quand même l'appel, mettez `planTool: false` pour un agent dont le métier n'a pas besoin de plans (écrire un document, répondre à des questions) : le modèle travaille alors sans.

### Les plans disparaissent

En v1, les plans sont stockés en mémoire et seront perdus lorsque :
- Vous démarrez une nouvelle session avec `/new`
- L'agent redémarre
- Vous fermez et rouvrez le terminal

C'est un comportement attendu en v1. La persistance des sessions arrive en v2.

---

## Bonnes pratiques

1. **Soyez spécifique** - Plus il y a de détails dans vos descriptions de tâches, mieux l'agent peut les exécuter

2. **Gardez les plans concentrés** - Un plan par demande logique. Ne mélangez pas des tâches sans rapport

3. **Vérifiez la progression** - La ligne d'état vous montre exactement où se trouve l'agent

4. **Demandez des clarifications** - Si l'agent semble bloqué ou confus, demandez "Quel est l'état ?"

5. **Commencez petit** - Pour un travail multi-étapes complexe, commencez par quelques tâches et ajoutez-en davantage si nécessaire

---

## Comparaison avec d'autres outils

| Fonctionnalité | outil plan | compétences | commandes slash |
|---------------|------------|-------------|-----------------|
| Objectif | Suivre le travail multi-étapes | Charger des procédures | Commandes utilisateur |
| Déclenchement | Automatique (modèle détecte) | Explicite (`/skill`) | Explicite (`/command`) |
| Persistance (v1) | En mémoire, session uniquement | Basé sur des fichiers | N/A |
| Interaction utilisateur | Indirecte (via le modèle) | Indirecte (modèle charge) | Directe |

L'outil `plan` complète les autres fonctionnalités de mini-me :
- Utilisez les **compétences** pour des procédures complexes et réutilisables
- Utilisez l'**outil plan** pour des demandes multi-étapes ad-hoc
- Utilisez les **commandes slash** pour des actions utilisateur directes

---

## Voir aussi

- [Référence des commandes slash](../reference/slash-commands.md) - Pour les commandes utilisateur
- [Référence des outils](../reference/tools.md) - Pour tous les outils intégrés
- [Aperçu des compétences](../explanation/skills.md) - Pour le système de compétences