cc-viewer 1.6.182 → 1.6.183

package/concepts/fr/Tool-EnterWorktree.md

@@ -1,56 +1,44 @@
 # EnterWorktree
 
-## Définition
+Crée un worktree Git isolé sur une nouvelle branche, ou bascule la session dans un worktree existant du dépôt courant, afin qu'un travail parallèle ou expérimental puisse se dérouler sans toucher au checkout principal.
 
-Creates an isolated git worktree and switches the current session into it. Only used when the user explicitly asks to work in a worktree.
+## Quand l'utiliser
 
-## Paramètres
-
-| Name | Type | Required | Description |
-|---|---|---|---|
-| name | string | No | A name for the worktree. If not provided, a random name is generated. |
-
-## Cas d'utilisation
-
-**Adapté pour :**
-- The user explicitly says "worktree" (e.g., "start a worktree", "work in a worktree", "create a worktree")
-
-**Non adapté pour :**
-- The user asks to create/switch branches — use git commands instead
-- The user asks to fix a bug or work on a feature — use normal git workflow unless they specifically mention worktrees
+- L'utilisateur dit explicitement « worktree » — par exemple « start a worktree », « create a worktree » ou « work in a worktree ».
+- Les instructions du projet dans `CLAUDE.md` ou la mémoire persistante vous indiquent d'utiliser un worktree pour la tâche en cours.
+- Vous souhaitez poursuivre une tâche précédemment configurée en tant que worktree (passez `path` pour y rentrer).
+- Plusieurs branches expérimentales doivent coexister sur le disque sans bascule constante de checkout.
+- Une tâche de longue durée doit être isolée des modifications sans rapport dans l'arbre de travail principal.
 
-## Remarques
-
-- Must be in a git repository, or have WorktreeCreate/WorktreeRemove hooks configured
-- Must not already be in a worktree
-
-## Texte original
-
-<textarea readonly>Use this tool ONLY when the user explicitly asks to work in a worktree. This tool creates an isolated git worktree and switches the current session into it.
+## Paramètres
 
-## When to Use
+- `name` (string, optionnel) : nom pour un nouveau répertoire de worktree. Chaque segment séparé par `/` ne peut contenir que des lettres, chiffres, points, underscores et tirets ; la chaîne complète est plafonnée à 64 caractères. Si omis et que `path` est également omis, un nom aléatoire est généré. Mutuellement exclusif avec `path`.
+- `path` (string, optionnel) : chemin de système de fichiers d'un worktree existant du dépôt courant dans lequel basculer. Doit apparaître dans `git worktree list` pour ce dépôt ; les chemins qui ne sont pas des worktrees enregistrés du dépôt courant sont rejetés. Mutuellement exclusif avec `name`.
 
-- The user explicitly says "worktree" (e.g., "start a worktree", "work in a worktree", "create a worktree", "use a worktree")
+## Exemples
 
-## When NOT to Use
+### Exemple 1 : créer un nouveau worktree avec un nom descriptif
 
-- The user asks to create a branch, switch branches, or work on a different branch — use git commands instead
-- The user asks to fix a bug or work on a feature — use normal git workflow unless they specifically mention worktrees
-- Never use this tool unless the user explicitly mentions "worktree"
+```
+EnterWorktree(name="feat/okta-sso")
+```
 
-## Requirements
+Crée `.claude/worktrees/feat/okta-sso` sur une nouvelle branche basée sur `HEAD`, puis bascule le répertoire de travail de la session à l'intérieur. Toutes les modifications de fichiers et commandes shell ultérieures opèrent à l'intérieur de ce worktree jusqu'à ce que vous en sortiez.
 
-- Must be in a git repository, OR have WorktreeCreate/WorktreeRemove hooks configured in settings.json
-- Must not already be in a worktree
+### Exemple 2 : rentrer dans un worktree existant
 
-## Behavior
+```
+EnterWorktree(path="/Users/me/repo/.claude/worktrees/feat/okta-sso")
+```
 
-- In a git repository: creates a new git worktree inside `.claude/worktrees/` with a new branch based on HEAD
-- Outside a git repository: delegates to WorktreeCreate/WorktreeRemove hooks for VCS-agnostic isolation
-- Switches the session's working directory to the new worktree
-- On session exit, the user will be prompted to keep or remove the worktree
+Reprend le travail dans un worktree précédemment créé. Comme vous y êtes entré via `path`, `ExitWorktree` ne le supprimera pas automatiquement — sortir avec `action: "keep"` retourne simplement au répertoire d'origine.
 
-## Parameters
+## Notes
 
-- `name` (optional): A name for the worktree. If not provided, a random name is generated.
-</textarea>
+- N'appelez pas `EnterWorktree` sauf si l'utilisateur l'a explicitement demandé ou si les instructions du projet l'exigent. Les changements de branche ordinaires ou les demandes de correction de bug doivent utiliser les commandes Git habituelles, pas les worktrees.
+- Lorsqu'il est invoqué dans un dépôt Git, l'outil crée un worktree sous `.claude/worktrees/` et enregistre une nouvelle branche basée sur `HEAD`. En dehors d'un dépôt Git, il délègue aux hooks `WorktreeCreate` / `WorktreeRemove` configurés dans `settings.json` pour une isolation indépendante du VCS.
+- Une seule session de worktree est active à la fois. L'outil refuse de s'exécuter si vous êtes déjà dans une session de worktree ; sortez d'abord avec `ExitWorktree`.
+- Utilisez `ExitWorktree` pour sortir en cours de session. Si la session se termine alors que vous êtes encore dans un worktree nouvellement créé, l'utilisateur est invité à le conserver ou à le supprimer.
+- Les worktrees entrés via `path` sont considérés comme externes — `ExitWorktree` avec `action: "remove"` ne les supprimera pas. C'est un garde-fou pour protéger les worktrees gérés manuellement par l'utilisateur.
+- Un nouveau worktree hérite du contenu de la branche courante mais possède un répertoire de travail et un index indépendants. Les modifications stagées ou non stagées du checkout principal ne sont pas visibles dans le worktree.
+- Astuce de nommage : préfixez avec le type de travail (`feat/`, `fix/`, `spike/`) afin que plusieurs worktrees concurrents soient faciles à distinguer dans `git worktree list`.

package/concepts/fr/Tool-ExitPlanMode.md

@@ -1,62 +1,42 @@
 # ExitPlanMode
 
-## Définition
+Soumet le plan d'implémentation rédigé pendant le mode plan pour approbation de l'utilisateur et — s'il est approuvé — fait sortir la session du mode plan afin que les modifications puissent commencer.
 
-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.
+## Quand l'utiliser
 
-## 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
+- Un plan rédigé pendant `EnterPlanMode` est complet et prêt à être examiné.
+- La tâche est orientée implémentation (changements de code ou de configuration), et non pure recherche, donc un plan explicite est approprié.
+- Toutes les lectures et analyses préalables ont été effectuées ; aucune investigation supplémentaire n'est nécessaire avant que l'utilisateur ne se prononce.
+- L'assistant a énuméré des chemins de fichiers, des fonctions et des étapes concrètes — pas seulement des objectifs.
+- L'utilisateur a demandé à voir le plan, ou le workflow en mode plan s'apprête à passer la main aux outils d'édition.
 
-**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
+## Paramètres
 
-- 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
+- `allowedPrompts` (array, optionnel) : invites que l'utilisateur peut saisir sur l'écran d'approbation pour approuver automatiquement ou modifier le plan. Chaque élément spécifie une permission limitée (par exemple un nom d'opération et l'outil auquel elle s'applique). Laissez non défini pour utiliser le flux d'approbation par défaut.
 
-## Texte original
+## Exemples
 
-<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.
+### Exemple 1 : soumission standard
 
-## 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
+Après avoir étudié un refactoring d'authentification en mode plan et écrit le fichier du plan sur disque, l'assistant appelle `ExitPlanMode` sans arguments. Le harnais lit le plan depuis son emplacement canonique, l'affiche à l'utilisateur et attend approbation ou rejet.
 
-## 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.
+### Exemple 2 : actions rapides pré-approuvées
 
-## 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
+```
+ExitPlanMode(allowedPrompts=[
+  {"tool": "Bash", "prompt": "run tests"},
+  {"tool": "Bash", "prompt": "install dependencies"}
+])
+```
 
-**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.
+Permet à l'utilisateur d'accorder d'avance la permission pour des commandes de suivi courantes, afin que l'assistant n'ait pas besoin de s'interrompre pour chaque invite de permission pendant l'implémentation.
 
-## Examples
+## Notes
 
-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>
+- `ExitPlanMode` n'a de sens que pour un travail de type implémentation. Si la demande de l'utilisateur est une tâche de recherche ou d'explication sans changement de fichier, répondez directement — ne passez pas par le mode plan juste pour en sortir.
+- Le plan doit déjà être écrit sur disque avant d'appeler cet outil. `ExitPlanMode` n'accepte pas le corps du plan comme paramètre ; il lit depuis le chemin attendu par le harnais.
+- Si l'utilisateur rejette le plan, vous retournez en mode plan. Révisez en fonction du retour et soumettez de nouveau ; ne commencez pas à éditer des fichiers tant que le plan n'est pas approuvé.
+- L'approbation accorde la permission de sortir du mode plan et d'utiliser des outils mutatifs (`Edit`, `Write`, `Bash`, etc.) pour la portée décrite dans le plan. Élargir la portée par la suite nécessite un nouveau plan ou un consentement explicite de l'utilisateur.
+- N'utilisez pas `AskUserQuestion` pour demander « ce plan vous convient-il ? » avant d'appeler cet outil — demander l'approbation du plan est exactement ce que fait `ExitPlanMode`, et l'utilisateur ne peut pas voir le plan tant qu'il n'est pas soumis.
+- Gardez le plan minimal et actionnable. Un relecteur doit pouvoir le parcourir en moins d'une minute et comprendre exactement ce qui va changer.
+- Si vous réalisez en cours d'implémentation que le plan était erroné, arrêtez-vous et faites un rapport à l'utilisateur plutôt que de dévier silencieusement. Rentrer en mode plan est une étape suivante valide.

package/concepts/fr/Tool-ExitWorktree.md

@@ -0,0 +1,41 @@
+# ExitWorktree
+
+Quitte une session de worktree précédemment créée par `EnterWorktree` et ramène la session dans le répertoire de travail d'origine. Cet outil agit uniquement sur les worktrees créés par `EnterWorktree` dans la session en cours ; s'il n'y a aucune session active de ce type, l'appel est sans effet.
+
+## Quand l'utiliser
+
+- Le travail dans un worktree isolé est terminé et vous souhaitez revenir au répertoire de travail principal.
+- Une tâche dans un worktree de branche de fonctionnalité est achevée et, après la fusion, vous voulez nettoyer la branche et le répertoire.
+- Vous souhaitez conserver le worktree pour une utilisation ultérieure et simplement revenir au répertoire d'origine sans rien supprimer.
+- Vous souhaitez abandonner une branche expérimentale ou temporaire sans laisser d'artefacts sur le disque.
+- Vous devez démarrer une nouvelle session `EnterWorktree`, ce qui nécessite de quitter d'abord la session actuelle.
+
+## Paramètres
+
+- `action` (chaîne, obligatoire) : `"keep"` conserve le répertoire du worktree et la branche sur le disque afin de pouvoir y revenir plus tard ; `"remove"` supprime le répertoire et la branche, effectuant une sortie propre.
+- `discard_changes` (booléen, optionnel, valeur par défaut `false`) : Pertinent uniquement lorsque `action` vaut `"remove"`. Si le worktree contient des fichiers non commités ou des commits absents de la branche d'origine, l'outil refuse la suppression à moins que `discard_changes` ne soit `true`. La réponse d'erreur liste les modifications concernées afin que vous puissiez confirmer avec l'utilisateur avant de relancer l'appel.
+
+## Exemples
+
+### Exemple 1 : sortie propre après la fusion des modifications
+
+Après avoir terminé le travail dans un worktree et fusionné la branche dans main, appelez `ExitWorktree` avec `action: "remove"` pour supprimer le répertoire du worktree et la branche, et revenir au répertoire de travail d'origine.
+
+```
+ExitWorktree(action: "remove")
+```
+
+### Exemple 2 : suppression d'un worktree temporaire contenant du code expérimental non commité
+
+Si un worktree contient des modifications expérimentales non commitées à supprimer entièrement, commencez par tenter `action: "remove"`. L'outil refusera et listera les modifications non commitées. Après confirmation de l'utilisateur que les modifications peuvent être supprimées, relancez l'appel avec `discard_changes: true`.
+
+```
+ExitWorktree(action: "remove", discard_changes: true)
+```
+
+## Notes
+
+- Cet outil agit uniquement sur les worktrees créés par `EnterWorktree` dans la session en cours. Il n'affectera pas les worktrees créés avec `git worktree add`, les worktrees de sessions précédentes, ni le répertoire de travail ordinaire si `EnterWorktree` n'a jamais été appelé — dans ces cas, l'appel est sans effet.
+- `action: "remove"` est refusé si le worktree contient des modifications non commitées ou des commits absents de la branche d'origine, à moins que `discard_changes: true` ne soit explicitement fourni. Confirmez toujours avec l'utilisateur avant de définir `discard_changes: true`, car les données ne peuvent pas être récupérées.
+- Si une session tmux est attachée au worktree : avec `remove`, elle est terminée ; avec `keep`, elle continue de s'exécuter et son nom est retourné afin que l'utilisateur puisse se reconnecter ultérieurement.
+- Après la fin de `ExitWorktree`, `EnterWorktree` peut être appelé à nouveau pour démarrer une nouvelle session de worktree.

package/concepts/fr/Tool-Glob.md

@@ -1,39 +1,35 @@
 # Glob
 
-## Définition
+Fait correspondre les noms de fichiers à un motif glob et renvoie les chemins triés par date de modification la plus récente en premier. Optimisé pour localiser rapidement des fichiers dans des bases de code de toute taille sans passer par `find`.
 
-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.
+## Quand l'utiliser
 
-## Paramètres
+- Énumérer chaque fichier d'une extension spécifique (par exemple tous les fichiers `*.ts` sous `src`)
+- Découvrir des fichiers de configuration ou de fixtures par convention de nommage (`**/jest.config.*`, `**/*.test.tsx`)
+- Restreindre la surface de recherche avant d'exécuter un `Grep` ciblé
+- Vérifier qu'un fichier existe déjà à un motif connu avant d'appeler `Write`
+- Trouver les fichiers récemment modifiés en s'appuyant sur le tri par date de modification
 
-| 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 » |
+## Paramètres
 
-## Cas d'utilisation
+- `pattern` (string, requis) : expression glob à faire correspondre. Prend en charge `*` pour les jokers sur un seul segment, `**` pour les correspondances récursives, et `{a,b}` pour les alternatives, par exemple `src/**/*.{ts,tsx}`.
+- `path` (string, optionnel) : répertoire dans lequel exécuter la recherche. Doit être un chemin de répertoire valide s'il est fourni. Omettez le champ entièrement pour rechercher dans le répertoire de travail courant. Ne passez pas les chaînes `"undefined"` ou `"null"`.
 
-**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
+## Exemples
 
-**Non adapté pour :**
-- Rechercher du contenu de fichiers — utiliser Grep
-- Exploration ouverte nécessitant plusieurs tours de recherche — utiliser Task (type Explore)
+### Exemple 1 : chaque fichier source TypeScript
+Appelez `Glob` avec `pattern: "src/**/*.ts"`. Le résultat est une liste triée par mtime, donc les fichiers édités le plus récemment apparaissent en premier, ce qui est utile pour se concentrer sur les points chauds.
 
-## Notes
+### Exemple 2 : localiser une classe candidate
+Lorsque vous soupçonnez qu'une classe réside dans un fichier dont vous ne connaissez pas le nom, cherchez avec `pattern: "**/*UserService*"` pour restreindre les candidats, puis enchaînez avec `Read` ou `Grep`.
 
-- 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
+### Exemple 3 : découverte parallèle avant une tâche plus large
+Dans un unique message, émettez plusieurs appels `Glob` (par exemple un pour `**/*.test.ts` et un pour `**/fixtures/**`) afin qu'ils s'exécutent en parallèle et que leurs résultats puissent être corrélés.
 
-## Texte original
+## Notes
 
-<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>
+- Les résultats sont triés par date de modification du fichier (plus récent en premier), et non par ordre alphabétique. Triez en aval si vous avez besoin d'un ordre stable.
+- Les motifs sont évalués par l'outil, et non par le shell ; vous n'avez pas besoin de les mettre entre guillemets ou de les échapper comme vous le feriez en ligne de commande.
+- Pour une exploration ouverte nécessitant plusieurs tours de recherche et de raisonnement, déléguez à une `Agent` avec le type d'agent Explore plutôt que d'enchaîner de nombreux appels `Glob`.
+- Préférez `Glob` aux invocations `Bash` de `find` ou `ls` pour la découverte de noms de fichiers ; il gère les permissions de façon cohérente et renvoie une sortie structurée.
+- Lorsque vous cherchez du contenu à l'intérieur des fichiers plutôt que des noms de fichiers, utilisez `Grep` à la place.

package/concepts/fr/Tool-Grep.md

@@ -1,57 +1,46 @@
 # Grep
 
-## Définition
+Recherche dans le contenu des fichiers en utilisant le moteur ripgrep. Offre une prise en charge complète des expressions régulières, un filtrage par type de fichier et trois modes de sortie pour arbitrer entre précision et compacité.
 
-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.
+## Quand l'utiliser
+
+- Localiser chaque site d'appel d'une fonction ou chaque référence à un identifiant
+- Vérifier si une chaîne ou un message d'erreur apparaît quelque part dans la base de code
+- Compter les occurrences d'un motif pour évaluer l'impact avant un refactoring
+- Restreindre une recherche à un type de fichier (`type: "ts"`) ou à un glob (`glob: "**/*.tsx"`)
+- Extraire des correspondances multilignes telles que des définitions de struct sur plusieurs lignes ou des blocs JSX avec `multiline: true`
 
 ## 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)
+- `pattern` (string, requis) : expression régulière à rechercher. Utilise la syntaxe ripgrep, donc les accolades littérales doivent être échappées (par exemple `interface\{\}` pour trouver `interface{}`).
+- `path` (string, optionnel) : fichier ou répertoire dans lequel chercher. Par défaut, le répertoire de travail courant.
+- `glob` (string, optionnel) : filtre de nom de fichier tel que `*.js` ou `*.{ts,tsx}`.
+- `type` (string, optionnel) : raccourci de type de fichier tel que `js`, `py`, `rust`, `go`. Plus efficace que `glob` pour les langages standards.
+- `output_mode` (enum, optionnel) : `files_with_matches` (par défaut, renvoie uniquement les chemins), `content` (renvoie les lignes correspondantes) ou `count` (renvoie les totaux de correspondances).
+- `-i` (boolean, optionnel) : correspondance insensible à la casse.
+- `-n` (boolean, optionnel) : inclut les numéros de ligne en mode `content`. Par défaut `true`.
+- `-A` (number, optionnel) : lignes de contexte à afficher après chaque correspondance (nécessite le mode `content`).
+- `-B` (number, optionnel) : lignes de contexte avant chaque correspondance (nécessite le mode `content`).
+- `-C` / `context` (number, optionnel) : lignes de contexte de chaque côté de chaque correspondance.
+- `multiline` (boolean, optionnel) : permet aux motifs d'enjamber les sauts de ligne (`.` correspond à `\n`). Par défaut `false`.
+- `head_limit` (number, optionnel) : limite les lignes, chemins de fichiers ou entrées de comptage renvoyés. Par défaut 250 ; passez `0` pour illimité (à utiliser avec parcimonie).
+- `offset` (number, optionnel) : ignore les N premiers résultats avant d'appliquer `head_limit`. Par défaut `0`.
+
+## Exemples
+
+### Exemple 1 : trouver tous les sites d'appel d'une fonction
+Réglez `pattern: "registerHandler\\("`, `output_mode: "content"` et `-C: 2` pour voir les lignes environnantes de chaque appel.
+
+### Exemple 2 : compter les correspondances pour un type
+Réglez `pattern: "TODO"`, `type: "py"` et `output_mode: "count"` pour voir les totaux de TODO par fichier dans les sources Python.
+
+### Exemple 3 : correspondance de struct multiligne
+Utilisez `pattern: "struct Config \\{[\\s\\S]*?version"` avec `multiline: true` pour capturer un champ déclaré plusieurs lignes à l'intérieur d'un struct Go.
 
 ## 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>
+- Préférez toujours `Grep` à l'exécution de `grep` ou `rg` via `Bash` ; l'outil est optimisé pour des permissions correctes et une sortie structurée.
+- Le mode de sortie par défaut est `files_with_matches`, le moins coûteux. Basculez vers `content` uniquement lorsque vous avez besoin de voir les lignes elles-mêmes.
+- Les drapeaux de contexte (`-A`, `-B`, `-C`) sont ignorés sauf si `output_mode` est `content`.
+- De gros ensembles de résultats consomment des tokens de contexte. Utilisez `head_limit`, `offset` ou des filtres `glob`/`type` plus serrés pour rester focalisé.
+- Pour la découverte de noms de fichiers, utilisez `Glob` à la place ; pour des investigations ouvertes sur de nombreux tours, lancez une `Agent` avec l'agent Explore.

package/concepts/fr/Tool-Monitor.md

@@ -0,0 +1,50 @@
+# Monitor
+
+Lance un moniteur en arrière-plan qui diffuse des événements depuis un script de longue durée. Chaque ligne de la sortie standard devient une notification — continuez à travailler pendant que les événements arrivent dans le chat.
+
+## Quand l'utiliser
+
+- Suivre les erreurs, avertissements ou signatures de crash dans un fichier journal pendant qu'un déploiement s'exécute
+- Interroger une API distante, une PR ou un pipeline CI toutes les 30 secondes pour détecter de nouveaux événements de statut
+- Surveiller les changements dans un répertoire du système de fichiers ou dans la sortie de compilation en temps réel
+- Attendre une condition spécifique sur de nombreuses itérations (par exemple un jalon d'étape d'entraînement ou le vidage d'une file d'attente)
+- **Pas** pour un simple "attendre jusqu'à la fin" — utiliser `Bash` avec `run_in_background` pour cela ; il émet une notification de fin lorsque le processus se termine
+
+## Paramètres
+
+- `command` (chaîne, obligatoire) : La commande shell ou le script à exécuter. Chaque ligne écrite sur la sortie standard devient un événement de notification distinct. Le moniteur se termine quand le processus se termine.
+- `description` (chaîne, obligatoire) : Une courte étiquette lisible affichée dans chaque notification. Être précis — "erreurs dans deploy.log" vaut mieux que "surveillance des logs". Cette étiquette identifie quel moniteur s'est déclenché.
+- `timeout_ms` (nombre, défaut `300000`, max `3600000`) : Délai de terminaison forcée en millisecondes. Après cette durée le processus est arrêté. Ignoré quand `persistent: true`.
+- `persistent` (booléen, défaut `false`) : Quand `true`, le moniteur s'exécute pendant toute la durée de la session sans délai d'expiration. L'arrêter explicitement avec `TaskStop`.
+
+## Exemples
+
+### Exemple 1 : Suivre un fichier journal pour les erreurs et les crashs
+
+Cet exemple couvre tous les états terminaux : marqueur de succès, traceback, mots-clés d'erreur courants, arrêt OOM et sortie inattendue du processus.
+
+```bash
+tail -F /var/log/deploy.log | grep -E --line-buffered \
+  "deployed|Traceback|Error|FAILED|assert|Killed|OOM"
+```
+
+Utiliser `grep --line-buffered` dans chaque pipe. Sans cela, le système d'exploitation met en tampon la sortie par blocs de 4 Ko et les événements peuvent être retardés de plusieurs minutes. Le motif d'alternance couvre à la fois le chemin de succès (`deployed`) et les chemins d'échec (`Traceback`, `Error`, `FAILED`, `Killed`, `OOM`). Un moniteur qui observe uniquement le marqueur de succès reste silencieux lors d'un crash — le silence est identique à "toujours en cours d'exécution".
+
+### Exemple 2 : Interroger une API distante toutes les 30 secondes
+
+```bash
+while true; do
+  curl -sf "https://api.example.com/status" || true
+  sleep 30
+done | grep --line-buffered -E "completed|failed|error"
+```
+
+`|| true` empêche une défaillance réseau transitoire de mettre fin à la boucle. Des intervalles d'interrogation de 30 secondes ou plus conviennent aux APIs distantes pour éviter les limites de débit. Ajuster le motif grep pour capturer à la fois les réponses de succès et d'échec afin que les erreurs côté API ne soient pas masquées par le silence.
+
+## Notes
+
+- **Toujours utiliser `grep --line-buffered` dans les pipes.** Sans cela, la mise en tampon des pipes retarde les événements de plusieurs minutes car le système d'exploitation accumule la sortie jusqu'à remplir un bloc de 4 Ko. `--line-buffered` force un vidage après chaque ligne.
+- **Le filtre doit couvrir à la fois les signatures de succès et d'échec.** Un moniteur qui observe uniquement le marqueur de succès reste silencieux en cas de crash, de blocage ou de sortie inattendue. Élargir l'alternance : inclure `Error`, `Traceback`, `FAILED`, `Killed`, `OOM` et des marqueurs d'état terminal similaires aux côtés du mot-clé de succès.
+- **Intervalles d'interrogation : 30 secondes ou plus pour les APIs distantes.** L'interrogation fréquente de services externes risque des erreurs de limite de débit ou des blocages. Pour les vérifications locales du système de fichiers ou des processus, 0,5–1 seconde est approprié.
+- **Utiliser `persistent: true` pour les moniteurs de durée de session.** Le `timeout_ms` par défaut de 300 000 ms (5 minutes) arrête le processus. Pour les moniteurs qui doivent s'exécuter jusqu'à un arrêt explicite, définir `persistent: true` et appeler `TaskStop` quand c'est terminé.
+- **Arrêt automatique en cas de flood d'événements.** Chaque ligne de la sortie standard est un message de conversation. Si le filtre est trop large et produit trop d'événements, le moniteur est automatiquement arrêté. Redémarrer avec un motif `grep` plus restrictif. Les lignes arrivant dans les 200 ms sont regroupées en une seule notification.

package/concepts/fr/Tool-NotebookEdit.md

@@ -1,33 +1,39 @@
 # NotebookEdit
 
-## Définition
+Modifie une seule cellule d'un notebook Jupyter (`.ipynb`). Prend en charge le remplacement du code source d'une cellule, l'insertion d'une nouvelle cellule ou la suppression d'une cellule existante tout en préservant le reste de la structure du notebook.
 
-Remplace, insère ou supprime des cellules spécifiques dans un Jupyter notebook (fichier .ipynb).
+## Quand l'utiliser
+
+- Corriger ou mettre à jour une cellule de code dans un notebook d'analyse sans réécrire l'intégralité du fichier
+- Remplacer une cellule markdown pour améliorer la narration ou ajouter de la documentation
+- Insérer une nouvelle cellule de code ou markdown à une position connue dans un notebook existant
+- Supprimer une cellule obsolète ou cassée afin que les cellules en aval n'en dépendent plus
+- Préparer un notebook reproductible en itérant sur les cellules une à une
 
 ## 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` |
+- `notebook_path` (string, requis) : chemin absolu du fichier `.ipynb`. Les chemins relatifs sont rejetés.
+- `new_source` (string, requis) : le nouveau code source de la cellule. Pour `replace` et `insert`, il devient le corps de la cellule ; pour `delete`, il est ignoré mais reste requis par le schéma.
+- `cell_id` (string, optionnel) : ID de la cellule cible. Dans les modes `replace` et `delete`, l'outil agit sur cette cellule. En mode `insert`, la nouvelle cellule est insérée immédiatement après la cellule avec cet ID ; omettez-le pour insérer en haut du notebook.
+- `cell_type` (enum, optionnel) : soit `code`, soit `markdown`. Requis lorsque `edit_mode` est `insert`. Lorsqu'omis pendant un `replace`, le type de la cellule existante est préservé.
+- `edit_mode` (enum, optionnel) : `replace` (par défaut), `insert` ou `delete`.
 
-## Cas d'utilisation
+## Exemples
 
-**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
+### Exemple 1 : remplacer une cellule de code boguée
+Appelez `NotebookEdit` avec `notebook_path` réglé sur le chemin absolu, `cell_id` sur l'ID de la cellule cible, et `new_source` contenant le code Python corrigé. Laissez `edit_mode` à sa valeur par défaut `replace`.
 
-## Notes
+### Exemple 2 : insérer une explication markdown
+Pour ajouter une cellule markdown juste après une cellule existante `setup`, réglez `edit_mode: "insert"`, `cell_type: "markdown"`, `cell_id` sur l'ID de la cellule setup, et mettez le texte explicatif dans `new_source`.
 
-- `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
+### Exemple 3 : supprimer une cellule obsolète
+Réglez `edit_mode: "delete"` et fournissez le `cell_id` de la cellule à supprimer. Fournissez n'importe quelle chaîne pour `new_source` ; elle n'est pas appliquée.
 
-## Texte original
+## Notes
 
-<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>
+- Passez toujours un chemin absolu. `NotebookEdit` ne résout pas les chemins relatifs par rapport au répertoire de travail.
+- L'outil ne réécrit que la cellule ciblée ; les compteurs d'exécution, sorties et métadonnées des cellules sans rapport restent intacts.
+- Insérer sans `cell_id` place la nouvelle cellule tout au début du notebook.
+- `cell_type` est obligatoire pour les insertions. Pour les remplacements, omettez-le sauf si vous voulez explicitement convertir une cellule de code en markdown ou vice versa.
+- Pour inspecter les cellules et récupérer leurs IDs, utilisez d'abord l'outil `Read` sur le notebook ; il renvoie les cellules avec leur contenu et leurs sorties.
+- Utilisez `Edit` habituel pour les fichiers source ordinaires ; `NotebookEdit` est spécifique au JSON `.ipynb` et comprend sa structure de cellules.

package/concepts/fr/Tool-PushNotification.md

@@ -0,0 +1,48 @@
+# PushNotification
+
+Envoie une notification de bureau depuis la session Claude Code en cours. Si Remote Control est connecté, la notification est également transmise sur le téléphone de l'utilisateur, attirant son attention de là où il se trouve vers la session.
+
+## Quand l'utiliser
+
+- Une tâche longue s'est terminée alors que l'utilisateur était probablement absent du terminal
+- Une compilation, une exécution de tests ou un déploiement est terminé et le résultat est prêt à être examiné
+- Un point de décision nécessitant la saisie de l'utilisateur a été atteint avant de pouvoir continuer
+- Une erreur ou un blocage est survenu et ne peut être résolu de façon autonome
+- L'utilisateur a explicitement demandé à être notifié lorsqu'une tâche ou une condition spécifique est remplie
+
+## Quand ne pas l'utiliser
+
+N'envoyez pas de notification pour des mises à jour de progression routinières en cours de tâche, ni pour confirmer que vous avez répondu à quelque chose que l'utilisateur vient clairement de demander et attend. Ne notifiez pas lorsqu'une tâche courte se termine — si l'utilisateur vient de la soumettre et attend, la notification n'apporte aucune valeur et érode la confiance dans les notifications futures. Penchez fortement vers l'absence d'envoi.
+
+## Paramètres
+
+- `message` (chaîne, obligatoire) : le corps de la notification. Gardez-le sous 200 caractères ; les systèmes d'exploitation mobiles tronquent les chaînes plus longues. Commencez par ce sur quoi l'utilisateur agirait : "build failed: 2 auth tests" est plus utile que "task complete".
+- `status` (chaîne, obligatoire) : toujours défini sur `"proactive"`. C'est un marqueur fixe qui ne change pas.
+
+## Exemples
+
+### Exemple 1 : notification à la fin d'une longue analyse
+
+Un audit de dépendances sur l'ensemble du dépôt a été demandé et a pris plusieurs minutes. L'utilisateur s'est éloigné. Lorsque le rapport est prêt :
+
+```
+message: "Audit des dépendances terminé : 3 CVE critiques dans lodash, axios, jsonwebtoken. Rapport : audit-report.txt"
+status: "proactive"
+```
+
+### Exemple 2 : signaler un point de décision lors d'un travail autonome
+
+Au cours d'une refactorisation en plusieurs étapes, il s'avère que deux modules ont des interfaces en conflit et ne peuvent être fusionnés sans une décision de conception :
+
+```
+message: "Refactorisation suspendue : AuthService et UserService ont des interfaces de token incompatibles. Votre décision est nécessaire."
+status: "proactive"
+```
+
+## Notes
+
+- Penchez vers **ne pas** envoyer. La notification interrompt l'utilisateur quoi qu'il fasse. Traitez-la comme un coût qui doit être justifié par la valeur de l'information.
+- Commencez par un contenu actionnable. Les premiers mots doivent indiquer ce qui s'est passé et ce que l'utilisateur doit faire, le cas échéant — pas une étiquette de statut générique.
+- Gardez `message` sous 200 caractères. Les systèmes d'exploitation mobiles tronqueront les chaînes plus longues, coupant la partie la plus importante si elle apparaît à la fin.
+- Si le résultat indique que le push n'a pas été envoyé parce que Remote Control n'est pas connecté, c'est le comportement attendu. Aucune nouvelle tentative ni action supplémentaire n'est nécessaire ; la notification de bureau locale se déclenche tout de même.
+- Évitez le spam de notifications. Si vous envoyez des notifications fréquemment pour des événements mineurs, l'utilisateur commencera à les ignorer. Réservez cet outil aux moments où il y a une réelle probabilité que l'utilisateur soit absent et veuille connaître le résultat maintenant.