cx-viewer 1.0.0

package/concepts/fr/Tool-ExitPlanMode.md

@@ -0,0 +1,62 @@
+# ExitPlanMode
+
+## Définition
+
+Quitte le mode planification et soumet le plan à l'utilisateur pour approbation. Le contenu du plan est lu à partir du fichier de plan écrit précédemment.
+
+## Paramètres
+
+| Paramètre | Type | Requis | Description |
+|-----------|------|--------|-------------|
+| `allowedPrompts` | array | Non | Liste des descriptions de permissions nécessaires pour implémenter le plan |
+
+Chaque élément du tableau `allowedPrompts` :
+
+| Champ | Type | Requis | Description |
+|-------|------|--------|-------------|
+| `tool` | enum | Oui | Outil applicable, actuellement seul `Bash` est supporté |
+| `prompt` | string | Oui | Description sémantique de l'opération (comme « run tests », « install dependencies ») |
+
+## Cas d'utilisation
+
+**Adapté pour :**
+- Le plan est terminé en mode planification, prêt à être soumis pour approbation de l'utilisateur
+- Uniquement pour les tâches d'implémentation nécessitant l'écriture de code
+
+**Non adapté pour :**
+- Tâches purement de recherche/exploration — pas besoin de quitter le mode planification
+- Vouloir demander à l'utilisateur « le plan est-il correct ? » — c'est exactement la fonction de cet outil, ne pas utiliser AskUserQuestion pour cela
+
+## Notes
+
+- Cet outil n'accepte pas le contenu du plan comme paramètre — il le lit à partir du fichier de plan écrit précédemment
+- L'utilisateur verra le contenu du fichier de plan pour l'approuver
+- Ne pas utiliser AskUserQuestion pour demander « le plan est-il correct ? » avant d'appeler cet outil, c'est redondant
+- Ne pas mentionner « plan » dans les questions, car l'utilisateur ne peut pas voir le contenu du plan avant ExitPlanMode
+
+## Texte original
+
+<textarea readonly>Use this tool when you are in plan mode and have finished writing your plan to the plan file and are ready for user approval.
+
+## How This Tool Works
+- You should have already written your plan to the plan file specified in the plan mode system message
+- This tool does NOT take the plan content as a parameter - it will read the plan from the file you wrote
+- This tool simply signals that you're done planning and ready for the user to review and approve
+- The user will see the contents of your plan file when they review it
+
+## When to Use This Tool
+IMPORTANT: Only use this tool when the task requires planning the implementation steps of a task that requires writing code. For research tasks where you're gathering information, searching files, reading files or in general trying to understand the codebase - do NOT use this tool.
+
+## Before Using This Tool
+Ensure your plan is complete and unambiguous:
+- If you have unresolved questions about requirements or approach, use AskUserQuestion first (in earlier phases)
+- Once your plan is finalized, use THIS tool to request approval
+
+**Important:** Do NOT use AskUserQuestion to ask "Is this plan okay?" or "Should I proceed?" - that's exactly what THIS tool does. ExitPlanMode inherently requests user approval of your plan.
+
+## Examples
+
+1. Initial task: "Search for and understand the implementation of vim mode in the codebase" - Do not use the exit plan mode tool because you are not planning the implementation steps of a task.
+2. Initial task: "Help me implement yank mode for vim" - Use the exit plan mode tool after you have finished planning the implementation steps of the task.
+3. Initial task: "Add a new feature to handle user authentication" - If unsure about auth method (OAuth, JWT, etc.), use AskUserQuestion first, then use exit plan mode tool after clarifying the approach.
+</textarea>

package/concepts/fr/Tool-Glob.md

@@ -0,0 +1,39 @@
+# Glob
+
+## Définition
+
+Outil rapide de correspondance de motifs de noms de fichiers, compatible avec des bases de code de toute taille. Renvoie les chemins de fichiers correspondants triés par date de modification.
+
+## Paramètres
+
+| Paramètre | Type | Requis | Description |
+|-----------|------|--------|-------------|
+| `pattern` | string | Oui | Motif glob (comme `**/*.js`, `src/**/*.ts`) |
+| `path` | string | Non | Répertoire de recherche, par défaut le répertoire de travail actuel. Ne pas passer « undefined » ou « null » |
+
+## Cas d'utilisation
+
+**Adapté pour :**
+- Rechercher des fichiers par motif de nom
+- Trouver tous les fichiers d'un type spécifique (comme tous les fichiers `.tsx`)
+- Localiser des fichiers d'abord lors de la recherche de définitions de classes spécifiques (comme `class Foo`)
+- Plusieurs appels Glob peuvent être lancés en parallèle dans un seul message
+
+**Non adapté pour :**
+- Rechercher du contenu de fichiers — utiliser Grep
+- Exploration ouverte nécessitant plusieurs tours de recherche — utiliser Task (type Explore)
+
+## Notes
+
+- Supporte la syntaxe glob standard : `*` correspond à un niveau, `**` correspond à plusieurs niveaux, `{}` correspond à plusieurs choix
+- Les résultats sont triés par date de modification
+- Plus recommandé que la commande `find` de Bash
+
+## Texte original
+
+<textarea readonly>- Fast file pattern matching tool that works with any codebase size
+- Supports glob patterns like "**/*.js" or "src/**/*.ts"
+- Returns matching file paths sorted by modification time
+- Use this tool when you need to find files by name patterns
+- When you are doing an open ended search that may require multiple rounds of globbing and grepping, use the Agent tool instead
+- You can call multiple tools in a single response. It is always better to speculatively perform multiple searches in parallel if they are potentially useful.</textarea>

package/concepts/fr/Tool-Grep.md

@@ -0,0 +1,57 @@
+# Grep
+
+## Définition
+
+Puissant outil de recherche de contenu basé sur ripgrep. Supporte les expressions régulières, le filtrage par type de fichier et plusieurs modes de sortie.
+
+## Paramètres
+
+| Paramètre | Type | Requis | Description |
+|-----------|------|--------|-------------|
+| `pattern` | string | Oui | Motif de recherche en expression régulière |
+| `path` | string | Non | Chemin de recherche (fichier ou répertoire), par défaut le répertoire de travail actuel |
+| `glob` | string | Non | Filtre de nom de fichier (comme `*.js`, `*.{ts,tsx}`) |
+| `type` | string | Non | Filtre de type de fichier (comme `js`, `py`, `rust`), plus efficace que glob |
+| `output_mode` | enum | Non | Mode de sortie : `files_with_matches` (par défaut), `content`, `count` |
+| `-i` | boolean | Non | Recherche insensible à la casse |
+| `-n` | boolean | Non | Afficher les numéros de ligne (mode content uniquement), par défaut true |
+| `-A` | number | Non | Nombre de lignes à afficher après la correspondance |
+| `-B` | number | Non | Nombre de lignes à afficher avant la correspondance |
+| `-C` / `context` | number | Non | Nombre de lignes à afficher avant et après la correspondance |
+| `head_limit` | number | Non | Limiter le nombre d'entrées en sortie, par défaut 0 (illimité) |
+| `offset` | number | Non | Ignorer les N premiers résultats |
+| `multiline` | boolean | Non | Activer le mode de correspondance multiligne, par défaut false |
+
+## Cas d'utilisation
+
+**Adapté pour :**
+- Rechercher des chaînes ou motifs spécifiques dans la base de code
+- Trouver les emplacements d'utilisation de fonctions/variables
+- Filtrer les résultats de recherche par type de fichier
+- Compter le nombre de correspondances
+
+**Non adapté pour :**
+- Rechercher des fichiers par nom — utiliser Glob
+- Exploration ouverte nécessitant plusieurs tours de recherche — utiliser Task (type Explore)
+
+## Notes
+
+- Utilise la syntaxe ripgrep (pas grep), les caractères spéciaux comme les accolades doivent être échappés
+- Le mode `files_with_matches` ne renvoie que les chemins de fichiers, c'est le plus efficace
+- Le mode `content` renvoie le contenu des lignes correspondantes, supporte les lignes de contexte
+- La correspondance multiligne nécessite de définir `multiline: true`
+- Toujours préférer l'outil Grep aux commandes `grep` ou `rg` dans Bash
+
+## Texte original
+
+<textarea readonly>A powerful search tool built on ripgrep
+
+  Usage:
+  - ALWAYS use Grep for search tasks. NEVER invoke `grep` or `rg` as a Bash command. The Grep tool has been optimized for correct permissions and access.
+  - Supports full regex syntax (e.g., "log.*Error", "function\s+\w+")
+  - Filter files with glob parameter (e.g., "*.js", "**/*.tsx") or type parameter (e.g., "js", "py", "rust")
+  - Output modes: "content" shows matching lines, "files_with_matches" shows only file paths (default), "count" shows match counts
+  - Use Agent tool for open-ended searches requiring multiple rounds
+  - Pattern syntax: Uses ripgrep (not grep) - literal braces need escaping (use `interface\{\}` to find `interface{}` in Go code)
+  - Multiline matching: By default patterns match within single lines only. For cross-line patterns like `struct \{[\s\S]*?field`, use `multiline: true`
+</textarea>

package/concepts/fr/Tool-NotebookEdit.md

@@ -0,0 +1,33 @@
+# NotebookEdit
+
+## Définition
+
+Remplace, insère ou supprime des cellules spécifiques dans un Jupyter notebook (fichier .ipynb).
+
+## Paramètres
+
+| Paramètre | Type | Requis | Description |
+|-----------|------|--------|-------------|
+| `notebook_path` | string | Oui | Chemin absolu du fichier notebook |
+| `new_source` | string | Oui | Nouveau contenu de la cellule |
+| `cell_id` | string | Non | ID de la cellule à éditer. En mode insertion, la nouvelle cellule est insérée après cet ID |
+| `cell_type` | enum | Non | Type de cellule : `code` ou `markdown`. Requis en mode insertion |
+| `edit_mode` | enum | Non | Mode d'édition : `replace` (par défaut), `insert`, `delete` |
+
+## Cas d'utilisation
+
+**Adapté pour :**
+- Modifier des cellules de code ou markdown dans des Jupyter notebooks
+- Ajouter de nouvelles cellules à un notebook
+- Supprimer des cellules d'un notebook
+
+## Notes
+
+- `cell_number` est indexé à partir de 0
+- Le mode `insert` insère une nouvelle cellule à la position spécifiée
+- Le mode `delete` supprime la cellule à la position spécifiée
+- Le chemin doit être absolu
+
+## Texte original
+
+<textarea readonly>Completely replaces the contents of a specific cell in a Jupyter notebook (.ipynb file) with new source. Jupyter notebooks are interactive documents that combine code, text, and visualizations, commonly used for data analysis and scientific computing. The notebook_path parameter must be an absolute path, not a relative path. The cell_number is 0-indexed. Use edit_mode=insert to add a new cell at the index specified by cell_number. Use edit_mode=delete to delete the cell at the index specified by cell_number.</textarea>

package/concepts/fr/Tool-Read.md

@@ -0,0 +1,56 @@
+# Read
+
+## Définition
+
+Lit le contenu de fichiers depuis le système de fichiers local. Supporte les fichiers texte, images, PDF et Jupyter notebook.
+
+## 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 |
+
+## Cas d'utilisation
+
+**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
+
+**Non adapté pour :**
+- Lire des répertoires — utiliser la commande `ls` de Bash
+- Exploration ouverte de la base de code — utiliser Task (type Explore)
+
+## 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>

package/concepts/fr/Tool-SendMessage.md

@@ -0,0 +1,41 @@
+# SendMessage
+
+## Définition
+
+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).
+
+## 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 |
+
+## Types de messages
+
+### Texte brut
+Messages directs entre coéquipiers pour la coordination, les mises à jour d'état et les discussions sur les tâches.
+
+### Requête d'arrêt
+Demande à un coéquipier de s'arrêter proprement : `{ type: "shutdown_request", reason: "..." }`
+
+### Réponse d'arrêt
+Le coéquipier approuve ou refuse l'arrêt : `{ type: "shutdown_response", approve: true/false }`
+
+### Réponse d'approbation de plan
+Approuve ou refuse le plan d'un coéquipier : `{ type: "plan_approval_response", approve: true/false }`
+
+## Diffusion vs. Direct
+
+- **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
+
+## Outils associés
+
+| 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 |

package/concepts/fr/Tool-Skill.md

@@ -0,0 +1,56 @@
+# Skill
+
+## Définition
+
+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`).
+
+## Paramètres
+
+| 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 |
+
+## Cas d'utilisation
+
+**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
+
+**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
+
+## Notes
+
+- 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
+
+## Texte original
+
+<textarea readonly>Execute a skill within the main conversation
+
+When users ask you to perform tasks, check if any of the available skills match. Skills provide specialized capabilities and domain knowledge.
+
+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
+
+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>

package/concepts/fr/Tool-Task.md

@@ -0,0 +1,51 @@
+# Task
+
+> **Note :** Dans les versions récentes de Claude Code, cet outil a été renommé en **Agent**. Voir le document [Tool-Agent](Tool-Agent).
+
+## Définition
+
+Lance un sous-agent (SubAgent) pour gérer de manière autonome des tâches complexes multi-étapes. Les sous-agents sont des sous-processus indépendants, chacun avec son propre ensemble d'outils et contexte dédiés.
+
+## Paramètres
+
+| Paramètre | Type | Requis | Description |
+|-----------|------|--------|-------------|
+| `prompt` | string | Oui | Description de la tâche à exécuter par le sous-agent |
+| `description` | string | Oui | Résumé bref de 3-5 mots |
+| `subagent_type` | string | Oui | Type de sous-agent, détermine l'ensemble d'outils disponibles |
+| `model` | enum | Non | Spécifier le modèle (sonnet / opus / haiku), par défaut hérité du parent |
+| `max_turns` | integer | Non | Nombre maximum de tours agentiques |
+| `run_in_background` | boolean | Non | Si la tâche s'exécute en arrière-plan ; les tâches en arrière-plan renvoient le chemin du output_file |
+| `resume` | string | Non | ID de l'agent à reprendre, continue depuis la dernière exécution |
+| `isolation` | enum | Non | Mode d'isolation, `worktree` crée un git worktree temporaire |
+
+## Types de sous-agents
+
+| Type | Utilité | Outils disponibles |
+|------|---------|-------------------|
+| `Bash` | Exécution de commandes, opérations git | Bash |
+| `general-purpose` | Tâches générales multi-étapes | Tous les outils |
+| `Explore` | Exploration rapide de la base de code | Tous les outils sauf Task/Edit/Write/NotebookEdit/ExitPlanMode |
+| `Plan` | Concevoir des plans d'implémentation | Tous les outils sauf Task/Edit/Write/NotebookEdit/ExitPlanMode |
+| `claude-code-guide` | Questions-réponses sur le guide d'utilisation de Claude Code | Glob, Grep, Read, WebFetch, WebSearch |
+| `statusline-setup` | Configurer la barre d'état | Read, Edit |
+
+## Cas d'utilisation
+
+**Adapté pour :**
+- Tâches complexes nécessitant une réalisation autonome en plusieurs étapes
+- Exploration de la base de code et recherche approfondie (utiliser le type Explore)
+- Travail parallèle nécessitant des environnements isolés
+- Tâches de longue durée nécessitant une exécution en arrière-plan
+
+**Non adapté pour :**
+- Lire des chemins de fichiers spécifiques — utiliser directement Read ou Glob
+- Rechercher dans 2-3 fichiers connus — utiliser directement Read
+- Rechercher des définitions de classes spécifiques — utiliser directement Glob
+
+## Notes
+
+- Le sous-agent renvoie un seul message à la fin, ses résultats ne sont pas visibles pour l'utilisateur et l'agent principal doit les transmettre
+- Plusieurs appels Task peuvent être lancés en parallèle dans un seul message pour améliorer l'efficacité
+- Les tâches en arrière-plan vérifient la progression via l'outil TaskOutput
+- Le type Explore est plus lent que l'appel direct à Glob/Grep, à utiliser uniquement quand la recherche simple ne suffit pas

package/concepts/fr/Tool-TaskCreate.md

@@ -0,0 +1,78 @@
+# TaskCreate
+
+## Définition
+
+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.
+
+## 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
+
+## 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
+
+<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.
+
+## When to Use This Tool
+
+Use this tool proactively in these scenarios:
+
+- 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
+
+## When NOT to Use This Tool
+
+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
+
+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.
+
+## Task Fields
+
+- **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.
+
+**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`.
+
+## Tips
+
+- 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>

package/concepts/fr/Tool-TaskGet.md

@@ -0,0 +1,56 @@
+# TaskGet
+
+## Définition
+
+Obtient les détails complets d'une tâche via son ID.
+
+## Paramètres
+
+| Paramètre | Type | Requis | Description |
+|-----------|------|--------|-------------|
+| `taskId` | string | Oui | ID de la tâche à obtenir |
+
+## Contenu renvoyé
+
+- `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
+
+## Cas d'utilisation
+
+**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
+
+## Notes
+
+- 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
+
+## Texte original
+
+<textarea readonly>Use this tool to retrieve a task by its ID from the task list.
+
+## When to Use This Tool
+
+- 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
+
+## Output
+
+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
+
+## Tips
+
+- After fetching a task, verify its blockedBy list is empty before beginning work.
+- Use TaskList to see all tasks in summary form.
+</textarea>

package/concepts/fr/Tool-TaskList.md

@@ -0,0 +1,56 @@
+# TaskList
+
+## Définition
+
+Liste toutes les tâches dans la liste de tâches pour voir la progression globale et le travail disponible.
+
+## Paramètres
+
+Aucun paramètre.
+
+## Contenu renvoyé
+
+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
+
+## Cas d'utilisation
+
+**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
+
+## Notes
+
+- 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
+
+## Texte original
+
+<textarea readonly>Use this tool to list all tasks in the task list.
+
+## When to Use This Tool
+
+- 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
+
+## Output
+
+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)
+
+Use TaskGet with a specific task ID to view full details including description and comments.
+</textarea>

package/concepts/fr/Tool-TaskOutput.md

@@ -0,0 +1,40 @@
+# TaskOutput
+
+## Définition
+
+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.
+
+## 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 |
+
+## Cas d'utilisation
+
+**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
+
+**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
+
+## Notes
+
+- `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
+
+## Texte original
+
+<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>