cc-viewer 1.6.182 → 1.6.183

package/concepts/fr/Tool-Read.md

@@ -1,56 +1,41 @@
 # Read
 
-## Définition
+Charge le contenu d'un unique fichier depuis le système de fichiers local. Prend en charge le texte brut, le code source, les images, les PDF et les notebooks Jupyter, en renvoyant les résultats avec des numéros de ligne commençant à 1, au style `cat -n`.
 
-Lit le contenu de fichiers depuis le système de fichiers local. Supporte les fichiers texte, images, PDF et Jupyter notebook.
+## Quand l'utiliser
+
+- Lire un fichier source à un chemin connu avant édition ou analyse
+- Inspecter des fichiers de configuration, des lockfiles, des journaux ou des artefacts générés
+- Visualiser des captures d'écran ou des diagrammes que l'utilisateur a collés dans la conversation
+- Extraire une plage de pages spécifique d'un long manuel PDF
+- Ouvrir un notebook `.ipynb` pour examiner ensemble les cellules de code, le markdown et les sorties de cellules
 
 ## Paramètres
 
-| Paramètre | Type | Requis | Description |
-|-----------|------|--------|-------------|
-| `file_path` | string | Oui | Chemin absolu du fichier |
-| `offset` | number | Non | Numéro de ligne de départ (pour la lecture segmentée de gros fichiers) |
-| `limit` | number | Non | Nombre de lignes à lire (pour la lecture segmentée de gros fichiers) |
-| `pages` | string | Non | Plage de pages PDF (comme « 1-5 », « 3 », « 10-20 »), applicable uniquement aux PDF |
+- `file_path` (string, requis) : chemin absolu du fichier cible. Les chemins relatifs sont rejetés.
+- `offset` (integer, optionnel) : numéro de ligne (base 1) à partir duquel commencer la lecture. Utile pour les gros fichiers associés à `limit`.
+- `limit` (integer, optionnel) : nombre maximal de lignes à renvoyer à partir de `offset`. Par défaut 2000 lignes depuis le début du fichier lorsqu'omis.
+- `pages` (string, optionnel) : plage de pages pour les fichiers PDF, par exemple `"1-5"`, `"3"` ou `"10-20"`. Requis pour les PDF de plus de 10 pages ; maximum 20 pages par requête.
+
+## Exemples
+
+### Exemple 1 : lire un petit fichier entier
+Appelez `Read` avec seulement `file_path` réglé sur `/Users/me/project/src/index.ts`. Jusqu'à 2000 lignes sont renvoyées avec numéros de ligne, ce qui suffit généralement pour le contexte d'édition.
 
-## Cas d'utilisation
+### Exemple 2 : parcourir un long journal
+Utilisez `offset: 5001` et `limit: 500` sur un fichier de journal de plusieurs milliers de lignes pour récupérer une fenêtre étroite sans gaspiller de tokens de contexte.
 
-**Adapté pour :**
-- Lire des fichiers de code, fichiers de configuration et autres fichiers texte
-- Visualiser des fichiers image (Claude est un modèle multimodal)
-- Lire des documents PDF
-- Lire des Jupyter notebooks (renvoie toutes les cellules et sorties)
-- Lire plusieurs fichiers en parallèle pour obtenir du contexte
+### Exemple 3 : extraire des pages PDF spécifiques
+Pour un PDF de 120 pages situé à `/tmp/spec.pdf`, réglez `pages: "8-15"` pour n'extraire que le chapitre dont vous avez besoin. Omettre `pages` sur un grand PDF produit une erreur.
 
-**Non adapté pour :**
-- Lire des répertoires — utiliser la commande `ls` de Bash
-- Exploration ouverte de la base de code — utiliser Task (type Explore)
+### Exemple 4 : visualiser une image
+Passez le chemin absolu d'une capture d'écran PNG ou JPG. L'image est rendue visuellement afin que Claude Code puisse raisonner dessus directement.
 
 ## Notes
 
-- Le chemin doit être absolu, pas relatif
-- Par défaut, lit les 2000 premières lignes du fichier
-- Les lignes dépassant 2000 caractères seront tronquées
-- La sortie utilise le format `cat -n`, les numéros de ligne commencent à 1
-- Les gros PDF (plus de 10 pages) doivent spécifier le paramètre `pages`, maximum 20 pages par requête
-- Lire un fichier inexistant renvoie une erreur (pas de plantage)
-- Plusieurs appels Read peuvent être effectués en parallèle dans un seul message
-
-## Texte original
-
-<textarea readonly>Reads a file from the local filesystem. You can access any file directly by using this tool.
-Assume this tool is able to read all files on the machine. If the User provides a path to a file assume that path is valid. It is okay to read a file that does not exist; an error will be returned.
-
-Usage:
-- The file_path parameter must be an absolute path, not a relative path
-- By default, it reads up to 2000 lines starting from the beginning of the file
-- You can optionally specify a line offset and limit (especially handy for long files), but it's recommended to read the whole file by not providing these parameters
-- Any lines longer than 2000 characters will be truncated
-- Results are returned using cat -n format, with line numbers starting at 1
-- This tool allows Claude Code to read images (eg PNG, JPG, etc). When reading an image file the contents are presented visually as Claude Code is a multimodal LLM.
-- This tool can read PDF files (.pdf). For large PDFs (more than 10 pages), you MUST provide the pages parameter to read specific page ranges (e.g., pages: "1-5"). Reading a large PDF without the pages parameter will fail. Maximum 20 pages per request.
-- This tool can read Jupyter notebooks (.ipynb files) and returns all cells with their outputs, combining code, text, and visualizations.
-- This tool can only read files, not directories. To read a directory, use an ls command via the Bash tool.
-- You can call multiple tools in a single response. It is always better to speculatively read multiple potentially useful files in parallel.
-- You will regularly be asked to read screenshots. If the user provides a path to a screenshot, ALWAYS use this tool to view the file at the path. This tool will work with all temporary file paths.
-- If you read a file that exists but has empty contents you will receive a system reminder warning in place of file contents.</textarea>
+- Préférez toujours les chemins absolus. Si l'utilisateur en fournit un, faites-lui confiance tel quel.
+- Les lignes de plus de 2000 caractères sont tronquées ; traitez le contenu renvoyé comme potentiellement coupé pour des données extrêmement larges.
+- Vous lisez plusieurs fichiers indépendants ? Émettez plusieurs appels `Read` dans la même réponse afin qu'ils s'exécutent en parallèle.
+- `Read` ne peut pas lister les répertoires. Utilisez un appel `Bash` `ls` ou l'outil `Glob` à la place.
+- Lire un fichier existant mais vide renvoie un rappel système plutôt que les octets du fichier ; gérez ce signal explicitement.
+- Un `Read` réussi est requis avant de pouvoir utiliser `Edit` sur le même fichier dans la session en cours.

package/concepts/fr/Tool-RemoteTrigger.md

@@ -0,0 +1,73 @@
+# RemoteTrigger
+
+Appelle l'API de déclencheurs distants de claude.ai pour gérer l'exécution de tâches planifiées et à la demande. Le jeton OAuth est géré en interne par l'outil et n'est jamais exposé au modèle ni au shell.
+
+## Quand l'utiliser
+
+- Gérer des agents distants (déclencheurs) sur claude.ai, notamment lister, inspecter et mettre à jour les déclencheurs existants
+- Créer une nouvelle tâche automatisée basée sur cron qui exécute un agent Claude selon un calendrier récurrent
+- Déclencher un déclencheur existant à la demande sans attendre sa prochaine exécution planifiée
+- Lister ou auditer tous les déclencheurs actuels pour examiner leur configuration et leur état
+- Mettre à jour les paramètres d'un déclencheur, tels que le calendrier, la charge utile ou la description, sans avoir à le recréer
+
+## Paramètres
+
+- `action` (string, requis) : l'opération à effectuer — l'une des valeurs `list`, `get`, `create`, `update` ou `run`
+- `trigger_id` (string, requis pour `get`, `update` et `run`) : l'identifiant du déclencheur sur lequel opérer ; doit correspondre au modèle `^[\w-]+$` (caractères de mot et tirets uniquement)
+- `body` (object, requis pour `create` et `update` ; optionnel pour `run`) : la charge utile de la requête envoyée à l'API
+
+## Exemples
+
+### Exemple 1 : lister tous les déclencheurs
+
+```json
+{
+  "action": "list"
+}
+```
+
+Appelle `GET /v1/code/triggers` et renvoie un tableau JSON de tous les déclencheurs associés au compte authentifié.
+
+### Exemple 2 : créer un nouveau déclencheur qui s'exécute chaque matin en semaine
+
+```json
+{
+  "action": "create",
+  "body": {
+    "name": "weekday-morning-report",
+    "schedule": "0 8 * * 1-5",
+    "description": "Générer un résumé quotidien chaque jour de semaine à 08h00 UTC"
+  }
+}
+```
+
+Appelle `POST /v1/code/triggers` avec le corps fourni et renvoie l'objet déclencheur nouvellement créé, incluant son `trigger_id` attribué.
+
+### Exemple 3 : déclencher un déclencheur à la demande
+
+```json
+{
+  "action": "run",
+  "trigger_id": "my-report-trigger"
+}
+```
+
+Appelle immédiatement `POST /v1/code/triggers/my-report-trigger/run`, en contournant l'heure planifiée.
+
+### Exemple 4 : récupérer un seul déclencheur
+
+```json
+{
+  "action": "get",
+  "trigger_id": "my-report-trigger"
+}
+```
+
+Appelle `GET /v1/code/triggers/my-report-trigger` et renvoie la configuration complète du déclencheur.
+
+## Notes
+
+- Le jeton OAuth est injecté en cours de processus par l'outil — ne copiez, ne collez ni n'enregistrez jamais les jetons manuellement ; cela crée un risque de sécurité et est inutile lors de l'utilisation de cet outil.
+- Préférez cet outil à `curl` brut ou à d'autres clients HTTP pour tous les appels à l'API de déclencheurs ; l'utilisation directe de HTTP contourne l'injection sécurisée du jeton et peut exposer des informations d'identification.
+- L'outil renvoie la réponse JSON brute de l'API ; l'appelant est responsable de l'analyse de la réponse et de la gestion des codes d'état d'erreur.
+- La valeur de `trigger_id` doit correspondre au modèle `^[\w-]+$` — seuls les caractères alphanumériques, les traits de soulignement et les tirets sont autorisés ; les espaces ou les caractères spéciaux feront échouer la requête.

package/concepts/fr/Tool-ScheduleWakeup.md

@@ -0,0 +1,56 @@
+# ScheduleWakeup
+
+Planifie le moment où reprendre le travail en mode dynamique `/loop`. L'outil permet à Claude de gérer lui-même le rythme des itérations d'une tâche en dormant pendant l'intervalle choisi, puis en se déclenchant à nouveau avec le même prompt de boucle.
+
+## Quand l'utiliser
+
+- Pour gérer le rythme d'une tâche dynamique `/loop` où l'intervalle d'itération dépend de l'état du travail plutôt que d'une horloge fixe
+- Pour attendre la fin d'une longue compilation, d'un déploiement ou d'une exécution de tests avant de vérifier les résultats
+- Pour insérer des ticks d'inactivité entre les itérations quand il n'y a aucun signal spécifique à surveiller pour le moment
+- Pour exécuter une boucle autonome sans prompt utilisateur — passer le sentinel littéral `<<autonomous-loop-dynamic>>` comme `prompt`
+- Pour interroger un processus dont l'état est sur le point de changer (utiliser un délai court pour maintenir le cache chaud)
+
+## Paramètres
+
+- `delaySeconds` (nombre, requis) : Secondes avant la reprise. Le runtime limite automatiquement la valeur à `[60, 3600]`, il n'est donc pas nécessaire de la limiter manuellement.
+- `reason` (chaîne, requis) : Une courte phrase expliquant le délai choisi. Affichée à l'utilisateur et enregistrée dans la télémétrie. Soyez précis — « vérification de la longue compilation bun » est plus utile que « en attente ».
+- `prompt` (chaîne, requis) : L'entrée `/loop` à déclencher au réveil. Passer la même chaîne à chaque tour pour que le prochain déclenchement répète la tâche. Pour une boucle autonome sans prompt utilisateur, passer le sentinel littéral `<<autonomous-loop-dynamic>>`.
+
+## Exemples
+
+### Exemple 1 : court délai pour revérifier un signal qui change rapidement (maintenir le cache chaud)
+
+Une compilation vient d'être lancée et se termine généralement en deux à trois minutes.
+
+```json
+{
+  "delaySeconds": 120,
+  "reason": "vérification de la compilation bun attendue dans ~2 min",
+  "prompt": "vérifier l'état de la compilation et signaler les erreurs"
+}
+```
+
+120 secondes maintient le contexte de la conversation dans le cache de prompts Anthropic (TTL 5 min), ce qui rend le prochain réveil plus rapide et moins coûteux.
+
+### Exemple 2 : long tick d'inactivité (accepter un échec de cache, amortir sur une attente plus longue)
+
+Une migration de base de données est en cours et prend généralement 20 à 40 minutes.
+
+```json
+{
+  "delaySeconds": 1200,
+  "reason": "la migration prend généralement 20–40 min ; vérification dans 20 min",
+  "prompt": "vérifier l'état de la migration et continuer si terminée"
+}
+```
+
+Le cache sera froid au réveil, mais l'attente de 20 minutes amortit largement le coût du seul échec de cache. Interroger toutes les 5 minutes paierait le même coût d'échec 4 fois pour aucun bénéfice.
+
+## Notes
+
+- **TTL de cache de 5 minutes** : Le cache de prompts Anthropic expire après 300 secondes. Les délais inférieurs à 300 s maintiennent le contexte chaud ; les délais supérieurs à 300 s entraînent un échec de cache au prochain réveil.
+- **Éviter exactement 300 s** : C'est le pire des deux mondes — on paie l'échec de cache sans obtenir une attente significativement plus longue. Soit réduire à 270 s (maintenir le cache chaud), soit s'engager à 1200 s ou plus (un seul échec achète une attente bien plus longue).
+- **Valeur par défaut pour les ticks d'inactivité** : Quand il n'y a aucun signal spécifique à surveiller, utiliser **1200–1800 s** (20–30 min). Cela permet à la boucle de vérifier périodiquement sans brûler le cache 12 fois par heure pour rien.
+- **Limitation automatique** : Le runtime limite `delaySeconds` à `[60, 3600]`. Les valeurs inférieures à 60 deviennent 60 ; les valeurs supérieures à 3600 deviennent 3600. Il n'est pas nécessaire de gérer ces limites soi-même.
+- **Omettre l'appel pour terminer la boucle** : Si l'on souhaite arrêter les itérations, ne pas appeler ScheduleWakeup. Simplement omettre l'appel termine la boucle.
+- **Passer le même `prompt` à chaque tour** : Le champ `prompt` doit contenir l'instruction `/loop` originale à chaque invocation pour que le prochain réveil sache quelle tâche reprendre.

package/concepts/fr/Tool-SendMessage.md

@@ -1,41 +1,68 @@
 # SendMessage
 
-## Définition
+Transmet un message d'un membre d'équipe à un autre au sein d'une équipe active, ou diffuse à tous les coéquipiers en même temps. C'est le seul canal que les coéquipiers peuvent entendre — tout ce qui est écrit en sortie texte normale leur est invisible.
 
-Envoie des messages entre agents au sein d'une équipe. Utilisé pour la communication directe, la diffusion et les messages de protocole (requêtes/réponses d'arrêt, approbation de plan).
+## Quand l'utiliser
+
+- Attribuer une tâche ou transférer un sous-problème à un coéquipier nommé pendant une collaboration d'équipe.
+- Demander un statut, des résultats intermédiaires ou une revue de code à un autre agent.
+- Diffuser une décision, une contrainte partagée ou une annonce d'arrêt à toute l'équipe via `*`.
+- Répondre à une invite de protocole telle qu'une demande d'arrêt ou une demande d'approbation de plan du chef d'équipe.
+- Boucler la boucle à la fin d'une tâche déléguée afin que le chef puisse marquer l'élément terminé.
 
 ## Paramètres
 
-| Paramètre | Type | Requis | Description |
-|-----------|------|--------|-------------|
-| `to` | string | Oui | Destinataire : nom du coéquipier, ou `"*"` pour diffuser à tous |
-| `message` | string / object | Oui | Message texte ou objet de protocole structuré |
-| `summary` | string | Non | Aperçu de 5 à 10 mots affiché dans l'interface |
+- `to` (string, requis) : le `name` du coéquipier cible tel qu'enregistré dans l'équipe, ou `*` pour diffuser à tous les coéquipiers à la fois.
+- `message` (string ou object, requis) : texte brut pour une communication normale, ou objet structuré pour les réponses de protocole telles que `shutdown_response` et `plan_approval_response`.
+- `summary` (string, optionnel) : aperçu de 5 à 10 mots affiché dans le journal d'activité de l'équipe pour les messages texte. Requis pour les longs messages de type chaîne ; ignoré lorsque `message` est un objet de protocole.
+
+## Exemples
+
+### Exemple 1 : transfert direct de tâche
+
+```
+SendMessage(
+  to="db-lead",
+  message="Please audit prisma/schema.prisma and list any model missing createdAt/updatedAt timestamps. Reply when done.",
+  summary="Audit schema for missing timestamps"
+)
+```
 
-## Types de messages
+### Exemple 2 : diffuser une contrainte partagée
 
-### Texte brut
-Messages directs entre coéquipiers pour la coordination, les mises à jour d'état et les discussions sur les tâches.
+```
+SendMessage(
+  to="*",
+  message="Reminder: do not touch files under legacy/ — that subtree is frozen until the migration PR lands.",
+  summary="Freeze legacy/ during migration"
+)
+```
 
-### Requête d'arrêt
-Demande à un coéquipier de s'arrêter proprement : `{ type: "shutdown_request", reason: "..." }`
+### Exemple 3 : réponse de protocole
 
-### Réponse d'arrêt
-Le coéquipier approuve ou refuse l'arrêt : `{ type: "shutdown_response", approve: true/false }`
+Répondez à une demande d'arrêt du chef via un message structuré :
 
-### Réponse d'approbation de plan
-Approuve ou refuse le plan d'un coéquipier : `{ type: "plan_approval_response", approve: true/false }`
+```
+SendMessage(
+  to="leader",
+  message={ "type": "shutdown_response", "ready": true, "final_report": "All assigned diff chunks committed on branch refactor-crew/db-lead." }
+)
+```
 
-## Diffusion vs. Direct
+### Exemple 4 : réponse d'approbation de plan
 
-- **Direct** (`to: "nom-du-coéquipier"`) : Envoyer à un coéquipier spécifique — à privilégier pour la plupart des communications
-- **Diffusion** (`to: "*"`) : Envoyer à tous les coéquipiers — à utiliser avec parcimonie, uniquement pour les annonces critiques à l'échelle de l'équipe
+```
+SendMessage(
+  to="leader",
+  message={ "type": "plan_approval_response", "approved": true, "notes": "LGTM, but please split step 4 into migration + backfill." }
+)
+```
 
-## Outils associés
+## Notes
 
-| Outil | Rôle |
-|-------|------|
-| `TeamCreate` | Créer une nouvelle équipe |
-| `TeamDelete` | Supprimer l'équipe une fois terminé |
-| `Agent` | Démarrer des coéquipiers qui rejoignent l'équipe |
-| `TaskCreate` / `TaskUpdate` / `TaskList` | Gérer la liste de tâches partagée |
+- Votre sortie texte d'assistant habituelle n'est PAS transmise aux coéquipiers. Si vous voulez qu'un autre agent voie quelque chose, cela doit passer par `SendMessage`. C'est l'erreur la plus courante dans les workflows d'équipe.
+- La diffusion (`to: "*"`) est coûteuse — elle réveille chaque coéquipier et consomme son contexte. Réservez-la aux annonces qui concernent réellement tout le monde. Préférez les envois ciblés.
+- Gardez les messages concis et orientés action. Incluez les chemins de fichiers, les contraintes et le format de réponse attendu dont le destinataire a besoin ; rappelez-vous qu'il n'a pas de mémoire partagée avec vous.
+- Les objets de message de protocole (`shutdown_response`, `plan_approval_response`) ont des formes fixes. Ne mélangez pas les champs de protocole dans les messages texte ou vice versa.
+- Les messages sont asynchrones. Le destinataire recevra le vôtre à son prochain tour ; ne supposez pas qu'il l'a lu ou a agi dessus avant qu'il ne réponde.
+- Un `summary` bien rédigé rend le journal d'activité de l'équipe scannable pour le chef — traitez-le comme une ligne d'objet de commit.

package/concepts/fr/Tool-Skill.md

@@ -1,56 +1,47 @@
 # Skill
 
-## Définition
+Invoque une skill nommée au sein de la conversation en cours. Les skills sont des ensembles de capacités pré-packagés — connaissances de domaine, workflows et parfois accès à des outils — que le harnais expose à l'assistant via des rappels système.
 
-Exécute une compétence (skill) dans la conversation principale. Les compétences sont des capacités spécialisées que l'utilisateur peut invoquer via des slash commands (comme `/commit`, `/review-pr`).
+## Quand l'utiliser
 
-## Paramètres
+- L'utilisateur tape une commande slash telle que `/review` ou `/init` — les commandes slash sont des skills et doivent être exécutées via cet outil.
+- L'utilisateur décrit une tâche qui correspond aux conditions de déclenchement d'une skill annoncée (par exemple, demander de scanner les transcriptions pour des invites de permission répétées correspond à `fewer-permission-prompts`).
+- L'objectif déclaré d'une skill correspond directement au fichier, à la requête ou au contexte de conversation courant.
+- Des workflows spécialisés et répétables sont disponibles sous forme de skills et la procédure canonique est préférable à une approche ad hoc.
+- L'utilisateur demande « quelles skills sont disponibles » — listez les noms annoncés, et n'invoquez que lorsqu'il confirme.
 
-| Paramètre | Type | Requis | Description |
-|-----------|------|--------|-------------|
-| `skill` | string | Oui | Nom de la compétence (comme « commit », « review-pr », « pdf ») |
-| `args` | string | Non | Arguments de la compétence |
+## Paramètres
 
-## Cas d'utilisation
+- `skill` (string, requis) : le nom exact d'une skill listée dans le rappel système des skills disponibles. Pour les skills avec un espace de noms de plugin, utilisez la forme pleinement qualifiée `plugin:skill` (par exemple `skill-creator:skill-creator`). N'incluez pas de slash initial.
+- `args` (string, optionnel) : arguments libres passés à la skill. Le format et la sémantique sont définis par la documentation de chaque skill.
 
-**Adapté pour :**
-- L'utilisateur a saisi un slash command au format `/<skill-name>`
-- La demande de l'utilisateur correspond à la fonctionnalité d'une compétence enregistrée
+## Exemples
 
-**Non adapté pour :**
-- Commandes CLI intégrées (comme `/help`, `/clear`)
-- Une compétence déjà en cours d'exécution
-- Noms de compétences absents de la liste des compétences disponibles
+### Exemple 1 : exécuter une skill de revue sur la branche courante
 
-## Notes
+```
+Skill(skill="review")
+```
 
-- Après invocation, la compétence se déploie en un prompt complet
-- Supporte les noms pleinement qualifiés (comme `ms-office-suite:pdf`)
-- La liste des compétences disponibles est fournie dans les messages system-reminder
-- Quand on voit une balise `<command-name>`, cela signifie que la compétence est déjà chargée et doit être exécutée directement plutôt que de rappeler cet outil
-- Ne pas mentionner une compétence sans avoir réellement appelé l'outil
+La skill `review` encapsule les étapes de revue d'une pull request par rapport à la branche de base courante. L'invoquer charge la procédure de revue définie par le harnais dans le tour.
 
-## Texte original
+### Exemple 2 : invoquer une skill avec espace de noms de plugin avec des arguments
 
-<textarea readonly>Execute a skill within the main conversation
+```
+Skill(
+  skill="skill-creator:skill-creator",
+  args="create a skill that summarizes git log for a given date range"
+)
+```
 
-When users ask you to perform tasks, check if any of the available skills match. Skills provide specialized capabilities and domain knowledge.
+Achemine la requête via le point d'entrée du plugin `skill-creator` afin que le workflow de création se déclenche.
 
-When users reference a "slash command" or "/<something>" (e.g., "/commit", "/review-pr"), they are referring to a skill. Use this tool to invoke it.
-
-How to invoke:
-- Use this tool with the skill name and optional arguments
-- Examples:
-  - `skill: "pdf"` - invoke the pdf skill
-  - `skill: "commit", args: "-m 'Fix bug'"` - invoke with arguments
-  - `skill: "review-pr", args: "123"` - invoke with arguments
-  - `skill: "ms-office-suite:pdf"` - invoke using fully qualified name
+## Notes
 
-Important:
-- Available skills are listed in system-reminder messages in the conversation
-- When a skill matches the user's request, this is a BLOCKING REQUIREMENT: invoke the relevant Skill tool BEFORE generating any other response about the task
-- NEVER mention a skill without actually calling this tool
-- Do not invoke a skill that is already running
-- Do not use this tool for built-in CLI commands (like /help, /clear, etc.)
-- If you see a <command-name> tag in the current conversation turn, the skill has ALREADY been loaded - follow the instructions directly instead of calling this tool again
-</textarea>
+- N'invoquez que les skills dont les noms apparaissent textuellement dans le rappel système des skills disponibles, ou les skills que l'utilisateur a tapées directement en tant que `/name` dans son message. Ne devinez ni n'inventez jamais des noms de skill à partir de la mémoire ou des données d'entraînement — si la skill n'est pas annoncée, n'appelez pas cet outil.
+- Lorsqu'une requête de l'utilisateur correspond à une skill annoncée, appeler `Skill` est un prérequis bloquant : invoquez-la avant de générer toute autre réponse sur la tâche. Ne décrivez pas ce que ferait la skill — exécutez-la.
+- Ne mentionnez jamais une skill par son nom sans l'invoquer réellement. Annoncer une skill sans appeler l'outil est trompeur.
+- N'utilisez pas `Skill` pour les commandes CLI intégrées telles que `/help`, `/clear`, `/model` ou `/exit`. Celles-ci sont gérées directement par le harnais.
+- Ne réinvoquez pas une skill déjà en cours d'exécution dans le tour courant. Si vous voyez une balise `<command-name>` dans le tour courant, la skill a déjà été chargée — suivez ses instructions en place plutôt que de rappeler l'outil.
+- Si plusieurs skills peuvent s'appliquer, choisissez la plus spécifique. Pour les changements de configuration tels que l'ajout de permissions ou de hooks, préférez `update-config` à une approche de paramètres générique.
+- L'exécution d'une skill peut introduire de nouveaux rappels système, outils ou contraintes pour le reste du tour. Relisez l'état de la conversation après qu'une skill se termine avant de continuer.

package/concepts/fr/Tool-TaskCreate.md

@@ -1,78 +1,56 @@
 # TaskCreate
 
-## Définition
+Crée une nouvelle tâche dans la liste de tâches de l'équipe courante (ou la liste de tâches de la session lorsqu'aucune équipe n'est active). Utilisez-le pour capturer des éléments de travail à suivre, déléguer ou reprendre plus tard.
 
-Crée des entrées structurées dans la liste de tâches pour suivre la progression, organiser des tâches complexes et montrer l'avancement du travail à l'utilisateur.
+## Quand l'utiliser
 
-## Paramètres
-
-| Paramètre | Type | Requis | Description |
-|-----------|------|--------|-------------|
-| `subject` | string | Oui | Titre bref de la tâche, utiliser la forme impérative (comme « Fix authentication bug ») |
-| `description` | string | Oui | Description détaillée, incluant le contexte et les critères d'acceptation |
-| `activeForm` | string | Non | Texte au participe présent affiché quand la tâche est en cours (comme « Fixing authentication bug ») |
-| `metadata` | object | Non | Métadonnées arbitraires attachées à la tâche |
-
-## Cas d'utilisation
-
-**Adapté pour :**
-- Tâches complexes multi-étapes (plus de 3 étapes)
-- L'utilisateur a fourni plusieurs éléments à faire
-- Suivre le travail en mode planification
-- L'utilisateur demande explicitement d'utiliser une liste de tâches
-
-**Non adapté pour :**
-- Une seule tâche simple
-- Opérations simples de 3 étapes ou moins
-- Requêtes purement conversationnelles ou informatives
+- L'utilisateur décrit un travail en plusieurs étapes qui bénéficie d'un suivi explicite.
+- Vous décomposez une grosse requête en unités plus petites réalisables séparément.
+- Un suivi est découvert en cours de tâche et ne doit pas être oublié.
+- Vous avez besoin d'une trace durable de l'intention avant de confier le travail à un coéquipier ou à un sous-agent.
+- Vous opérez en mode plan et souhaitez que chaque étape du plan soit représentée comme une tâche concrète.
 
-## Notes
-
-- Toutes les nouvelles tâches ont le statut initial `pending`
-- `subject` utilise la forme impérative (« Run tests »), `activeForm` utilise le participe présent (« Running tests »)
-- Après la création de la tâche, les relations de dépendance (blocks/blockedBy) peuvent être établies via TaskUpdate
-- Avant de créer, appeler TaskList pour vérifier s'il y a des tâches en double
-
-## Texte original
+Sautez `TaskCreate` pour les actions triviales en un coup, la pure conversation ou tout ce qui est réalisable en deux ou trois appels d'outil directs.
 
-<textarea readonly>Use this tool to create a structured task list for your current coding session. This helps you track progress, organize complex tasks, and demonstrate thoroughness to the user.
-It also helps the user understand the progress of the task and overall progress of their requests.
+## Paramètres
 
-## When to Use This Tool
+- `subject` (string, requis) : titre court à l'impératif, par exemple `Fix login redirect on Safari`. Gardez-le sous environ quatre-vingts caractères.
+- `description` (string, requis) : contexte détaillé — le problème, les contraintes, les critères d'acceptation et les fichiers ou liens dont un futur lecteur aura besoin. Écrivez comme si un coéquipier allait reprendre cela à froid.
+- `activeForm` (string, optionnel) : texte de spinner au présent continu affiché tant que la tâche est `in_progress`, par exemple `Fixing login redirect on Safari`. Reflète le `subject` mais à la forme en -ing.
+- `metadata` (object, optionnel) : données structurées arbitraires attachées à la tâche. Usages courants : libellés, indices de priorité, IDs de tickets externes ou configuration spécifique à l'agent.
 
-Use this tool proactively in these scenarios:
+Les tâches nouvellement créées commencent toujours avec le statut `pending` et sans propriétaire. Les dépendances (`blocks`, `blockedBy`) ne sont pas définies à la création — appliquez-les ensuite avec `TaskUpdate`.
 
-- Complex multi-step tasks - When a task requires 3 or more distinct steps or actions
-- Non-trivial and complex tasks - Tasks that require careful planning or multiple operations
-- Plan mode - When using plan mode, create a task list to track the work
-- User explicitly requests todo list - When the user directly asks you to use the todo list
-- User provides multiple tasks - When users provide a list of things to be done (numbered or comma-separated)
-- After receiving new instructions - Immediately capture user requirements as tasks
-- When you start working on a task - Mark it as in_progress BEFORE beginning work
-- After completing a task - Mark it as completed and add any new follow-up tasks discovered during implementation
+## Exemples
 
-## When NOT to Use This Tool
+### Exemple 1
 
-Skip using this tool when:
-- There is only a single, straightforward task
-- The task is trivial and tracking it provides no organizational benefit
-- The task can be completed in less than 3 trivial steps
-- The task is purely conversational or informational
+Capturer un rapport de bug que l'utilisateur vient de déposer.
 
-NOTE that you should not use this tool if there is only one trivial task to do. In this case you are better off just doing the task directly.
+```
+TaskCreate(
+  subject: "Repair broken PDF export on Windows",
+  description: "Users on Windows 11 report the export button produces a 0-byte file. Reproduce with sample doc in test/fixtures/export/, then fix the code path in src/export/pdf.ts. Acceptance: export writes a valid PDF and the existing export test suite passes.",
+  activeForm: "Repairing broken PDF export on Windows"
+)
+```
 
-## Task Fields
+### Exemple 2
 
-- **subject**: A brief, actionable title in imperative form (e.g., "Fix authentication bug in login flow")
-- **description**: Detailed description of what needs to be done, including context and acceptance criteria
-- **activeForm**: Present continuous form shown in spinner when task is in_progress (e.g., "Fixing authentication bug"). This is displayed to the user while you work on the task.
+Découper une épopée en unités suivies au début d'une session.
 
-**IMPORTANT**: Always provide activeForm when creating tasks. The subject should be imperative ("Run tests") while activeForm should be present continuous ("Running tests"). All tasks are created with status `pending`.
+```
+TaskCreate(
+  subject: "Draft migration plan for auth service",
+  description: "Produce a written plan covering rollout stages, rollback strategy, and monitoring. Output: docs/auth-migration.md.",
+  activeForm: "Drafting migration plan for auth service",
+  metadata: { "priority": "P1", "linearId": "AUTH-214" }
+)
+```
 
-## Tips
+## Notes
 
-- Create tasks with clear, specific subjects that describe the outcome
-- Include enough detail in the description for another agent to understand and complete the task
-- After creating tasks, use TaskUpdate to set up dependencies (blocks/blockedBy) if needed
-- Check TaskList first to avoid creating duplicate tasks
-</textarea>
+- Écrivez le `subject` à la voix impérative et le `activeForm` au présent continu afin que l'interface se lise naturellement lorsque la tâche passe à `in_progress`.
+- Appelez `TaskList` avant de créer pour éviter les doublons — la liste d'équipe est partagée avec les coéquipiers et sous-agents.
+- N'incluez pas de secrets ou d'identifiants dans `description` ou `metadata` ; les enregistrements de tâches sont visibles à toute personne ayant accès à l'équipe.
+- Après la création, faites progresser la tâche dans son cycle de vie avec `TaskUpdate`. Ne laissez pas du travail silencieusement abandonné en `in_progress`.