cc-viewer 1.6.182 → 1.6.183

package/concepts/fr/Tool-TaskGet.md

@@ -1,56 +1,47 @@
 # TaskGet
 
-## Définition
+Récupère l'enregistrement complet d'une tâche unique par ID, y compris sa description, son statut actuel, son propriétaire, ses métadonnées et ses arêtes de dépendance. Utilisez-le lorsque le résumé renvoyé par `TaskList` ne suffit pas pour agir sur la tâche.
 
-Obtient les détails complets d'une tâche via son ID.
+## Quand l'utiliser
 
-## Paramètres
-
-| Paramètre | Type | Requis | Description |
-|-----------|------|--------|-------------|
-| `taskId` | string | Oui | ID de la tâche à obtenir |
-
-## Contenu renvoyé
+- Vous avez récupéré une tâche dans `TaskList` et avez besoin de la description complète avant de commencer le travail.
+- Vous êtes sur le point de marquer une tâche `completed` et souhaitez revérifier les critères d'acceptation.
+- Vous devez inspecter quelles tâches celle-ci `blocks` ou par lesquelles elle est `blockedBy` afin de décider de la suite.
+- Vous enquêtez sur l'historique — qui la possède, quelles métadonnées étaient attachées, quand elle a changé d'état.
+- Un coéquipier ou une session antérieure a référencé un ID de tâche et vous avez besoin du contexte.
 
-- `subject` — Titre de la tâche
-- `description` — Exigences détaillées et contexte
-- `status` — Statut : `pending`, `in_progress` ou `completed`
-- `blocks` — Liste des tâches bloquées par cette tâche
-- `blockedBy` — Liste des tâches préalables qui bloquent cette tâche
+Préférez `TaskList` lorsque vous n'avez besoin que d'un balayage de haut niveau ; réservez `TaskGet` à l'enregistrement spécifique que vous prévoyez de lire attentivement ou de modifier.
 
-## Cas d'utilisation
+## Paramètres
 
-**Adapté pour :**
-- Obtenir la description complète et le contexte d'une tâche avant de commencer à travailler
-- Comprendre les relations de dépendance d'une tâche
-- Obtenir les exigences complètes après avoir été assigné à une tâche
+- `taskId` (string, requis) : l'identifiant de tâche renvoyé par `TaskCreate` ou `TaskList`. Les IDs sont stables pendant toute la durée de vie de la tâche.
 
-## Notes
+## Exemples
 
-- Après avoir obtenu la tâche, vérifier si la liste `blockedBy` est vide avant de commencer à travailler
-- Utiliser TaskList pour voir les informations résumées de toutes les tâches
+### Exemple 1
 
-## Texte original
+Consulter une tâche que vous venez de voir dans la liste.
 
-<textarea readonly>Use this tool to retrieve a task by its ID from the task list.
+```
+TaskGet(taskId: "t_01HXYZ...")
+```
 
-## When to Use This Tool
+Champs de réponse typiques : `id`, `subject`, `description`, `activeForm`, `status`, `owner`, `blocks`, `blockedBy`, `metadata`, `createdAt`, `updatedAt`.
 
-- When you need the full description and context before starting work on a task
-- To understand task dependencies (what it blocks, what blocks it)
-- After being assigned a task, to get complete requirements
+### Exemple 2
 
-## Output
+Résoudre les dépendances avant de commencer.
 
-Returns full task details:
-- **subject**: Task title
-- **description**: Detailed requirements and context
-- **status**: 'pending', 'in_progress', or 'completed'
-- **blocks**: Tasks waiting on this one to complete
-- **blockedBy**: Tasks that must complete before this one can start
+```
+TaskGet(taskId: "t_01HXYZ...")
+# Inspect blockedBy — if any referenced task is still pending
+# or in_progress, work on the blocker first.
+```
 
-## Tips
+## Notes
 
-- After fetching a task, verify its blockedBy list is empty before beginning work.
-- Use TaskList to see all tasks in summary form.
-</textarea>
+- `TaskGet` est en lecture seule et peut être appelé à plusieurs reprises sans danger ; il ne modifie ni statut ni propriété.
+- Si `blockedBy` n'est pas vide et contient des tâches qui ne sont pas `completed`, ne commencez pas cette tâche — résolvez d'abord les bloqueurs (ou coordonnez-vous avec leur propriétaire).
+- Le champ `description` peut être long. Lisez-le intégralement avant d'agir ; le survoler conduit à manquer des critères d'acceptation.
+- Un `taskId` inconnu ou supprimé renvoie une erreur. Relancez `TaskList` pour récupérer un ID courant.
+- Si vous êtes sur le point d'éditer une tâche, appelez `TaskGet` d'abord pour éviter d'écraser des champs qu'un coéquipier vient de modifier.

package/concepts/fr/Tool-TaskList.md

@@ -1,56 +1,62 @@
 # TaskList
 
-## Définition
+Renvoie toutes les tâches de l'équipe courante (ou de la session) sous forme résumée. Utilisez-le pour passer en revue le travail en cours, décider quoi prendre ensuite et éviter de créer des doublons.
 
-Liste toutes les tâches dans la liste de tâches pour voir la progression globale et le travail disponible.
+## Quand l'utiliser
+
+- Au début d'une session pour voir ce qui est déjà suivi.
+- Avant d'appeler `TaskCreate`, pour confirmer que le travail n'est pas déjà capturé.
+- Lorsque vous décidez quelle tâche réclamer ensuite en tant que coéquipier ou sous-agent.
+- Pour vérifier les relations de dépendance au sein de l'équipe d'un coup d'œil.
+- Périodiquement pendant de longues sessions pour resynchroniser avec des coéquipiers qui ont pu réclamer, terminer ou ajouter des tâches.
+
+`TaskList` est en lecture seule et peu coûteux ; appelez-le librement chaque fois que vous avez besoin d'une vue d'ensemble.
 
 ## Paramètres
 
-Aucun paramètre.
+`TaskList` ne prend aucun paramètre. Il renvoie toujours l'ensemble complet des tâches pour le contexte actif.
 
-## Contenu renvoyé
+## Forme de la réponse
 
-Informations résumées de chaque tâche :
-- `id` — Identifiant de la tâche
-- `subject` — Description brève
-- `status` — Statut : `pending`, `in_progress` ou `completed`
-- `owner` — Responsable (agent ID), vide signifie non assigné
-- `blockedBy` — Liste des IDs de tâches incomplètes qui bloquent cette tâche
+Chaque tâche de la liste est un résumé, pas l'enregistrement complet. Attendez-vous à peu près à :
 
-## Cas d'utilisation
+- `id` — identifiant stable à utiliser avec `TaskGet` / `TaskUpdate`.
+- `subject` — titre court à l'impératif.
+- `status` — un parmi `pending`, `in_progress`, `completed`, `deleted`.
+- `owner` — identifiant d'agent ou de coéquipier, ou vide lorsqu'aucune propriété.
+- `blockedBy` — tableau d'IDs de tâches qui doivent se terminer d'abord.
 
-**Adapté pour :**
-- Voir quelles tâches sont disponibles (statut pending, sans owner, non bloquées)
-- Vérifier la progression globale du projet
-- Trouver les tâches bloquées
-- Chercher la prochaine tâche après en avoir terminé une
+Pour la description complète, les critères d'acceptation ou les métadonnées d'une tâche spécifique, enchaînez avec `TaskGet`.
 
-## Notes
+## Exemples
 
-- Préférer traiter les tâches dans l'ordre des ID (ID le plus bas en premier), car les tâches antérieures fournissent généralement du contexte pour les suivantes
-- Les tâches avec `blockedBy` ne peuvent pas être réclamées tant que les dépendances ne sont pas résolues
-- Utiliser TaskGet pour obtenir les détails complets d'une tâche spécifique
+### Exemple 1
 
-## Texte original
+Vérification de statut rapide.
 
-<textarea readonly>Use this tool to list all tasks in the task list.
+```
+TaskList()
+```
 
-## When to Use This Tool
+Parcourez la sortie pour repérer tout ce qui est `in_progress` sans `owner` (travail stagnant) et tout ce qui est `pending` avec un `blockedBy` vide (prêt à être pris).
 
-- To see what tasks are available to work on (status: 'pending', no owner, not blocked)
-- To check overall progress on the project
-- To find tasks that are blocked and need dependencies resolved
-- After completing a task, to check for newly unblocked work or claim the next available task
-- **Prefer working on tasks in ID order** (lowest ID first) when multiple tasks are available, as earlier tasks often set up context for later ones
+### Exemple 2
 
-## Output
+Un coéquipier choisit la prochaine tâche.
 
-Returns a summary of each task:
-- **id**: Task identifier (use with TaskGet, TaskUpdate)
-- **subject**: Brief description of the task
-- **status**: 'pending', 'in_progress', or 'completed'
-- **owner**: Agent ID if assigned, empty if available
-- **blockedBy**: List of open task IDs that must be resolved first (tasks with blockedBy cannot be claimed until dependencies resolve)
+```
+TaskList()
+# Filter to: status == pending AND blockedBy is empty AND owner is empty.
+# Among those, prefer the lower ID (tasks are typically numbered in
+# creation order, so lower IDs are older and usually higher priority).
+TaskGet(taskId: "<chosen id>")
+TaskUpdate(taskId: "<chosen id>", status: "in_progress", owner: "<your handle>")
+```
+
+## Notes
 
-Use TaskGet with a specific task ID to view full details including description and comments.
-</textarea>
+- Heuristique de coéquipier : lorsque plusieurs tâches `pending` sont débloquées et sans propriétaire, prenez le plus petit ID. Cela maintient le travail en FIFO et évite que deux agents ne s'emparent de la même tâche très visible.
+- Respectez `blockedBy` : ne commencez pas une tâche dont les bloqueurs sont encore `pending` ou `in_progress`. Travaillez d'abord le bloqueur ou coordonnez-vous avec son propriétaire.
+- `TaskList` est le seul mécanisme de découverte des tâches. Il n'y a pas de recherche ; si la liste est longue, parcourez-la structurellement (par statut, puis par propriétaire).
+- Les tâches supprimées peuvent encore apparaître dans la liste avec le statut `deleted` pour la traçabilité. Ignorez-les à des fins de planification.
+- La liste reflète l'état en direct de l'équipe, donc les coéquipiers peuvent ajouter ou réclamer des tâches entre les appels. Relistez avant de réclamer si du temps s'est écoulé.

package/concepts/fr/Tool-TaskOutput.md

@@ -1,40 +1,50 @@
 # TaskOutput
 
-## Définition
+Récupère la sortie accumulée d'une tâche d'arrière-plan en cours ou terminée — une commande shell en arrière-plan, un agent local ou une session distante. Utilisez-le lorsque vous devez inspecter ce qu'une tâche de longue durée a produit jusqu'à présent.
 
-Obtient la sortie des tâches en arrière-plan en cours d'exécution ou terminées. Applicable aux shells en arrière-plan, agents asynchrones et sessions distantes.
+## Quand l'utiliser
+
+- Une session distante (par exemple un sandbox cloud) est en cours d'exécution et vous avez besoin de sa sortie standard.
+- Un agent local a été dispatché en arrière-plan et vous souhaitez une progression partielle avant qu'il ne renvoie son résultat.
+- Une commande shell en arrière-plan est en cours depuis assez longtemps pour que vous souhaitiez vérifier sans l'arrêter.
+- Vous devez confirmer qu'une tâche d'arrière-plan progresse réellement avant d'attendre plus longtemps ou d'appeler `TaskStop`.
+
+Ne recourez pas à `TaskOutput` par réflexe. Pour la plupart des travaux d'arrière-plan, il existe un chemin plus direct — voir les notes ci-dessous.
 
 ## Paramètres
 
-| Paramètre | Type | Requis | Description |
-|-----------|------|--------|-------------|
-| `task_id` | string | Oui | ID de la tâche |
-| `block` | boolean | Oui | Si l'on bloque en attendant la fin de la tâche, par défaut `true` |
-| `timeout` | number | Oui | Temps d'attente maximum (millisecondes), par défaut 30000, maximum 600000 |
+- `task_id` (string, requis) : l'identifiant de tâche renvoyé au démarrage du travail en arrière-plan. Ce n'est pas la même chose qu'un `taskId` de liste de tâches ; c'est le handle d'exécution de l'exécution spécifique.
+- `block` (boolean, optionnel) : lorsque `true` (par défaut), attendez que la tâche produise une nouvelle sortie ou se termine avant de renvoyer. Lorsque `false`, renvoyez immédiatement ce qui est mis en mémoire tampon.
+- `timeout` (number, optionnel) : millisecondes maximales de blocage avant de renvoyer. N'a de sens que lorsque `block` est `true`. Défaut `30000`, maximum `600000`.
 
-## Cas d'utilisation
+## Exemples
 
-**Adapté pour :**
-- Vérifier la progression des agents en arrière-plan lancés via Task (`run_in_background: true`)
-- Obtenir les résultats d'exécution de commandes Bash en arrière-plan
-- Attendre qu'une tâche asynchrone se termine et obtenir sa sortie
+### Exemple 1
 
-**Non adapté pour :**
-- Tâches au premier plan — les tâches au premier plan renvoient directement les résultats, cet outil n'est pas nécessaire
+Jeter un coup d'œil à une session distante sans bloquer.
 
-## Notes
+```
+TaskOutput(task_id: "sess_01HXYZ...", block: false)
+```
+
+Renvoie tout ce qui a été produit en sortie standard / erreur depuis le démarrage de la tâche (ou depuis votre dernier appel `TaskOutput`, selon l'environnement d'exécution).
 
-- `block: true` bloque jusqu'à ce que la tâche se termine ou que le délai expire
-- `block: false` est utilisé pour une vérification non bloquante de l'état actuel
-- L'ID de la tâche peut être trouvé via la commande `/tasks`
-- Applicable à tous les types de tâches : shells en arrière-plan, agents asynchrones, sessions distantes
+### Exemple 2
 
-## Texte original
+Attendre brièvement qu'un agent local émette plus de sortie.
+
+```
+TaskOutput(
+  task_id: "agent_01ABCD...",
+  block: true,
+  timeout: 10000
+)
+```
+
+## Notes
 
-<textarea readonly>- Retrieves output from a running or completed task (background shell, agent, or remote session)
-- Takes a task_id parameter identifying the task
-- Returns the task output along with status information
-- Use block=true (default) to wait for task completion
-- Use block=false for non-blocking check of current status
-- Task IDs can be found using the /tasks command
-- Works with all task types: background shells, async agents, and remote sessions</textarea>
+- Commandes bash en arrière-plan : `TaskOutput` est en pratique déprécié pour ce cas d'usage. Lorsque vous démarrez une tâche shell en arrière-plan, le résultat inclut déjà le chemin de son fichier de sortie — lisez ce chemin directement avec l'outil `Read`. `Read` vous donne un accès aléatoire, des offsets de ligne et une vue stable ; `TaskOutput` non.
+- Agents locaux (l'outil `Agent` dispatché en arrière-plan) : lorsque l'agent termine, le résultat de l'outil `Agent` contient déjà sa réponse finale. Utilisez-la directement. Ne lisez pas le fichier de transcription symlinké — il contient le flux complet d'appels d'outils et débordera la fenêtre de contexte.
+- Sessions distantes : `TaskOutput` est la méthode correcte et souvent la seule pour récupérer la sortie en streaming. Préférez `block: true` avec un `timeout` modeste plutôt que des boucles de polling serrées.
+- Un `task_id` inconnu, ou une tâche dont la sortie a été collectée par le ramasse-miettes, renvoie une erreur. Relancez le travail si vous en avez encore besoin.
+- `TaskOutput` n'arrête pas la tâche. Utilisez `TaskStop` pour terminer.

package/concepts/fr/Tool-TaskStop.md

@@ -1,32 +1,45 @@
 # TaskStop
 
-## Définition
+Arrête une tâche d'arrière-plan en cours — une commande shell, un agent dispatché ou une session distante — par son handle d'exécution. Utilisez-le pour récupérer des ressources, annuler un travail qui n'est plus utile, ou récupérer quand une tâche est bloquée.
 
-Arrête une tâche en arrière-plan en cours d'exécution.
+## Quand l'utiliser
+
+- Une commande shell en arrière-plan tourne depuis plus longtemps que prévu et vous n'avez plus besoin de son résultat.
+- Un agent local boucle ou est bloqué et doit être coupé court.
+- L'utilisateur a changé de direction et le travail d'arrière-plan pour la direction précédente doit être abandonné.
+- Une session distante est sur le point d'expirer ou détient une ressource dont vous avez besoin.
+- Vous avez besoin d'une ardoise vierge avant de démarrer une nouvelle exécution de la même tâche.
+
+Préférez laisser le travail d'arrière-plan de courte durée se terminer de lui-même. `TaskStop` est réservé aux cas où la poursuite de l'exécution n'a plus de valeur ou est activement nuisible.
 
 ## Paramètres
 
-| Paramètre | Type | Requis | Description |
-|-----------|------|--------|-------------|
-| `task_id` | string | Non | ID de la tâche en arrière-plan à arrêter |
-| `shell_id` | string | Non | Obsolète, utiliser `task_id` à la place |
+- `task_id` (string, requis) : le handle d'exécution renvoyé au démarrage de la tâche d'arrière-plan. C'est le même identifiant accepté par `TaskOutput`, pas un `taskId` de liste de tâches.
 
-## Cas d'utilisation
+## Exemples
 
-**Adapté pour :**
-- Terminer des tâches de longue durée qui ne sont plus nécessaires
-- Annuler des tâches en arrière-plan lancées par erreur
+### Exemple 1
 
-## Notes
+Arrêter une commande shell d'arrière-plan qui s'emballe.
+
+```
+TaskStop(task_id: "bash_01HXYZ...")
+```
 
-- Renvoie un statut de succès ou d'échec
-- Le paramètre `shell_id` est obsolète, utiliser `task_id`
+La commande reçoit un signal de terminaison ; la sortie mise en mémoire tampon écrite jusque-là reste lisible à son chemin de sortie.
 
-## Texte original
+### Exemple 2
+
+Annuler un agent dispatché après une correction de trajectoire de l'utilisateur.
+
+```
+TaskStop(task_id: "agent_01ABCD...")
+```
+
+## Notes
 
-<textarea readonly>
-- Stops a running background task by its ID
-- Takes a task_id parameter identifying the task to stop
-- Returns a success or failure status
-- Use this tool when you need to terminate a long-running task
-</textarea>
+- `TaskStop` demande la terminaison ; il ne garantit pas un arrêt instantané. Les tâches bien conçues sortent rapidement, mais un processus effectuant des E/S bloquantes peut prendre un moment pour se dérouler.
+- Arrêter une tâche ne supprime pas sa sortie. Pour les tâches shell en arrière-plan, le fichier de sortie sur disque est préservé et reste lisible avec `Read`. Pour les agents et sessions, toute sortie capturée avant l'arrêt reste accessible via `TaskOutput`.
+- Un `task_id` inconnu, ou une tâche déjà terminée, renvoie une erreur ou un no-op. C'est sûr — vous pouvez appeler `TaskStop` de manière défensive sans vérifier le statut au préalable.
+- Si vous comptez relancer le même travail, arrêtez l'ancienne tâche avant de dispatcher la nouvelle pour éviter que deux exécutions parallèles ne se disputent des ressources partagées (fichiers, ports, lignes de base de données).
+- `TaskStop` n'affecte pas les entrées de la liste de tâches d'équipe. Pour annuler une tâche suivie, mettez à jour son statut à `deleted` avec `TaskUpdate`.

package/concepts/fr/Tool-TaskUpdate.md

@@ -1,123 +1,70 @@
 # TaskUpdate
 
-## Définition
+Modifie une tâche existante — son statut, son contenu, sa propriété, ses métadonnées ou ses arêtes de dépendance. C'est ainsi que les tâches progressent dans leur cycle de vie et que le travail est transféré entre Claude Code, les coéquipiers et les sous-agents.
 
-Met à jour le statut, le contenu ou les relations de dépendance d'une tâche dans la liste de tâches.
+## Quand l'utiliser
 
-## Paramètres
-
-| Paramètre | Type | Requis | Description |
-|-----------|------|--------|-------------|
-| `taskId` | string | Oui | ID de la tâche à mettre à jour |
-| `status` | enum | Non | Nouveau statut : `pending` / `in_progress` / `completed` / `deleted` |
-| `subject` | string | Non | Nouveau titre |
-| `description` | string | Non | Nouvelle description |
-| `activeForm` | string | Non | Texte au participe présent affiché quand la tâche est en cours |
-| `owner` | string | Non | Nouveau responsable de la tâche (nom de l'agent) |
-| `metadata` | object | Non | Métadonnées à fusionner (définir à null pour supprimer une clé) |
-| `addBlocks` | string[] | Non | Liste des IDs de tâches bloquées par cette tâche |
-| `addBlockedBy` | string[] | Non | Liste des IDs de tâches préalables qui bloquent cette tâche |
-
-## Flux de statuts
-
-```
-pending → in_progress → completed
-```
-
-`deleted` peut être atteint depuis n'importe quel statut, supprime définitivement la tâche.
-
-## Cas d'utilisation
-
-**Adapté pour :**
-- Marquer une tâche comme `in_progress` au début du travail
-- Marquer une tâche comme `completed` à la fin du travail
-- Établir des relations de dépendance entre les tâches
-- Mettre à jour le contenu de la tâche quand les exigences changent
-
-**Règles importantes :**
-- Ne marquer comme `completed` que lorsque la tâche est entièrement terminée
-- Garder comme `in_progress` en cas d'erreurs ou de blocages
-- Ne pas marquer comme `completed` quand les tests échouent, l'implémentation est partielle ou des erreurs non résolues existent
-
-## Notes
-
-- Avant de mettre à jour, obtenir le statut le plus récent de la tâche via TaskGet pour éviter les données obsolètes
-- Après avoir terminé une tâche, appeler TaskList pour trouver la prochaine tâche disponible
+- Faire transiter une tâche dans le workflow de statut au fur et à mesure que vous y travaillez.
+- Réclamer une tâche en vous attribuant (ou en attribuant à un autre agent) le rôle de `owner`.
+- Affiner le `subject` ou la `description` une fois que vous en savez plus sur le problème.
+- Enregistrer des dépendances nouvellement découvertes avec `addBlocks` / `addBlockedBy`.
+- Attacher des `metadata` structurées telles que des IDs de tickets externes ou des indices de priorité.
 
-## Texte original
-
-<textarea readonly>Use this tool to update a task in the task list.
-
-## When to Use This Tool
-
-**Mark tasks as resolved:**
-- When you have completed the work described in a task
-- When a task is no longer needed or has been superseded
-- IMPORTANT: Always mark your assigned tasks as resolved when you finish them
-- After resolving, call TaskList to find your next task
-
-- ONLY mark a task as completed when you have FULLY accomplished it
-- If you encounter errors, blockers, or cannot finish, keep the task as in_progress
-- When blocked, create a new task describing what needs to be resolved
-- Never mark a task as completed if:
-  - Tests are failing
-  - Implementation is partial
-  - You encountered unresolved errors
-  - You couldn't find necessary files or dependencies
-
-**Delete tasks:**
-- When a task is no longer relevant or was created in error
-- Setting status to `deleted` permanently removes the task
+## Paramètres
 
-**Update task details:**
-- When requirements change or become clearer
-- When establishing dependencies between tasks
+- `taskId` (string, requis) : la tâche à modifier. Obtenue depuis `TaskList` ou `TaskCreate`.
+- `status` (string, optionnel) : un parmi `pending`, `in_progress`, `completed`, `deleted`.
+- `subject` (string, optionnel) : titre impératif de remplacement.
+- `description` (string, optionnel) : description détaillée de remplacement.
+- `activeForm` (string, optionnel) : texte de spinner au présent continu de remplacement.
+- `owner` (string, optionnel) : handle d'agent ou de coéquipier prenant la responsabilité de la tâche.
+- `metadata` (object, optionnel) : clés de métadonnées à fusionner dans la tâche. Réglez une clé à `null` pour la supprimer.
+- `addBlocks` (array de strings, optionnel) : IDs de tâches que cette tâche bloque.
+- `addBlockedBy` (array de strings, optionnel) : IDs de tâches qui doivent se terminer avant celle-ci.
 
-## Fields You Can Update
+## Workflow de statut
 
-- **status**: The task status (see Status Workflow below)
-- **subject**: Change the task title (imperative form, e.g., "Run tests")
-- **description**: Change the task description
-- **activeForm**: Present continuous form shown in spinner when in_progress (e.g., "Running tests")
-- **owner**: Change the task owner (agent name)
-- **metadata**: Merge metadata keys into the task (set a key to null to delete it)
-- **addBlocks**: Mark tasks that cannot start until this one completes
-- **addBlockedBy**: Mark tasks that must complete before this one can start
+Le cycle de vie est délibérément linéaire : `pending` → `in_progress` → `completed`. `deleted` est terminal et utilisé pour retirer les tâches qui ne seront jamais traitées.
 
-## Status Workflow
+- Passez à `in_progress` au moment où vous commencez réellement le travail, pas avant. Une seule tâche à la fois doit être `in_progress` pour un propriétaire donné.
+- Passez à `completed` uniquement lorsque le travail est entièrement terminé — critères d'acceptation remplis, tests passants, sortie écrite. Si un bloqueur apparaît, gardez la tâche `in_progress` et ajoutez une nouvelle tâche décrivant ce qui doit être résolu.
+- Ne marquez jamais une tâche `completed` lorsque les tests échouent, que l'implémentation est partielle ou que vous rencontrez des erreurs non résolues.
+- Utilisez `deleted` pour les tâches annulées ou en double ; ne recyclez pas une tâche pour un travail sans rapport.
 
-Status progresses: `pending` → `in_progress` → `completed`
+## Exemples
 
-Use `deleted` to permanently remove a task.
+### Exemple 1
 
-## Staleness
+Réclamer une tâche et la démarrer.
 
-Make sure to read a task's latest state using `TaskGet` before updating it.
+```
+TaskUpdate(
+  taskId: "t_01HXYZ...",
+  status: "in_progress",
+  owner: "main-agent"
+)
+```
 
-## Examples
+### Exemple 2
 
-Mark task as in progress when starting work:
-```json
-{"taskId": "1", "status": "in_progress"}
-```
+Terminer le travail et enregistrer une dépendance de suivi.
 
-Mark task as completed after finishing work:
-```json
-{"taskId": "1", "status": "completed"}
 ```
-
-Delete a task:
-```json
-{"taskId": "1", "status": "deleted"}
+TaskUpdate(
+  taskId: "t_01HXYZ...",
+  status: "completed"
+)
+
+TaskUpdate(
+  taskId: "t_01FOLLOWUP...",
+  addBlockedBy: ["t_01HXYZ..."]
+)
 ```
 
-Claim a task by setting owner:
-```json
-{"taskId": "1", "owner": "my-name"}
-```
+## Notes
 
-Set up task dependencies:
-```json
-{"taskId": "2", "addBlockedBy": ["1"]}
-```
-</textarea>
+- `metadata` fusionne clé par clé ; passer `null` pour une clé la supprime. Appelez `TaskGet` d'abord si vous n'êtes pas sûr du contenu actuel.
+- `addBlocks` et `addBlockedBy` ajoutent des arêtes ; ils ne suppriment pas les existantes. Éditer le graphe de manière destructive nécessite un workflow dédié — consultez le propriétaire de l'équipe avant de réécrire les dépendances.
+- Gardez `activeForm` synchronisé lorsque vous modifiez `subject` afin que le texte du spinner continue de se lire naturellement.
+- Ne marquez pas une tâche `completed` pour la faire taire. Si l'utilisateur a annulé le travail, utilisez `deleted` avec un bref justificatif dans `description`.
+- Lisez l'état le plus récent d'une tâche avec `TaskGet` avant de la mettre à jour — les coéquipiers peuvent l'avoir modifiée entre votre dernière lecture et votre écriture.

package/concepts/fr/Tool-TeamCreate.md

@@ -1,38 +1,53 @@
 # TeamCreate
 
-## Définition
+Établit une nouvelle équipe de collaboration avec une liste de tâches partagée et un canal de messagerie inter-agents. Une équipe est la primitive de coordination pour le travail multi-agents — la session principale fait office de chef et fait apparaître des coéquipiers nommés via l'outil `Agent`.
 
-Crée une nouvelle équipe pour coordonner plusieurs agents travaillant sur un projet. Les équipes permettent l'exécution parallèle des tâches via une liste de tâches partagée et une messagerie inter-agents.
+## Quand l'utiliser
+
+- L'utilisateur demande explicitement une équipe, un essaim, un équipage ou une collaboration multi-agents.
+- Un projet comporte plusieurs flux de travail clairement indépendants qui bénéficient de spécialistes dédiés (par exemple frontend, backend, tests, docs).
+- Vous avez besoin d'une liste de tâches partagée persistante que plusieurs agents mettent à jour à mesure qu'ils progressent.
+- Vous voulez des coéquipiers nommés et adressables capables d'échanger des messages via `SendMessage` plutôt que des appels de sous-agent à usage unique.
+
+N'utilisez PAS pour une unique recherche déléguée ou un fan-out parallèle ponctuel — de simples appels `Agent` sont plus légers et suffisants.
 
 ## Paramètres
 
-| Paramètre | Type | Requis | Description |
-|-----------|------|--------|-------------|
-| `team_name` | string | Oui | Nom de la nouvelle équipe |
-| `description` | string | Non | Description / objectif de l'équipe |
-| `agent_type` | string | Non | Type / rôle du responsable de l'équipe |
+- `team_name` (string, requis) : identifiant unique pour l'équipe. Utilisé comme nom de répertoire sous `~/.claude/teams/` et comme argument `team_name` lors du lancement de coéquipiers.
+- `description` (string, requis) : courte déclaration de l'objectif de l'équipe. Affichée à chaque coéquipier au lancement et écrite dans la configuration de l'équipe.
+- `agent_type` (string, optionnel) : persona de sous-agent par défaut appliquée aux coéquipiers qui ne la remplacent pas. Les valeurs typiques sont `general-purpose`, `Explore` ou `Plan`.
+
+## Exemples
+
+### Exemple 1 : créer une équipe de refactoring
 
-## Ce qui est créé
+```
+TeamCreate(
+  team_name="refactor-crew",
+  description="Refactor the data access layer from raw SQL to Prisma, including migrations and tests.",
+  agent_type="general-purpose"
+)
+```
 
-- **Fichier de configuration de l'équipe** : `~/.claude/teams/{team-name}/config.json` — stocke la liste des membres et les métadonnées
-- **Répertoire de liste de tâches** : `~/.claude/tasks/{team-name}/` — liste de tâches partagée pour tous les coéquipiers
+Après la création, faites apparaître des coéquipiers avec `Agent` en utilisant `team_name: "refactor-crew"` et des valeurs `name` distinctes telles que `db-lead`, `migrations` et `tests`.
 
-Les équipes ont une correspondance 1:1 avec les listes de tâches.
+### Exemple 2 : créer une équipe d'investigation
 
-## Flux de travail de l'équipe
+```
+TeamCreate(
+  team_name="perf-investigation",
+  description="Identify and rank the top three performance regressions introduced in the last release.",
+  agent_type="Explore"
+)
+```
 
-1. **TeamCreate** — créer l'équipe et sa liste de tâches
-2. **TaskCreate** — définir les tâches pour l'équipe
-3. **Agent** (avec `team_name` + `name`) — démarrer des coéquipiers qui rejoignent l'équipe
-4. **TaskUpdate** — attribuer des tâches aux coéquipiers via `owner`
-5. Les coéquipiers travaillent sur les tâches et communiquent via **SendMessage**
-6. Arrêter les coéquipiers une fois terminé, puis **TeamDelete** pour nettoyer
+Chaque coéquipier généré hérite de `Explore` comme persona par défaut, ce qui correspond à la nature en lecture seule et investigative du travail.
 
-## Outils associés
+## Notes
 
-| Outil | Rôle |
-|-------|------|
-| `TeamDelete` | Supprimer l'équipe et les répertoires de tâches |
-| `SendMessage` | Communication inter-agents au sein de l'équipe |
-| `TaskCreate` / `TaskUpdate` / `TaskList` / `TaskGet` | Gérer la liste de tâches partagée |
-| `Agent` | Démarrer des coéquipiers qui rejoignent l'équipe |
+- Une seule équipe peut être dirigée à la fois depuis une session donnée. Terminez ou supprimez l'équipe courante avant d'en créer une autre.
+- Une équipe est en relation 1:1 avec une liste de tâches partagée. Le chef possède la création, l'affectation et la clôture des tâches ; les coéquipiers mettent à jour le statut des tâches sur lesquelles ils travaillent.
+- La configuration de l'équipe est persistée à `~/.claude/teams/{team_name}/config.json`, et le répertoire de tâches se trouve à côté. Ces fichiers survivent aux sessions jusqu'à leur suppression explicite avec `TeamDelete`.
+- Les coéquipiers sont générés via l'outil `Agent` avec le `team_name` correspondant et un `name` distinct. Le `name` devient l'adresse utilisée par `SendMessage`.
+- Choisissez un `team_name` compatible avec le système de fichiers (lettres, chiffres, tirets, underscores). Évitez les espaces ou les slashes.
+- Rédigez la `description` de manière qu'un tout nouveau coéquipier, la lisant à froid, comprenne l'objectif de l'équipe sans contexte supplémentaire. Elle fait partie de l'invite de démarrage de chaque coéquipier.