> ## Documentation Index
> Fetch the complete documentation index at: https://code.claude.com/docs/llms.txt
> Use this file to discover all available pages before exploring further.
# Choisir un mode de permission
> Contrôlez si Claude demande avant de modifier les fichiers ou d'exécuter des commandes. Changez de mode avec Maj+Tab dans le CLI ou utilisez le sélecteur de mode dans VS Code, Desktop et claude.ai.
Quand Claude veut modifier un fichier, exécuter une commande shell ou effectuer une demande réseau, il s'arrête et vous demande d'approuver l'action. Les modes de permission contrôlent la fréquence de cette pause. Le mode que vous choisissez façonne le flux d'une session : le mode par défaut vous permet d'examiner chaque action au fur et à mesure, tandis que les modes plus souples permettent à Claude de travailler dans des étapes plus longues et ininterrompues et de faire un rapport quand c'est terminé. Choisissez une supervision plus importante pour les travaux sensibles, ou moins d'interruptions quand vous faites confiance à la direction.
Modes disponibles
Chaque mode fait un compromis différent entre la commodité et la supervision. Le tableau ci-dessous montre ce que Claude peut faire sans invite de permission dans chaque mode.
| Mode | Ce qui s'exécute sans demander | Idéal pour |
| :------------------------------------------------------------------ | :--------------------------------------------------------------------------------------------------------------------- | :-------------------------------------------------- |
| `default` | Lectures uniquement | Démarrage, travaux sensibles |
| [`acceptEdits`](#auto-approve-file-edits-with-acceptedits-mode) | Lectures, modifications de fichiers et commandes courantes du système de fichiers (`mkdir`, `touch`, `mv`, `cp`, etc.) | Itération sur le code que vous examinez |
| [`plan`](#analyze-before-you-edit-with-plan-mode) | Lectures uniquement | Explorer une base de code avant de la modifier |
| [`auto`](#eliminate-prompts-with-auto-mode) | Tout, avec des vérifications de sécurité en arrière-plan | Tâches longues, réduction de la fatigue des invites |
| [`dontAsk`](#allow-only-pre-approved-tools-with-dontask-mode) | Uniquement les outils pré-approuvés | CI verrouillé et scripts |
| [`bypassPermissions`](#skip-all-checks-with-bypasspermissions-mode) | Tout | Conteneurs et machines virtuelles isolés uniquement |
Dans tous les modes sauf `bypassPermissions`, les écritures dans les [chemins protégés](#protected-paths) ne sont jamais auto-approuvées, protégeant l'état du dépôt et la configuration propre de Claude contre la corruption accidentelle.
Les modes définissent la ligne de base. Superposez les [règles de permission](/fr/permissions#manage-permissions) sur le dessus pour pré-approuver ou bloquer des outils spécifiques. Les règles de refus et les règles de demande explicite s'appliquent dans tous les modes, y compris `bypassPermissions`. Les règles d'autorisation n'ont aucun effet dans ce mode car tout le reste est déjà approuvé.
Changer de mode de permission
Vous pouvez changer de mode en cours de session, au démarrage ou comme paramètre par défaut persistant. Le mode est défini via ces contrôles, pas en demandant à Claude dans le chat. Sélectionnez votre interface ci-dessous pour voir comment le modifier.
**Pendant une session** : appuyez sur `Maj+Tab` pour parcourir `default` → `acceptEdits` → `plan`. Le mode actuel apparaît dans la barre d'état. Tous les modes ne sont pas dans le cycle par défaut :
* `auto` : apparaît quand votre compte répond aux [exigences du mode auto](#eliminate-prompts-with-auto-mode) ; le parcours vers auto affiche une invite d'acceptation jusqu'à ce que vous l'acceptiez, ou sélectionnez **Non, ne me le demandez plus** pour supprimer auto du cycle
* `bypassPermissions` : apparaît après que vous ayez démarré avec `--permission-mode bypassPermissions`, `--dangerously-skip-permissions`, ou `--allow-dangerously-skip-permissions` ; la variante `--allow-` ajoute le mode au cycle sans l'activer
* `dontAsk` : n'apparaît jamais dans le cycle ; définissez-le avec `--permission-mode dontAsk`
Les modes optionnels activés s'insèrent après `plan`, avec `bypassPermissions` en premier et `auto` en dernier. Si vous avez les deux activés, vous parcourrez `bypassPermissions` en allant vers `auto`.
**Au démarrage** : passez le mode comme drapeau.
```bash theme={null}
claude --permission-mode plan
```
**Par défaut** : définissez `defaultMode` dans les [paramètres](/fr/settings#settings-files).
```json theme={null}
{
"permissions": {
"defaultMode": "acceptEdits"
}
}
```
Le même drapeau `--permission-mode` fonctionne avec `-p` pour les [exécutions non-interactives](/fr/headless).
**Pendant une session** : cliquez sur l'indicateur de mode en bas de la boîte d'invite.
**Par défaut** : définissez `claudeCode.initialPermissionMode` dans les paramètres VS Code, ou utilisez le panneau de paramètres de l'extension Claude Code.
L'indicateur de mode affiche ces étiquettes, mappées au mode auquel chacune s'applique :
| Étiquette UI | Mode |
| :------------------------------- | :------------------ |
| Demander avant les modifications | `default` |
| Modifier automatiquement | `acceptEdits` |
| Mode de planification | `plan` |
| Mode auto | `auto` |
| Ignorer les permissions | `bypassPermissions` |
Le mode auto apparaît dans l'indicateur de mode quand votre compte répond à chaque exigence listée dans la [section mode auto](#eliminate-prompts-with-auto-mode). Le paramètre `claudeCode.initialPermissionMode` n'accepte pas `auto`. Pour démarrer en mode auto par défaut, définissez `defaultMode` dans vos [paramètres utilisateur](/fr/settings#settings-files) à la place. Claude Code ignore `defaultMode: "auto"` dans les paramètres de projet et locaux.
Ignorer les permissions nécessite le bouton **Autoriser l'ignorance dangereuse des permissions** dans les paramètres de l'extension avant qu'il n'apparaisse dans l'indicateur de mode.
Consultez le [guide VS Code](/fr/vs-code) pour les détails spécifiques à l'extension.
Le plugin JetBrains exécute Claude Code dans le terminal IDE, donc le changement de mode fonctionne de la même manière que dans le CLI : appuyez sur `Maj+Tab` pour parcourir, ou passez `--permission-mode` lors du lancement.
Utilisez le sélecteur de mode à côté du bouton d'envoi. Auto et Ignorer les permissions n'apparaissent qu'après les avoir activés dans les paramètres Desktop. Consultez le [guide Desktop](/fr/desktop#choose-a-permission-mode).
Utilisez le menu déroulant de mode à côté de la boîte d'invite sur [claude.ai/code](https://claude.ai/code) ou dans l'application mobile. Les invites de permission apparaissent dans claude.ai pour approbation. Les modes qui apparaissent dépendent de l'endroit où la session s'exécute :
* **Sessions cloud** sur [Claude Code sur le web](/fr/claude-code-on-the-web) : Accepter les modifications, Mode de planification et Mode auto. Accepter les modifications correspond au mode `default` : l'environnement cloud pré-approuve les modifications de fichiers indépendamment du mode, donc le menu déroulant affiche Accepter les modifications au lieu de Demander les permissions. `defaultMode: "acceptEdits"` à partir des paramètres est toujours respecté. Le mode auto n'apparaît que quand votre organisation l'autorise et que le modèle sélectionné le supporte. Ignorer les permissions n'est pas disponible.
* **Sessions [Contrôle à distance](/fr/remote-control)** sur votre machine locale : Demander les permissions, Accepter automatiquement les modifications et Mode de planification. Auto et Ignorer les permissions ne sont pas disponibles.
Pour le Contrôle à distance, vous pouvez également définir le mode de démarrage lors du lancement de l'hôte :
```bash theme={null}
claude remote-control --permission-mode acceptEdits
```
Approuver automatiquement les modifications de fichiers avec le mode acceptEdits
Le mode `acceptEdits` permet à Claude de créer et de modifier des fichiers dans votre répertoire de travail sans inviter. La barre d'état affiche `⏵⏵ accept edits on` tandis que ce mode est actif.
En plus des modifications de fichiers, le mode `acceptEdits` approuve automatiquement les commandes Bash courantes du système de fichiers : `mkdir`, `touch`, `rm`, `rmdir`, `mv`, `cp` et `sed`. Ces commandes sont également auto-approuvées quand elles sont préfixées avec des variables d'environnement sûres comme `LANG=C` ou `NO_COLOR=1`, ou des wrappers de processus comme `timeout`, `nice` ou `nohup`. Comme les modifications de fichiers, l'approbation automatique s'applique uniquement aux chemins à l'intérieur de votre répertoire de travail ou `additionalDirectories`. Les chemins en dehors de cette portée, les écritures dans les [chemins protégés](#protected-paths) et toutes les autres commandes Bash invitent toujours.
Quand l'[outil PowerShell](/fr/tools-reference#powershell-tool) est activé, le mode `acceptEdits` approuve également automatiquement `Set-Content`, `Add-Content`, `Clear-Content` et `Remove-Item` sur les chemins dans la portée, ainsi que leurs alias courants. Les mêmes règles de portée et de chemins protégés s'appliquent.
Utilisez `acceptEdits` quand vous voulez examiner les modifications dans votre éditeur ou via `git diff` après coup plutôt que d'approuver chaque modification en ligne. Appuyez sur `Maj+Tab` une fois depuis le mode par défaut pour l'entrer, ou démarrez directement avec :
```bash theme={null}
claude --permission-mode acceptEdits
```
Analyser avant de modifier avec le mode de planification
Le mode de planification indique à Claude de rechercher et de proposer des modifications sans les apporter. Claude lit les fichiers, exécute des commandes shell pour explorer et écrit un plan, mais ne modifie pas votre source. Les invites de permission s'appliquent de la même manière que le mode par défaut.
Entrez le mode de planification en appuyant sur `Maj+Tab` ou en préfixant une seule invite avec `/plan`. Vous pouvez également démarrer en mode de planification depuis le CLI :
```bash theme={null}
claude --permission-mode plan
```
Appuyez sur `Maj+Tab` à nouveau pour quitter le mode de planification sans approuver un plan.
Examiner et approuver un plan
Quand le plan est prêt, Claude le présente et demande comment procéder. À partir de cette invite, vous pouvez :
* Approuver et démarrer en mode auto
* Approuver et accepter les modifications
* Approuver et examiner manuellement chaque modification
* Continuer la planification avec des commentaires
* Affiner avec [Ultraplan](/fr/ultraplan) pour un examen basé sur le navigateur
Approuver un plan quitte le mode de planification et bascule la session vers le mode de permission que chaque option d'approbation décrit, de sorte que Claude commence à modifier. Pour planifier à nouveau, revenez au mode de planification avec `Maj+Tab`, ou préfixez votre prochaine invite avec `/plan`.
Appuyez sur `Ctrl+G` pour ouvrir le plan proposé dans votre éditeur de texte par défaut et le modifier directement avant que Claude ne procède. Quand [`showClearContextOnPlanAccept`](/fr/settings#available-settings) est activé, chaque option d'approbation offre également d'effacer le contexte de planification en premier.
Accepter un plan nomme également la session à partir du contenu du plan automatiquement, sauf si vous avez déjà défini un nom avec `--name` ou `/rename`.
Définir le mode de planification comme valeur par défaut
Pour faire du mode de planification la valeur par défaut pour un projet, définissez `defaultMode` dans `.claude/settings.json` :
```json theme={null}
{
"permissions": {
"defaultMode": "plan"
}
}
```
Éliminer les invites de permission avec le mode auto
Le mode auto nécessite Claude Code v2.1.83 ou ultérieur.
Le mode auto permet à Claude d'exécuter sans invites de permission de routine. Un modèle classificateur séparé examine les actions avant qu'elles ne s'exécutent, bloquant tout ce qui escalade au-delà de votre demande, cible une infrastructure non reconnue ou semble entraîné par du contenu hostile que Claude a lu. Les [règles d'ask](/fr/permissions#manage-permissions) explicites forcent toujours une invite.
Le mode auto instruit également Claude à continuer à travailler sans s'arrêter pour des questions de clarification, bien que Claude pose toujours des questions quand votre invite ou une compétence s'y appuie explicitement. Pour un comportement autonome plus fort tout en conservant les invites de permission, définissez plutôt le [style de sortie proactif](/fr/output-styles).
Le mode auto est un aperçu de recherche. Il réduit les invites de permission mais ne garantit pas la sécurité. Utilisez-le pour les tâches où vous faites confiance à la direction générale, pas comme remplacement de l'examen sur les opérations sensibles.
Le mode auto n'est disponible que quand votre compte répond à toutes ces exigences :
* **Plan** : Tous les plans.
* **Propriétaire** : sur Team et Enterprise, un Propriétaire doit l'activer dans les [paramètres d'administration Claude Code](https://claude.ai/admin-settings/claude-code) avant que les utilisateurs puissent l'activer. Les administrateurs peuvent également le verrouiller en définissant `permissions.disableAutoMode` sur `"disable"` dans les [paramètres gérés](/fr/permissions#managed-settings).
* **Modèle** : sur l'API Anthropic, Claude Opus 4.6 ou ultérieur, ou Sonnet 4.6. Sur Amazon Bedrock, Google Cloud Vertex AI et Microsoft Foundry, uniquement Claude Opus 4.7 et Opus 4.8. Les modèles plus anciens, y compris Sonnet 4.5, Opus 4.5, Haiku et les modèles claude-3, ne sont pas supportés sur aucun fournisseur.
* **Fournisseur** : disponible par défaut sur l'API Anthropic. Sur Amazon Bedrock, Google Cloud Vertex AI et Microsoft Foundry, le mode auto est désactivé jusqu'à ce que vous [définissiez `CLAUDE_CODE_ENABLE_AUTO_MODE`](#enable-auto-mode-on-bedrock-vertex-ai-or-foundry).
Si Claude Code signale le mode auto comme indisponible, l'une de ces exigences n'est pas remplie ; ce n'est pas une panne transitoire. Un message séparé qui nomme un modèle et dit que le mode auto « ne peut pas déterminer la sécurité » d'une action est une panne transitoire du classificateur ; consultez la [référence d'erreur](/fr/errors#auto-mode-cannot-determine-the-safety-of-an-action).
Si vous définissez `defaultMode: "auto"` dans les [paramètres](/fr/settings#available-settings) et que la session démarre en mode `default` sans erreur, le paramètre se trouve probablement dans `.claude/settings.json` ou `.claude/settings.local.json`. Claude Code v2.1.142 et ultérieur ignorent `auto` de ces fichiers afin qu'un dépôt ne puisse pas s'accorder le mode auto. Déplacez-le vers `~/.claude/settings.json`.
Activer le mode auto sur Bedrock, Vertex AI ou Foundry
Sur [Amazon Bedrock](/fr/amazon-bedrock), [Google Cloud Vertex AI](/fr/google-vertex-ai) et [Microsoft Foundry](/fr/microsoft-foundry), le mode auto n'apparaît pas dans le cycle `Shift+Tab` jusqu'à ce que `CLAUDE_CODE_ENABLE_AUTO_MODE` soit défini sur `1`. La variable fonctionne dans Claude Code v2.1.158 et ultérieur. Seuls Claude Opus 4.7 et Opus 4.8 sont supportés sur ces fournisseurs.
Pour l'activer pour un développeur, ajoutez la variable au bloc `env` dans `~/.claude/settings.json` :
```json theme={null}
{
"env": {
"CLAUDE_CODE_ENABLE_AUTO_MODE": "1"
}
}
```
Pour l'activer pour votre organisation, ajoutez le même bloc `env` aux [paramètres gérés](/fr/settings#settings-files).
Une fois la variable définie, le mode auto apparaît dans le cycle `Shift+Tab` pour chaque session. Pour en faire le mode de démarrage par défaut, définissez également `"permissions": {"defaultMode": "auto"}` dans les paramètres utilisateur ou gérés. Sur ces fournisseurs, Claude Code ignore `defaultMode: "auto"` sauf si `CLAUDE_CODE_ENABLE_AUTO_MODE` est également défini.
Pour empêcher les développeurs d'activer le mode auto, définissez `disableAutoMode` sur `"disable"` dans les paramètres gérés. Cela remplace la variable d'activation.
Si vous vous connectez via une [passerelle LLM](/fr/llm-gateway) configurée avec `ANTHROPIC_BASE_URL`, le mode auto peut déjà être accessible sans la variable d'activation, car la passerelle achemine les demandes via l'API Anthropic. Le paramètre `disableAutoMode` s'applique de la même manière dans cette configuration.
Ce que le classificateur bloque par défaut
Le classificateur fait confiance à votre répertoire de travail et aux télécommandes configurées de votre dépôt. Tout le reste est traité comme externe jusqu'à ce que vous [configuriez l'infrastructure de confiance](/fr/auto-mode-config).
**Bloqué par défaut** :
* Téléchargement et exécution de code, comme `curl | bash`
* Envoi de données sensibles à des points de terminaison externes
* Déploiements et migrations de production
* Suppression en masse sur le stockage cloud
* Octroi de permissions IAM ou de dépôt
* Modification de l'infrastructure partagée
* Destruction irréversible de fichiers qui existaient avant la session
* Forçage ou poussée directe vers `main`
* {/* min-version: 2.1.182 */}`git reset --hard`, `git checkout -- .`, `git restore .`, `git clean -fd`, `git stash drop`, ou `git stash clear`, que le classificateur présume élimineraient les modifications non validées
* `git commit --amend` quand le commit à HEAD n'a pas été créé dans cette session
* `terraform destroy`, `pulumi destroy`, `cdk destroy`, ou `terragrunt destroy`, et l'application d'un plan qui détruit les ressources
**Autorisé par défaut** :
* Opérations de fichiers locaux dans votre répertoire de travail
* Installation de dépendances déclarées dans vos fichiers de verrouillage ou manifestes
* Lecture de `.env` et envoi des identifiants à leur API correspondante
* Demandes HTTP en lecture seule
* Poussée vers la branche sur laquelle vous avez commencé ou celle créée par Claude
Les demandes d'accès réseau sandbox sont acheminées via le classificateur plutôt que d'être autorisées par défaut. Exécutez `claude auto-mode defaults` pour voir les listes de règles complètes. Si les actions courantes sont bloquées, un administrateur peut ajouter des dépôts de confiance, des compartiments et des services via le paramètre `autoMode.environment` : consultez [Configurer le mode auto](/fr/auto-mode-config).
Limites que vous énoncez dans la conversation
Le classificateur traite les limites que vous énoncez dans la conversation comme un signal de blocage. Si vous dites à Claude « ne pousse pas » ou « attends que j'examine avant de déployer », le classificateur bloque les actions correspondantes même quand les règles par défaut les autoriseraient. Une limite reste en vigueur jusqu'à ce que vous la leviez dans un message ultérieur. Le propre jugement de Claude qu'une condition a été remplie ne la lève pas.
Les limites ne sont pas stockées comme des règles. Le classificateur les relit à partir de la transcription à chaque vérification, donc une limite peut être perdue si la [compaction de contexte](/fr/costs#reduce-token-usage) supprime le message qui l'a énoncée. Pour une garantie absolue, ajoutez une [règle de refus](/fr/permissions#permission-rule-syntax) à la place.
Quand le mode auto revient en arrière
Chaque action refusée affiche une notification et apparaît dans `/permissions` sous l'onglet Récemment refusé, où vous pouvez appuyer sur `r` pour la réessayer avec une approbation manuelle.
Si le classificateur bloque une action 3 fois de suite ou 20 fois au total, le mode auto s'interrompt et Claude Code reprend l'invite. Approuver l'action invitée reprend le mode auto. Ces seuils ne sont pas configurables. Toute action autorisée réinitialise le compteur consécutif, tandis que le compteur total persiste pour la session et ne se réinitialise que quand sa propre limite déclenche un retour en arrière.
En [mode non-interactif](/fr/headless) avec le drapeau `-p`, les blocages répétés abandonnent la session puisqu'il n'y a pas d'utilisateur pour inviter.
Les blocages répétés signifient généralement que le classificateur manque de contexte sur votre infrastructure. Utilisez `/feedback` pour signaler les faux positifs, ou demandez à un administrateur de [configurer l'infrastructure de confiance](/fr/auto-mode-config).
Chaque action passe par un ordre de décision fixe. La première étape correspondante gagne :
1. Les actions correspondant à vos [règles d'autorisation ou de refus](/fr/permissions#manage-permissions) se résolvent immédiatement, sauf les écritures dans les [chemins protégés](#protected-paths), qui sont acheminées vers le classificateur même quand une règle d'autorisation correspond
2. Les actions en lecture seule et les modifications de fichiers dans votre répertoire de travail sont auto-approuvées, sauf les écritures dans les [chemins protégés](#protected-paths)
3. Tout le reste va au classificateur
4. Si le classificateur bloque, Claude reçoit la raison et essaie une alternative
En entrant en mode auto, les règles d'autorisation larges qui accordent l'exécution de code arbitraire sont supprimées :
* `Bash(*)` sans restriction
* Interpréteurs avec caractères génériques comme `Bash(python*)`
* Commandes d'exécution du gestionnaire de paquets
* Règles `Agent`
Les règles étroites comme `Bash(npm test)` sont conservées. Les règles supprimées sont restaurées quand vous quittez le mode auto.
Le classificateur voit les messages utilisateur, les appels d'outils et votre contenu CLAUDE.md. Les résultats des outils sont supprimés, donc le contenu hostile dans un fichier ou une page web ne peut pas le manipuler directement. Une sonde côté serveur séparée analyse les résultats des outils entrants et signale le contenu suspect avant que Claude ne le lise. Pour plus d'informations sur la façon dont ces couches fonctionnent ensemble, consultez l'[annonce du mode auto](https://claude.com/blog/auto-mode) et l'[analyse technique approfondie](https://www.anthropic.com/engineering/claude-code-auto-mode).
Le classificateur vérifie le travail des [sous-agents](/fr/sub-agents) à trois points :
1. Avant qu'un sous-agent ne démarre, la description de la tâche déléguée est évaluée, donc une tâche qui semble dangereuse est bloquée au moment du lancement.
2. Pendant que le sous-agent s'exécute, chacune de ses actions passe par le classificateur avec les mêmes règles que la session parent, et tout `permissionMode` dans le frontmatter du sous-agent est ignoré.
3. Quand le sous-agent se termine, le classificateur examine son historique d'action complet ; si cette vérification de retour signale une préoccupation, un avertissement de sécurité est ajouté aux résultats du sous-agent.
L'étape 1 nécessite Claude Code v2.1.178 ou ultérieur. Les versions antérieures appliquaient le classificateur aux étapes 2 et 3, mais n'évaluaient pas la description de la tâche avant le démarrage du sous-agent.
Le classificateur s'exécute sur un modèle configuré par le serveur qui est indépendant de votre sélection `/model`, donc changer de modèle ne change pas la disponibilité du classificateur. Les appels du classificateur comptent dans votre utilisation de jetons. Chaque vérification envoie une partie de la transcription plus l'action en attente, ajoutant un aller-retour avant l'exécution. Les lectures et les modifications de répertoire de travail en dehors des chemins protégés ignorent le classificateur, donc la surcharge provient principalement des commandes shell et des opérations réseau.
Le mode `dontAsk` refuse automatiquement chaque appel d'outil qui inviterait autrement. Seules les actions correspondant à vos règles `permissions.allow` et les [commandes Bash en lecture seule](/fr/permissions#read-only-commands) peuvent s'exécuter ; les règles [`ask` explicites](/fr/permissions#manage-permissions) sont refusées plutôt que d'inviter. Cela rend le mode entièrement non-interactif pour les pipelines CI ou les environnements restreints où vous prédéfinissez exactement ce que Claude peut faire. Les sessions cloud sur [Claude Code sur le web](/fr/claude-code-on-the-web) ignorent `defaultMode: "dontAsk"` ; consultez [bypassPermissions](#skip-all-checks-with-bypasspermissions-mode) pour plus de détails.
Définissez-le au démarrage avec le drapeau :
```bash theme={null}
claude --permission-mode dontAsk
```
Ignorer toutes les vérifications avec le mode bypassPermissions
Le mode `bypassPermissions` désactive les invites de permission et les vérifications de sécurité pour que les appels d'outils s'exécutent immédiatement. À partir de la v2.1.126, cela inclut les écritures dans les [chemins protégés](#protected-paths), que les versions antérieures invitaient toujours. Les [règles ask](/fr/permissions#manage-permissions) explicites forcent toujours une invite dans ce mode, et les suppressions ciblant la racine du système de fichiers ou le répertoire personnel, telles que `rm -rf /` et `rm -rf ~`, invitent toujours comme disjoncteur contre les erreurs du modèle. Utilisez ce mode uniquement dans les environnements isolés comme les conteneurs, les machines virtuelles ou les devcontainers sans accès à Internet, où Claude Code ne peut pas endommager votre système hôte.
Vous ne pouvez pas entrer `bypassPermissions` à partir d'une session qui a été démarrée sans l'un des drapeaux d'activation ; redémarrez avec l'un pour l'activer :
```bash theme={null}
claude --permission-mode bypassPermissions
```
Le drapeau `--dangerously-skip-permissions` est équivalent.
Sur Linux et macOS, Claude Code refuse de démarrer dans ce mode lors de l'exécution en tant que root ou sous `sudo` :
```text theme={null}
--dangerously-skip-permissions cannot be used with root/sudo privileges for security reasons
```
La vérification est ignorée automatiquement à l'intérieur d'un sandbox reconnu. Pour fonctionner de manière autonome dans un conteneur, utilisez la configuration du [devcontainer](/fr/devcontainer), qui exécute Claude Code en tant qu'utilisateur non-root.
[Claude Code sur le web](/fr/claude-code-on-the-web) n'honore pas `defaultMode: "bypassPermissions"` ou `"dontAsk"` à partir de vos fichiers de paramètres, donc les paramètres archivés d'un référentiel ne peuvent pas démarrer une session cloud en mode bypass-permissions. Le paramètre est ignoré silencieusement et la session démarre dans le mode affiché dans la liste déroulante de mode à la place. Consultez [Changer les modes de permission](#switch-permission-modes) pour connaître les modes que les sessions cloud proposent.
`bypassPermissions` n'offre aucune protection contre l'injection d'invite ou les actions involontaires. Pour les vérifications de sécurité en arrière-plan avec beaucoup moins d'invites, utilisez le [mode auto](#eliminate-prompts-with-auto-mode) à la place. Les administrateurs peuvent bloquer ce mode en définissant `permissions.disableBypassPermissionsMode` sur `"disable"` dans les [paramètres gérés](/fr/permissions#managed-settings).
Chemins protégés
Les écritures dans un petit ensemble de chemins ne sont jamais auto-approuvées, dans tous les modes sauf `bypassPermissions`. Cela empêche la corruption accidentelle de l'état du dépôt et de la configuration propre de Claude.
| Mode | Écritures de chemins protégés |
| :------------------------------- | :-------------------------------- |
| `default`, `acceptEdits`, `plan` | Invitées |
| `auto` | Acheminées vers le classificateur |
| `dontAsk` | Refusées |
| `bypassPermissions` | Autorisées |
Les règles [`permissions.allow`](/fr/permissions#manage-permissions) dans les fichiers de paramètres ne pré-approuvent pas les écritures de chemins protégés. La vérification de sécurité s'exécute avant que Claude Code n'évalue les règles allow des paramètres, donc une entrée telle que `Edit(.claude/**)` dans `~/.claude/settings.json` ou `.claude/settings.json` ne change pas le résultat par mode dans le tableau ci-dessus. Dans les modes qui invitent, l'invite pour une écriture `.claude/` offre **Oui, et autoriser Claude à modifier ses propres paramètres pour cette session**, ce qui approuve les écritures `.claude/` ultérieures dans cette session sans inviter à nouveau.
Répertoires protégés :
* `.git`
* `.config/git`
* `.vscode`
* `.idea`
* `.husky`
* `.cargo`
* `.devcontainer`
* `.yarn`
* `.mvn`
* `.claude`, sauf pour `.claude/worktrees` où Claude stocke ses propres git worktrees
Fichiers protégés :
* `.gitconfig`, `.gitmodules`
* `.bashrc`, `.bash_profile`, `.bash_login`, `.bash_aliases`, `.bash_logout`, `.zshrc`, `.zprofile`, `.zshenv`, `.zlogin`, `.zlogout`, `.profile`, `.envrc`
* `.npmrc`, `.yarnrc`, `.yarnrc.yml`, `.pnp.cjs`, `.pnp.loader.mjs`, `.pnpmfile.cjs`, `bunfig.toml`, `.bunfig.toml`
* `.bazelrc`, `.bazelversion`, `.bazeliskrc`
* `.pre-commit-config.yaml`, `lefthook.yml`, `lefthook.yaml`, `.lefthook.yml`, `.lefthook.yaml`
* `gradle-wrapper.properties`, `maven-wrapper.properties`
* `.devcontainer.json`
* `.ripgreprc`, `pyrightconfig.json`
* `.mcp.json`, `.claude.json`
Voir aussi
* [Permissions](/fr/permissions) : règles d'autorisation, de demande et de refus ; politiques gérées
* [Configurer le mode auto](/fr/auto-mode-config) : indiquez au classificateur quelle infrastructure votre organisation fait confiance
* [Hooks](/fr/hooks) : logique de permission personnalisée via les hooks `PreToolUse` et `PermissionRequest`
* [Ultraplan](/fr/ultraplan) : exécutez le mode de planification dans une session Claude Code sur le web avec examen basé sur le navigateur
* [Sécurité](/fr/security) : garanties de sécurité et meilleures pratiques
* [Sandboxing](/fr/sandboxing) : isolation du système de fichiers et du réseau pour les commandes Bash
* [Mode non-interactif](/fr/headless) : exécutez Claude Code avec le drapeau `-p`