{"meta":{"title":"Référence de commande CLI pour GitHub Copilot","intro":"Recherchez des commandes et des raccourcis clavier pour vous aider à utiliser Copilot CLI efficacement.","product":"GitHub Copilot","breadcrumbs":[{"href":"/fr/copilot","title":"GitHub Copilot"},{"href":"/fr/copilot/reference","title":"Informations de référence"},{"href":"/fr/copilot/reference/copilot-cli-reference","title":"Copilot CLI référence"},{"href":"/fr/copilot/reference/copilot-cli-reference/cli-command-reference","title":"Référence des commandes CLI"}],"documentType":"article"},"body":"# Référence de commande CLI pour GitHub Copilot\n\nRecherchez des commandes et des raccourcis clavier pour vous aider à utiliser Copilot CLI efficacement.\n\n## Commandes de ligne de commande\n\n| Command | Objectif |\n| -------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |\n| `copilot` | Lancez l’interface utilisateur interactive. |\n| `copilot app` | Ouvrez le GitHub Copilot app dans le répertoire actuel, directement dans une nouvelle session. Revient à ouvrir la page de téléchargement de l’application dans un navigateur si le lien profond ne peut pas être géré ou imprime l’URL à ouvrir manuellement si aucun navigateur n’est disponible. |\n| `copilot completion SHELL` | Créez un script shell adapté à l’interpréteur de commandes sélectionné afin d’activer la complétion par tabulation pour Copilot CLI. Les interpréteurs de commandes pris en charge sont `bash`, `zsh` et `fish`. Consultez la section [Utilisation de `copilot completion`](#using-copilot-completion). |\n| `copilot config [KEY] [VALUE]` | Lisez ou modifiez Copilot les paramètres à partir de la ligne de commande, en dehors d’une session interactive. Consultez la section [Utilisation de `copilot config`](#using-copilot-config). |\n| `copilot help [TOPIC]` | Affichez les informations d’aide. Les rubriques d’aide incluent : `billing`, , `config``commands`, `environment``logging``monitoring``permissions``providers`et .`sandbox` |\n| `copilot init` | Initialisez des Copilot instructions personnalisées pour ce référentiel. |\n| `copilot login [OPTION]` | Authentifiez-vous via Copilot OAuth. Voir [`copilot login` les options](#copilot-login-options). |\n| `copilot mcp` | Gérez les configurations du serveur MCP à partir de la ligne de commande. |\n| `copilot plugin` | Gérez les plug-ins et les places de marché des plug-ins, notamment la liste, l’activation, la désactivation et la désinstallation. |\n| `copilot plugins` (plural) est un alias hérité. Consultez « [Référence du plug-in CLI GitHub Copilot](/fr/copilot/reference/copilot-cli-reference/cli-plugin-reference) ». | |\n| `copilot instruction` | Lister de manière non interactive les sources d’instructions personnalisées détectées pour le répertoire de travail actuel. Consultez la section [Utilisation de `copilot instruction`](#using-copilot-instruction). |\n| `copilot lsp` | Liste non interactive des serveurs linguistiques configurés. Consultez la section [Utilisation de `copilot lsp`](#using-copilot-lsp). |\n| `copilot sandbox ca` | Gérez l’autorité de certification proxy du bac à sable en dehors d’une session interactive. Consultez la section [Utilisation de `copilot sandbox ca`](#using-copilot-sandbox-ca). |\n| `copilot skill` | Gérer les compétences de l’agent à partir de la ligne de commande (liste, ajout, suppression, activation et désactivation des compétences). Consultez [Gestion des compétences non interactives](#managing-skills-non-interactively). |\n| `copilot update` | Téléchargez et installez la dernière version. |\n| `copilot version` | Affichez les informations de version et recherchez les mises à jour. |\n| `copilot workflow run WORKFLOW-NAME` | Exécutez directement un flux de travail dynamique existant, sans envoyer d’invite de conversation. Attendez que l’exécution se termine ou s’arrête. Consultez la section [Utilisation de `copilot workflow run`](#using-copilot-workflow-run). |\n\n### Options `copilot login`\n\n| Choix | Objectif |\n| ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |\n| `--host HOST` | |\n| GitHub URL de l’hôte (valeur par défaut : `http://gfffh3e2b966b640040f3sxv6nxvvcb0nq6kxk.ffgi.yc2.bjmu.edu.cn`). Utilisez ceci pour vous authentifier auprès d'une instance GitHub Enterprise Cloud qui utilise la localisation des données (par exemple, `http://gfffhe1aff970ddc74579sxv6nxvvcb0nq6kxk.ffgi.yc2.bjmu.edu.cn`). | |\n| `--web-flow` | Forcez le flux d’authentification basé sur le navigateur (web), qui est la valeur par défaut sur un terminal local. |\n| `--device-code` | Forcez le flux de code d’appareil OAuth, qui est la valeur par défaut sur un terminal distant ou dans CI. |\n| `--with-token` | Lisez un jeton d’authentification à partir d’une entrée standard au lieu de démarrer un flux OAuth. Requête sans écho d’entrée lorsque l’entrée standard est un terminal. Conflits avec `--web-flow` et `--device-code`. |\n\nSur un terminal local ou un processus local non TTY qui peut toujours atteindre un navigateur (par exemple, un système d’exploitation de bureau ou Linux avec un signal d’affichage ou de navigateur), le mode d’authentification par défaut est un flux web basé sur un navigateur : l’interface CLI ouvre votre navigateur pour autoriser, puis capture le résultat sur un rappel de bouclage local. Sur un terminal distant (par exemple, SSH, GitHub Codespacesou un conteneur de développement) ou dans CI, l’interface CLI utilise par défaut le flux de code de l’appareil OAuth, car le navigateur ne peut généralement pas atteindre le port de bouclage. Utilisez `--web-flow` ou `--device-code` pour remplacer le flux automatiquement sélectionné.\n\nUne fois l’opération terminée, un jeton d’authentification est stocké en toute sécurité dans le magasin d’informations d’identification système. Si aucun magasin d’identifiants n’est trouvé, le jeton est stocké dans un fichier de configuration en texte brut dans `~/.copilot/` (ou dans le répertoire spécifié par `COPILOT_HOME` si défini).\n\nCopilot CLI Vous pouvez également utiliser un jeton d’authentification trouvé dans les variables d’environnement. Les éléments suivants sont vérifiés dans l’ordre de priorité : `COPILOT_GITHUB_TOKEN`, `GH_TOKEN`, `GITHUB_TOKEN`. Cette méthode convient le mieux à une utilisation sans tête, comme l’automatisation.\n\nLes types de jetons pris en charge incluent fine-grained personal access tokens (v2 PATs) avec l'autorisation « Copilot Requests », les jetons OAuth de l'application CLI Copilot et les jetons OAuth de l'application GitHub CLI (`gh`). Les classiques personal access tokens (`ghp_`) ne sont pas pris en charge.\n\n**Exemples :**\n\n```shell\n# Authenticate with github.com\ncopilot login\n\n# Authenticate with GitHub Enterprise Cloud (data residency)\ncopilot login --host http://gfffhe1aff970ddc74579sxv6nxvvcb0nq6kxk.ffgi.yc2.bjmu.edu.cn\n\n# Force the device code flow, for example on a remote terminal\ncopilot login --device-code\n\n# Force the browser (web) flow, for example on a local terminal\ncopilot login --web-flow\n\n# Read a token from standard input, bypassing the OAuth flow entirely\ncopilot login --with-token < mytoken.txt\n\n# Use a fine-grained PAT via environment variable\nCOPILOT_GITHUB_TOKEN=github_pat_... copilot\n```\n\n### Utilisation de `copilot completion`\n\nLa commande `copilot completion SHELL` génère un script pour l’interpréteur de commandes spécifié (bash, zsh ou fish).\n\nEn exécutant ce script (ou en le plaçant dans le répertoire de complétion de votre interpréteur de commandes), vous activez la complétion par tabulation dans votre terminal pour les sous-commandes `copilot`, les options de commande ainsi que les valeurs connues associées. Pour `copilot config`, la complétion couvre également la définition de clés, de valeurs booléennes et d’énumération, ainsi que les fichiers ou répertoires pour les paramètres de chemin d’accès.\n\n#### Exemples d’utilisation\n\nBash (session active uniquement) :\n\n```bash copy\nsource <(copilot completion bash)\n```\n\nBash (persistant, Linux) :\n\n```bash copy\ncopilot completion bash | sudo tee /etc/bash_completion.d/copilot\n```\n\nZsh — placez la sortie dans un répertoire inclus dans votre $fpath. Redémarrez le terminal après avoir exécuté cette commande :\n\n```shell copy\ncopilot completion zsh > \"${fpath[1]}/_copilot\"\n```\n\nPoisson:\n\n```shell copy\ncopilot completion fish > ~/.config/fish/completions/copilot.fish\n```\n\n### Gestion des plug-ins de manière non interactive\n\nPermet `copilot plugin` d’installer, de lister, de mettre à jour, d’activer, de désactiver et de désinstaller des plug-ins à partir de la ligne de commande, sans ouvrir de session interactive.\n`copilot plugins` (plural) est un alias hérité pour la même commande. Pour obtenir la référence de commande et d’option complète, consultez [Référence du plug-in CLI GitHub Copilot](/fr/copilot/reference/copilot-cli-reference/cli-plugin-reference).\n\n### Utilisation de `copilot config`\n\nExécutez `copilot config` pour lire et modifier Copilot les paramètres à partir de la ligne de commande, en dehors d’une session interactive. Il s’agit de l’équivalent non interactif de la commande à barre oblique `/settings` (ou `/config`). Pour plus d’informations sur le fichier de paramètres et ses clés, consultez [GitHub Copilot le répertoire de configuration du CLI](/fr/copilot/reference/copilot-cli-reference/cli-config-dir-reference#settingsjson).\n\n```bash\n# Print a setting\ncopilot config theme\n\n# Set a nested value (dot notation)\ncopilot config footer.showQuota off\n\n# Append an item to a list setting (added only if not already present)\ncopilot config allowedUrls github.com\n\n# Append an item that starts with a dash\ncopilot config powershellFlags -- -NoProfile\n\n# Remove a key, or one list item\ncopilot config --rm theme\ncopilot config --rm allowedUrls github.com\n\n# List settings as key=value lines, or as JSON\ncopilot config --list\ncopilot config --repo --list --json\n```\n\n| Option/Argument | Description |\n| --------------- | ---------------------------------------------------------------------------------------------------- |\n| `KEY` | Clé de paramètre en notation par points (par exemple, `footer.showQuota`). |\n| `VALUE` | Valeur à définir, ajouter ou supprimer d’une liste avec `--rm`. |\n| `--list` | Afficher les paramètres sous forme de lignes `key=value` ; est en conflit avec /`KEY``VALUE`/`--rm`. |\n| `--json` | Générez `--list` au format JSON ; `--list` nécessite `--list`. |\n| `--rm` | Supprimez la clé ou uniquement l’élément donné d’une liste ; nécessite l’utilisation de `KEY`. |\n| `--global` | Utilisez votre fichier de paramètres utilisateur par défaut ; conflits avec `--repo`/`--local`. |\n| `--repo` | Utilisez le référentiel`--global` ; en conflit avec /`--local``.github/copilot/settings.json` |\n| `--local` | Utilisez le référentiel`--global` ; en conflit avec /`--repo``.github/copilot/settings.local.json` |\n\nLes valeurs doivent correspondre au type du paramètre : `on`/`off` ou `true`/`false` pour les valeurs booléennes, un nombre pour les paramètres numériques ou un choix accepté pour les énumérations. La lecture d’une liste imprime un élément par ligne ; la lecture d’un groupe imprime JSON. Une clé non définie se termine avec l’état `1`. Les valeurs secrètes sont masquées dans la sortie.\n\nLes commandes utilisent votre fichier de paramètres utilisateur (`settings.json` dans `~/.copilot`, ou dans `$COPILOT_HOME` lorsqu’il est défini) par défaut.\n`--repo` et `--local` acceptent uniquement les paramètres qu’un référentiel peut remplacer : voir [GitHub Copilot le répertoire de configuration du CLI](/fr/copilot/reference/copilot-cli-reference/cli-config-dir-reference#repository-settings-githubcopilotsettingsjson). Exécutez `copilot help config` pour afficher les paramètres disponibles.\n\n### Utilisation de `copilot instruction`\n\nExécutez `copilot instruction list` pour répertorier de manière non interactive les sources d’instructions personnalisées découvertes pour le répertoire de travail actif. Cela remplace le `copilot plugins list --kind instruction` supprimé.\n\n```bash\ncopilot instruction list\ncopilot instruction list --json\n```\n\n| Choix | Description | |\n| ------------------------ | ------------------------------------------------------------------------------------------------------------------- | ----------------------------------------- |\n| `--json` | Émettre JSON au lieu du texte. | |\n| `--config-dir=DIRECTORY` | Chemin d’accès au répertoire de configuration. Cette fonction est déconseillée. Utilisez `COPILOT_HOME` à la place. | |\n\nChaque `--json` entrée a la forme `{ id, label, description?, location, type, sourcePath, defaultDisabled, applyTo? }`. Cette liste résout les instructions fournies par le plug-in par rapport à vos paramètres utilisateur globaux uniquement, une instruction activée par un référentiel approuvé ou par des paramètres gérés peut ne pas apparaître ici même si une session en direct l’applique.\n\n### Utilisation de `copilot lsp`\n\nExécutez `copilot lsp list` pour lister de manière non interactive les serveurs de langage configurés. Cela remplace le `copilot plugins list --kind lsp` supprimé. Cette commande sert uniquement à l’inspection ; utilisez la commande slash `/lsp` dans une session interactive pour démarrer, arrêter ou recharger un serveur de langage.\n\n```bash\ncopilot lsp list\ncopilot lsp list --json\n```\n\n| Choix | Description | |\n| ------------------------ | ------------------------------------------------------------------------------------------------------------------- | ----------------------------------------- |\n| `--json` | Émettre JSON au lieu du texte. | |\n| `--config-dir=DIRECTORY` | Chemin d’accès au répertoire de configuration. Cette fonction est déconseillée. Utilisez `COPILOT_HOME` à la place. | |\n\nChaque `--json` entrée a la forme `{ id, fileExtensions?, sourcePlugin? }`.\n\nLes agents personnalisés et les hooks étendus à la session ne sont pas couverts par `copilot instruction`, `copilot lsp`, `copilot plugin`, `copilot mcp`ou `copilot skill`. Toutes nécessitent une session en direct.\n\n### Utilisation de `copilot workflow run`\n\nExécutez un flux de travail dynamique fourni par une extension, sans ouvrir de session interactive :\n\n```shell copy\ncopilot workflow run WORKFLOW-NAME [OPTIONS]\n```\n\n`WORKFLOW-NAME` est le nom inscrit par l’extension, et non un chemin d’accès à un fichier d’extension. La commande démarre une exécution et attend qu’elle se termine, se mette en pause ou s’arrête.\n\n| Choix | Description |\n| ------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |\n| `--args JSON` ou `--args @PATH` | Fournissez les données d’entrée du flux de travail. Remplacez « JSON » ici par JSON inline, ou remplacez « PATH » par le chemin d’accès à un fichier JSON UTF-8. La valeur par défaut est `{}` lorsqu’elle est omise. Les entrées acceptées dépendent du flux de travail. |\n| `--result-file PATH` | Écrivez la valeur retournée en tant que JSON dans un fichier au lieu de l’inclure dans la sortie standard. Écrit uniquement lorsque le flux de travail se termine et retourne un résultat. Un fichier existant est remplacé uniquement une fois que le nouveau résultat a été écrit avec succès. |\n| `-s`, `--silent` | Masquer l’affichage de progression. Le résultat final est quand même émis, sauf s’il est dirigé vers un fichier. Les diagnostics d’erreur et d’état peuvent toujours apparaître sur la sortie d’erreur standard. |\n| `--output-format FORMAT` | Définissez le format de sortie standard sur `text` (par défaut) ou `json` (JSONL, un enregistrement JSON par ligne). Combinez `json` avec `--silent` pour recevoir uniquement l’enregistrement de flux de travail final. Ne modifie pas le format JSON de `--result-file`. |\n\nLes chemins de fichier d’argument et de fichier de résultats relatifs sont résolus à partir du répertoire de travail. Sans `--silent`, la sortie inclut des phases et des messages de progression signalés par le flux de travail.\n\nLa commande utilise les paramètres d’authentification, de modèle, d’autorisations et de bac à sable de l’interface CLI. Options d’autorisation telles que `--allow-tool` et `--allow-url` s’appliquent aux agents du flux de travail. Il n’affiche pas les invites d’approbation d’autorisation.\n\nLes options d’invite et de mode session ne peuvent pas être combinées avec cette commande. Exemples : `-p`, `--agent`, `-i`, `--fleet`, `--autopilot`, `--resume` et `--continue`. L’entrée standard redirigée n’est pas utilisée comme invite de commande ou comme arguments de flux de travail.\n\nPour plus d’informations, consultez « [Utilisation de flux de travail dynamiques](/fr/copilot/how-tos/use-copilot-agents/use-dynamic-workflows#running-a-dynamic-workflow-from-the-command-line) » et « [référence programmatique du CLI GitHub Copilot](/fr/copilot/reference/copilot-cli-reference/cli-programmatic-reference#running-dynamic-workflows) ».\n\n### Utilisation de `copilot sandbox ca`\n\nExécutez `copilot sandbox ca` pour gérer l’autorité de certification proxy du sandbox en dehors d’une session interactive, par exemple lors de l’approvisionnement d’appareils gérés sans TTY. Cela met en miroir les `/sandbox ca` commandes de barre oblique (`create`, `trust`, `rotate`, `remove`), ainsi qu’une `status` vérification.\n\n```bash\ncopilot sandbox ca status\ncopilot sandbox ca create\ncopilot sandbox ca trust\ncopilot sandbox ca rotate\ncopilot sandbox ca remove\n```\n\n| Sous-commande | Description |\n| ----------------------------------- | ------------------------------------------------------------------------------------------------------------------ |\n| `copilot sandbox ca status` | Indiquer l’état de confiance sans rien modifier. |\n| `copilot sandbox ca create` | Créez l’autorité de certification si nécessaire, sans lui faire confiance. |\n| `copilot sandbox ca trust [CA.PEM]` | Ajoutez l’autorité de certification (par défaut : votre propre) au magasin de confiance du système d’exploitation. |\n| `copilot sandbox ca rotate` | Remplacez l’autorité, en conservant son état de confiance actuel. |\n| `copilot sandbox ca remove` | Supprimez la confiance du système d’exploitation ; le chemin basé sur le bundle continue de fonctionner. |\n\nExécutez ces commandes avec le compte utilisateur qui exécute Copilot CLI, sans élévation de privilèges, et non en tant que `SYSTEM` ou `root`, car l’autorité de certification est stockée dans le répertoire personnel de cet utilisateur Copilot CLI. Exécutez `copilot sandbox ca trust --help` pour obtenir des instructions d’installation sans assistance.\n`--config-dir` (ou `COPILOT_HOME`) cible un répertoire personnel Copilot CLI non par défaut pour ces commandes, identique au reste de l’interface CLI.\n\n## Barre latérale des sessions\n\nLa barre latérale des sessions est un panneau ancré à côté de votre conversation actuelle qui offre un moyen rapide d’utiliser vos sessions locales GitHub Copilot CLI .\n\nLorsque la barre latérale a le focus, les raccourcis clavier suivants sont disponibles.\n\n| Shortcut | Objectif |\n| -------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |\n| ← | Depuis la conversation, ouvrez la barre latérale et placez le focus dans celle-ci (Vim : `h`). |\n| → | Revenez au focus sur la conversation ; appuyez de nouveau pour fermer la barre latérale (Vim : `l`). |\n| ↑/↓ | Passer d’une session à l’autre dans la barre latérale (également `k`/`j`). |\n| Saisissez | Ouvrez la session sélectionnée et revenez au focus sur la conversation. |\n| `n` | Démarrez une nouvelle session. |\n| `x` deux fois | Fermez la session sélectionnée. |\n| ↑ puis Tab | En haut de la liste des sessions, ↑ se déplace sur les boutons d’en-tête (**←** fermer la barre latérale, **+** nouvelle session). Tab permet de passer de l’un à l’autre. |\n| `?` | Afficher l’aide de la barre latérale. |\n\nLa barre latérale répond également à la souris.\n\n| Geste | Objectif |\n| ------------------------------------------------------------------------ | ---------------------------------------------------------------- |\n| Cliquez sur une session | Basculez vers cette session et revenez à la conversation. |\n| Double-cliquez sur une session | Basculez vers cette session et restez dans la barre latérale. |\n| Faites glisser le séparateur | Redimensionnez la barre latérale. |\n| Pointez sur la barre latérale et faites défiler | Faites défiler la liste des sessions. |\n| Cliquez sur un bouton d’en-tête | |\n| **←** fermer la barre **+** latérale pour démarrer une nouvelle session. | |\n| Survolez le côté droit d’une session | Afficher le bouton fermer (nécessite `sidebar.showCloseButton`). |\n\n### Indicateurs d’état de session\n\nChaque session de la barre latérale affiche un indicateur de son état actuel.\n\n| Indicateur | Meaning |\n| ----------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------- |\n| Vert `●` (stable) | La session est inactive. Il attend votre prochaine invite. |\n| Violet `●` (clignotant) | Un tour est en vol. L’agent travaille activement. |\n| Bleu `●` (stable) | L’agent a terminé un tour pendant que vous étiez dans une autre session, et vous ne l’avez pas ouvert depuis. L’ouverture de la session supprime l’état « non lu ». |\n| Jaune `●` (stable) | L’agent s’est arrêté à la suite d’une erreur, ou nécessite votre attention. |\n| Gris `○` (fixe) | Une session pouvant être reprise. Il est enregistré, mais n’est pas actuellement en cours d’exécution. |\n| Jaune `!` | La session a besoin d’une autorisation pour continuer. |\n| Jaune `?` | La session vous attend pour répondre à une question ou faire un choix. |\n\nLes noms de couleurs ci-dessus sont un guide. Les nuances exactes dépendent du jeu de couleurs de votre terminal et du thème avec lequel `/theme`vous avez défini . Par exemple, le `github` thème utilise ses propres couleurs fixes, et le `colorblind` thème utilise le bleu et le jaune à la place du vert et du rouge. Sur les terminaux sans prise en charge de couleur complète, les points utilisent les propres couleurs vertes, bleues et jaunes de votre terminal.\n\nLes couleurs nommées ci-dessus sont liées au mode de conversation par défaut. Le mode plan et le mode Autopilot teintent certains points différemment. La couleur de texte du nom de session change également dans ces modes. Comme la couleur peut varier selon votre terminal, votre thème et le mode, la forme fixe ou pulsante ainsi que les marqueurs `○`, `!` et `?` constituent les indices les plus fiables.\n\n### Paramètres de la barre latérale des sessions\n\nUtilisez la `/settings sidebar` commande barre oblique dans une session CLI interactive pour ajuster ces paramètres pour la barre latérale des sessions.\n\n\n\n\n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n \n
SettingDescriptionPar défaut
sidebar.enabledAutoriser l’affichage de la barre latérale des sessions.Activé
sidebar.showResumableSessionsLa barre latérale inclut les sessions précédentes que vous pouvez reprendre. Lorsque cette option est définie sur off, seules les sessions actives sont répertoriées. Les modifications apportées à ce paramètre prennent effet la prochaine fois Copilot CLI que vous démarrez.Activé
sidebar.showHeaderButtonsAfficher la ligne de boutons en haut de la barre latérale pour la réduire (←) et démarrer une nouvelle session (+).Activé
sidebar.showCloseButtonEn guise d’alternative au fait de cliquer sur X, pointer la souris vers la droite d’une session dans la barre latérale affiche un bouton fermer la session . Cliquez dessus, puis cliquez à nouveau pour confirmer. La session est définitivement supprimée, qu’elle soit toujours en cours d’exécution ou non. Vous ne pourrez pas reprendre une session qui a été supprimée de cette façon.Désactivé
sidebar.hoverFocusLe focus passe de l’onglet CLI principal à la barre latérale en fonction de l’emplacement où se trouve le pointeur de la souris.Désactivé
sidebar.coloredHintsLorsque la barre latérale est ouverte et que votre conversation est sélectionnée, affichez l’astuce utiliser la barre latérale dans la couleur d’accentuation de la barre latérale afin d’attirer l’attention dessus. En cas de désactivation, la même couleur que d’autres indicateurs est utilisée. Pendant que la barre latérale est fermée, la même couleur que d’autres indicateurs est toujours utilisée.Activé
sidebar.accentActiveSessionModifiez la mise en surbrillance de la session sélectionnée dans la barre latérale. Une fois activé, la session actuellement ouverte dans votre conversation obtient la mise en surbrillance principale. Lorsque cette option est désactivée, la session sélectionnée à l’aide des flèches haut et bas du clavier (ou de la souris) reçoit la mise en surbrillance principale.Activé
\n\nPour plus d’informations sur la barre latérale des sessions, consultez [Utilisation de plusieurs GitHub Copilot CLI sessions](/fr/copilot/how-tos/copilot-cli/use-copilot-cli/work-with-multiple-sessions).\n\n## Raccourcis globaux dans l’interface interactive\n\n| Shortcut | Objectif |\n| -------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |\n| `@ FILENAME` | Incluez le contenu du fichier dans le contexte. |\n| `# NUMBER` | Incluez un problème ou une pull request GitHub dans le contexte. |\n| `! COMMAND` | Exécutez une commande dans votre interpréteur de commandes local, en contournant Copilot. Saisissez uniquement `!` à une invite vide pour passer en mode shell afin d’exécuter plusieurs commandes shell successivement. Appuyez sur Échap ou Ctrl+C lorsque l’invite est vide pour quitter le mode shell. |\n| `$` | Tapez un seul `$` à l'invite et appuyez sur Entrée pour remettre le terminal à un interpréteur de commandes interactif réel (`$SHELL`sur Unix, `%COMSPEC%` sur Windows) rooté dans le répertoire de travail de la session. Contrairement au mode shell `!`, cela suspend complètement l’interface de la CLI, de sorte que la gestion des tâches, les applications en plein écran, l’autocomplétion par tabulation et les couleurs fonctionnent nativement. Quittez l’interpréteur de commandes (`exit`ou Ctrl+D sur Unix) pour revenir à l’interface CLI. S’active uniquement pour une session locale, approuvée et inactive sur un TTY réel. Peut être désactivé dans les paramètres gérés par l’entreprise. Option activée par défaut. Désactivez-le avec le `shellShortcut` paramètre : consultez [GitHub Copilot le répertoire de configuration du CLI](/fr/copilot/reference/copilot-cli-reference/cli-config-dir-reference#configuration-file-settings). |\n| `?` | Ouvrez l’aide rapide (dans une invite vide). Appuyez à nouveau pour fermer et insérer le caractère littéral `?`. |\n| Échap | Annulez l’opération actuelle. Appuyez deux fois pour interrompre le tour en cours d’exécution ou pour arrêter les agents d’arrière-plan lorsque l’agent principal est inactif. Dans une session locale, si le modèle n’a pas encore commencé à répondre, le deuxième appui réaffiche votre requête dans la zone de saisie afin que vous puissiez la modifier. |\n| Ctrl+C | Annuler l’opération / effacer la saisie. Appuyez deux fois pour quitter. |\n| Ctrl+D | Arrêt. |\n| Ctrl+G | Modifiez l’invite dans un éditeur externe (`$EDITOR`). |\n| Ctrl+L | Effacez l’écran. |\n| Ctrl+Entrée ou Ctrl+Q | Mettre en file d’attente un message à envoyer pendant que l’agent est occupé. |\n| Ctrl+R | Recherche inversée par le biais de l’historique des commandes. |\n| Ctrl+Espace | Activer ou désactiver la dictée vocale (alias pour Ctrl+X , puis `v`). Cela ne fonctionne que si votre terminal et votre système d’exploitation le prennent en charge. Vous devrez peut-être libérer cela dans vos liaisons de clé de système d’exploitation ou de terminal. Utilisez Ensuite Ctrl+X`v` comme alternative. |\n| Ctrl+V | Collez le contenu du Presse-papiers en tant que pièce jointe. |\n| Alt+V | Collez l’image à partir du presse-papiers en tant que pièce jointe. |\n| Ctrl+X puis `/` | Après avoir commencé à saisir un prompt, cela vous permet d’exécuter une commande slash. Par exemple, si vous souhaitez modifier le modèle sans avoir à retaper votre prompt. |\n| Ctrl+X puis `e` | Modifiez l’invite dans un éditeur externe (`$EDITOR`). |\n| Ctrl+X puis `b` | Passez la tâche ou la commande shell en cours d’exécution en arrière-plan. |\n| Ctrl+X puis `g` | Réduire ou développer le panneau des objectifs du pilote automatique. |\n| Ctrl+X puis `h` | Masquer la barre latérale de la session en cours. |\n| Ctrl+X puis `o` | Ouvrez le lien le plus récent à partir de la chronologie. |\n| Ctrl+X puis `v` | Activer ou désactiver la dictée vocale. |\n| Ctrl+X puis `x` | Fermez la session en cours. |\n| Ctrl+Z | Suspendez le processus en arrière-plan (Unix). |\n| Maj+Entrée ou Option+Entrée (Mac) / Alt+Entrée (Windows/Linux) | Insérez une nouvelle ligne dans l’entrée. |\n| Maj+Tab | Alternez entre le mode standard, plan et pilote automatique. |\n\nDans les sessions locales, vous pouvez mettre en attente des requêtes, des commandes shell et des commandes slash prises en charge afin qu’elles s’exécutent dans l’ordre une fois la tâche en cours terminée. Appuyez sur Ctrl+Q pour mettre en file d’attente l’entrée actuelle pendant l’exécution de l’agent. Les entrées mises en file d’attente affichent une étiquette « en attente » et peuvent être annulées individuellement avant leur exécution.\n\nAvec un champ d’invite vide, appuyez sur ↑ pour réafficher dans le champ d’invite l’invite la plus récemment mise en file d’attente ou l’invite de pilotage, afin de la modifier avant de la renvoyer. Un indice « rappel » s’affiche à côté de la file d’attente lorsque cette option est disponible. Utilisez Ctrl+P à la place pour naviguer sans effet destructif dans l’historique des commandes soumises.\n\nDans une session locale, appuyer deux fois sur Esc pour une invite envoyée à laquelle le modèle n’a pas encore commencé à répondre replace votre invite dans le champ de saisie et la supprime de la conversation. Si le modèle a déjà commencé à répondre, le deuxième appui sur Esc interrompt alors la réponse en cours. Ensuite, avec une zone d’invite vide, le fait d’appuyer sur ↑ restaure l’invite dans la zone d’invite.\n\n## Raccourcis de chronologie dans l’interface interactive\n\n| Shortcut | Objectif |\n| -------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------- |\n| Ctrl+F | Ouvrez la recherche de chronologie. |\n| Ctrl+O | Bien qu’il n’y ait rien dans l’entrée d’invite, ceci développe les éléments récents dans Copilot la chronologie des réponses pour afficher plus de détails. |\n| Ctrl+E | Bien qu’il n’y ait rien dans l’entrée d’invite, cela étend tous les éléments de la chronologie de réponse de Copilot. |\n| Ctrl+T | Développer/réduire l’affichage du raisonnement dans les réponses. |\n| Page vers le haut/Page vers le bas | Faites défiler la chronologie vers le haut ou vers le bas d’une page. |\n\n## Raccourcis de la boîte de dialogue Tâches\n\nLorsque la boîte de dialogue tâches est ouverte (ouverte via `/tasks`) :\n\n| Shortcut | Objectif |\n| ------------------------- | ------------------------------------------------------------------------------------------------------------------------ |\n| ↑/K | Déplacer la sélection vers le haut. |\n| ↓/J | Déplacez la sélection vers le bas. |\n| Saisissez | Voir les détails de la tâche ou téléportez-vous dans la vue de la session du sous-agent sélectionné. |\n| `a` | Basculer entre l’affichage de tous les niveaux de sous-agents imbriqués et uniquement les tâches de ce niveau. |\n| `f` | Activez ou désactivez l’affichage des sous-assistants et des shells terminés, et pas uniquement de ceux qui sont actifs. |\n| X | Supprimez la tâche active sélectionnée. |\n| R | Supprimez la tâche terminée sélectionnée. |\n| B | Promouvoir la tâche de synchronisation sélectionnée en arrière-plan. |\n| Échap | Fermez la boîte de dialogue (ou revenez à la liste). |\n\nLes sous-assistants qui génèrent leurs propres sous-assistants imbriqués s’affichent sous forme d’arborescence en retrait ; la ligne vers laquelle vous êtes redirigé est mise en surbrillance et indiquée comme « actuelle ». Lorsque vous consultez la vue d’un sous-assistant, vous pouvez lui envoyer un message d’orientation depuis la zone de saisie, comme vous le feriez dans la session principale.\n\n## Restauration d’une session interrompue\n\nSi une session était toujours ouverte lorsque son processus CLI s’est absenté( par exemple, en raison d’un incident ou d’un redémarrage de l’ordinateur), le démarrage suivant `copilot` peut vous offrir de le restaurer, ce qui vous permet de choisir les sessions à ramener ou à démarrer à la place. Une session dont l’assistant était en plein traitement reprend automatiquement cette tâche une fois restaurée.\n\nCe comportement de restauration est temporairement accepté pendant que sa boîte de dialogue de démarrage est retravaillée. Définissez la variable d’environnement `COPILOT_ENABLE_INTERRUPTED_SESSION_RESTORE` sur `1` pour l’activer. Consultez [Variables d’environnement](#environment-variables).\n\n## Raccourcis du sélecteur de session\n\nLorsque le sélecteur de session est ouvert (ouvert via `/resume` ou `--continue`) :\n\n| Shortcut | Objectif |\n| ------------------------- | -------------------------------------------------------------------- |\n| ↑/↓ | Déplacez la sélection vers le haut ou vers le bas. |\n| Saisissez | Ouvrez la session sélectionnée. |\n| `s` | Cycle de l’ordre de tri : pertinence → créé → nom → dernier utilisé. |\n| Tab | Basculez entre les onglets locaux et distants. |\n| `x` | Supprimez la session sélectionnée. |\n| Échap | Fermez le sélecteur. |\n\nLes sessions sont triées selon les modes suivants :\n\n| Mode | Description |\n| ----------- | --------------------------------------------------------------------------------------------------------- |\n| `relevance` | Évalue les sessions en fonction de leur correspondance avec le répertoire de travail actuel (par défaut). |\n| `last used` | Les sessions les plus récemment modifiées en premier. |\n| `created` | Les sessions les plus récemment créées en premier. |\n| `name` | Alphabétique par nom de session ; les sessions sans nom sont triées à la fin. |\n\nLes sessions déjà ouvertes dans une autre fenêtre flottent en haut dans tous les modes de tri non pertinents. Quand aucun contexte de répertoire de travail n’est disponible, le `relevance` mode est ignoré.\n\n## Sélecteur d’environnement de pré-conversation\n\nAvant d’envoyer le premier message dans une nouvelle session, appuyez sur Ctrl+E dans une zone d’invite vide pour choisir l’emplacement d’exécution de la conversation : sur votre ordinateur local ou dans un environnement cloud. L’environnement est provisionné lorsque vous envoyez votre premier message.\n\n> \\[!NOTE]\n> Le sélecteur d’environnement nécessite que les sessions cloud soient disponibles sur votre compte — la même exigence que les options `--remote`, `--no-remote`, `--no-remote-export`, `--remote-export` et `--connect`. Consultez [les options de ligne de commande](#command-line-options).\n\nUne fois qu’une conversation a démarré, Ctrl+E revient à ses autres comportements : déplacement du curseur vers la fin de la ligne lors de la saisie ou développe tous les éléments de la chronologie dans une zone d’invite vide. Consultez [les raccourcis de navigation dans l’interface interactive](#navigation-shortcuts-in-the-interactive-interface) et [les raccourcis chronologie dans l’interface interactive](#timeline-shortcuts-in-the-interactive-interface).\n\n## Raccourcis de la barre latérale et de l’onglet Sessions\n\nLa barre latérale de session active vous permet de parcourir et de basculer entre les sessions sans quitter celle dans laquelle vous êtes. Avec une zone d’invite vide, ←/→ parcourez un cycle de focus à trois états : fermé, centré sur la chronologie et axé sur la barre latérale. Désactivez entièrement la barre latérale avec le `sidebar` paramètre : consultez [GitHub Copilot le répertoire de configuration du CLI](/fr/copilot/reference/copilot-cli-reference/cli-config-dir-reference#configuration-file-settings).\n\n| Shortcut | Objectif |\n| ----------------------------------------------------- | -------------------------------------------------------------------------------------------------------------- |\n| ← (onglet actif, fermé) | Ouvrez la barre latérale ; la chronologie conserve le focus. |\n| ← (axé sur la chronologie) | Déplacez le focus dans la barre latérale. |\n| → (axé sur la barre latérale) | Retournez le focus sur la chronologie. |\n| → (axé sur la chronologie) | Fermez la barre latérale. |\n| Tab/Maj+Tab | Passez d’un onglet à l’autre (**En cours**, **Sessions**, etc.). |\n| ↑/↓ (axé sur la barre latérale) | Déplacez le curseur de sélection ; `j`/`k` sont des alias. |\n| Entrée (barre latérale sélectionnée) | Basculez la session de premier plan vers la carte sélectionnée. |\n| `n` (axé sur la barre latérale) | Générez une nouvelle session d’arrière-plan et apportez-la au premier plan. |\n| `s` (axé sur la barre latérale) | Parcourir l’ordre de tri : récent → date de création → nom → aucun. |\n| `x`, `x` (axé sur la barre latérale) | Fermez la carte sélectionnée (activée pour une seule frappe au clavier, affichée en rouge avant sa fermeture). |\n\nLe séparateur de la barre latérale peut être déplacé pour le redimensionner, et il se réduit automatiquement en dessous d’une largeur minimale utilisable. Chaque carte affiche un point d’état, le nom de session et sa branche Git (ou répertoire de travail lorsqu’il n’existe aucune branche). Le titre de la session de premier plan est mis en surbrillance en couleur d’accentuation et sa carte porte un remplissage subtil persistant.\n\nLes points indiquent l’état d’une session. Pour ce que signifie chaque point, consultez [les indicateurs d’état de session](#session-status-indicators).\n\nL’ordre de tri actif (`recent`, `created`, `name` ou `none` pour l’ordre d’insertion) est conservé d’un redémarrage à l’autre.\n\nLes actions de la souris reproduisent celles du clavier : cliquez sur une carte pour passer à la session au premier plan, double-cliquez sur une carte ou sur un espace vide dans le rail pour placer le focus sur la barre latérale, puis cliquez sur le volet chronologie lorsque la barre latérale a le focus pour le lui redonner.\n\nL’onglet **Sessions** répertorie la session active ainsi que l’historique complet de votre session pouvant être reprise sous un diviseur « Pouvant être repris » :\n\n| Shortcut | Objectif |\n| ---------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |\n| ↑/↓ | Parcourez les lignes. |\n| Maj+↑/↓ | Page vers le haut ou vers le bas. |\n| Saisissez | Reprendre la session sélectionnée. |\n| `n` | Démarrez une nouvelle session. |\n| `a` | Faites défiler la portée du filtre : tout → local → distant (cloud). |\n| `/` | Recherchez en direct sur le nom, la branche ou le répertoire de travail, le référentiel et l’ID de session. |\n| `x`, `x` | Fermez ou supprimez la ligne sélectionnée (prête pour une seule frappe, affichée en rouge avant exécution) ; Ctrl+X, puis `x`, fonctionne toujours comme raccourci à deux touches. |\n| ←/→ | Passez d’un onglet à l’autre. |\n\nLes lignes distantes (dans le cloud) de l’onglet **Sessions** affichent également l’état en ligne ou hors connexion ainsi que le dépôt.\n\nAppuyer `x` deux fois sur une ligne ferme une session en cours d’exécution ou, pour une ligne pouvant être reprise localement, supprime définitivement l’historique stocké de cette session. Le fait d’appuyer sur Esc, d’appuyer sur n’importe quelle autre touche, de déplacer la surbrillance ou l’expiration du délai annule la confirmation en cours.\n\n## Raccourcis en mode diff\n\nLorsque le mode diff est ouvert (entré via `/diff`) :\n\n| Shortcut | Objectif |\n| ----------------------------------------------- | -------------------------------------------------------------------------------------------------------- |\n| ↑ / `k` | Déplacer la sélection vers le haut d’une ligne. |\n| ↓ / `j` | Déplacer la sélection vers le bas d’une ligne. |\n| ← / `h` | Accédez au fichier précédent. |\n| → / `l` | Accédez au fichier suivant. |\n| Accueil / `g` | Passez à la première ligne. |\n| Fin / `G` | Passez à la dernière ligne. |\n| Page précédente | Faites défiler vers le haut une page. |\n| Page vers le bas | Faites défiler vers le bas une page. |\n| Ctrl+U | Faites défiler la moitié d’une page vers le haut. |\n| Ctrl+D | Faites défiler vers le bas la moitié d’une page. |\n| `Click` | Sélectionnez la ligne de diff sur laquelle vous avez cliqué (nécessite la prise en charge de la souris). |\n| Faire défiler la souris | Faites défiler vers le haut ou vers le bas. |\n| Alt/Option+défilement | Faites défiler une ligne à la fois pour un contrôle affiné. |\n| `c` | Ajoutez ou modifiez un commentaire sur la ligne sélectionnée. |\n| `s` | Afficher le résumé des commentaires (quand des commentaires existent). |\n| `b` | Basculez entre les modifications non modifiées et les différences de branche. |\n| `w` | Activer/désactiver le masquage des modifications d’espace blanc uniquement. |\n| Saisissez | Envoyez tous les commentaires (quand des commentaires existent). |\n| `r` | Actualiser le diff (sessions distantes uniquement). |\n| Échap / Ctrl+C | Quittez le mode diff. |\n\n## Raccourcis de navigation dans l’interface interactive\n\n| Shortcut | Objectif |\n| ------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |\n| Ctrl+A | Passez au début de la ligne (lors de la saisie). |\n| Ctrl+B | Passez au caractère précédent. |\n| Ctrl+E | Passez à la fin de la ligne (lors de la saisie). |\n| Ctrl+F | Passez au caractère suivant. |\n| Ctrl+H | Supprimez le caractère précédent. |\n| Ctrl+K | Supprimez depuis le curseur jusqu’à la fin de la ligne. Si le curseur se trouve à la fin de la ligne, supprimez le saut de ligne. |\n| Ctrl+U | Supprimer depuis le curseur jusqu'au début de la ligne. |\n| Ctrl+W | Supprimez le mot précédent. |\n| Accueil | Passez au début de la ligne visuelle actuelle. |\n| Fin | Passez à la fin de la ligne visuelle actuelle. |\n| Ctrl+Début | Accédez au début du texte. |\n| Ctrl+Fin | Passez à la fin du texte. |\n| Alt+/←→ (Windows/Linux)
Option+←/→ (Mac) | Déplacez le curseur par un mot. |\n| ↑/↓ | Naviguez dans l’historique des commandes. Avec un champ d’invite vide, ↑ rappelle à la place l’invite mise en file d’attente ou de pilotage la plus récente, s’il y en a une. |\n| Ctrl+P | Parcourez l’historique des commandes envoyées sans l’altérer, sans déclencher le comportement de rappel de l’invite mise en file d’attente. |\n| Onglet / Ctrl+Y | Accepter la suggestion de complétion en ligne actuelle. |\n\n## Commandes slash dans l’interface interactive\n\nVoici les commandes slash que vous pouvez utiliser dans une session CLI interactive. Un sous-ensemble de ces commandes slash est disponible pour les clients qui utilisent la CLI via son serveur ACP. Pour plus d’informations, consultez « [Serveur ACP de Copilot CLI](/fr/copilot/reference/copilot-cli-reference/acp-server) ».\n\n| Command | Objectif |\n| --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |\n| `/add-dir PATH` | Autoriser l’accès aux fichiers d’un répertoire et charger ses `.github/agents` et `.github/skills` comme configurations de confiance. Lorsque le sandbox est activé, accorde également au sandbox l’accès au répertoire pour la session en cours. |\n| `/after [DELAY PROMPT]`, `/after` | Planifiez, pour la session en cours, un prompt, une compétence ou une commande slash planifiable non récurrente (par exemple, `/after 30m remind me the time` ou `/after 1h /chronicle standup`). Sans argument, le gestionnaire de planification s’affiche. Disponible uniquement en mode expérimental. |\n| `/agent` | Parcourez et sélectionnez parmi les agents disponibles (le cas échéant). Consultez « [À propos des agents personnalisés](/fr/copilot/concepts/agents/copilot-cli/about-custom-agents) ». |\n| `/app` | Ouvrez la session en cours dans GitHub Copilot app (nécessite la version 1.1.3 ou ultérieure), ou affichez l’URL de téléchargement si l’application n’est pas installée. |\n| `/ask QUESTION`, `/btw QUESTION` | Posez une question de côté rapide sans ajouter à l’historique des conversations. Consultez « [Poser une question annexe dans GitHub Copilot CLI](/fr/copilot/how-tos/copilot-cli/use-copilot-cli/ask-a-side-question) ». |\n| `/allow-all [off\\|auto\\|show]`, `/yolo [off\\|auto\\|show]` | Activez toutes les autorisations (outils, chemins et URL). Il s’agit d’un alias pour `/permissions allow-all` ; voir la ligne `/permissions` pour la commande canonique et ses sous-commandes. |\n| `/autopilot [OBJECTIVE]`, `/goal [OBJECTIVE]` | Démarrer ou recentrer le mode pilote automatique, éventuellement avec un objectif explicite (par exemple, `/goal Refactor the auth module`). Sans objectif, Autopilot déduit l’intention à partir du contexte et le panneau d’état affiche votre dernière invite comme objectif déduit. Vous pouvez limiter les dépenses de crédit IA pour l’objectif à l’aide `--max-ai-credits N` (par exemple, `/goal Refactor the auth module --max-ai-credits 5`). Lorsque la limite est atteinte, Autopilot se met en pause et ouvre un panneau indiquant les crédits utilisés au titre de cette limite. Entrez un nouveau montant pour reprendre avec une nouvelle limite de crédit, ou fermez le volet pour rester en pause. Vous pouvez également reprendre un objectif suspendu vous-même, sans le panneau, en exécutant l’option par lui-même sans texte objectif, par exemple. `/goal --max-ai-credits 5` Il s’agit de la même action que le panneau effectue : il ouvre une nouvelle fenêtre des crédits que vous spécifiez (la nouvelle limite complète, pas un incrément) et poursuit l’objectif. `/goal on` et `/goal off` activent ou désactivent le mode pilote automatique sans définir d’objectif et n’acceptent pas `--max-ai-credits`. Un objectif actif s’affiche sous la forme d’un panneau épinglé au-dessus du champ de saisie, indiquant l’objectif, les crédits utilisés et l’avancement des tâches à effectuer. Le panneau se réduit automatiquement à une seule ligne d’identité sur des terminaux courts (moins de 30 lignes) et se développe au-dessus de ce seuil ; Appuyez sur Ctrl+X pour `g` remplacer le dimensionnement automatique à la main. |\n| `/changelog [summarize] [VERSION\\|last N\\|since VERSION]`, `/release-notes [summarize] [VERSION\\|last N\\|since VERSION]` | Affichez le journal des modifications CLI. Spécifiez éventuellement une version, un nombre de versions récentes ou une version de départ. Ajoutez le mot clé `summarize` pour un résumé généré par l’IA. |\n| `/chronicle ` | Outils et analyses pour l’historique des sessions. Les sous-commandes `skills` permettent de rédiger, d’examiner et de suivre l’état des propositions de compétences du dépôt générées à partir de l’usage observé. Consultez « [Utilisation des GitHub Copilot CLI données de session](/fr/copilot/how-tos/copilot-cli/use-copilot-cli/chronicle#using-the-chronicle-slash-command) ». |\n| `/clear [PROMPT]``/new [PROMPT]``/reset [PROMPT]` | Démarrez une nouvelle conversation. `/new worktree` démarre une session vide dans une nouvelle arborescence de travail Git au lieu de l’effacer, laissant la conversation actuelle et son répertoire de travail inchangés. |\n| `/clikit [COMPONENT]` | Aperçu des composants commerciaux CLI (par exemple, informations sur le quota). |\n| `/collect-debug-logs [file\\|gist\\|share] [PATH]` | Collectez les journaux de débogage dans une archive, un GitHub gist ou chargez-les sur GitHub (`share`). Consultez [Collecte et partage des journaux de débogage](#collecting-and-sharing-debug-logs). |\n| `/compact [FOCUS-INSTRUCTIONS]` | Résumez l’historique des conversations pour réduire l’utilisation de la fenêtre de contexte. Vous pouvez éventuellement fournir des consignes d’orientation pour orienter le résumé — par exemple, `/compact focus on the auth module`. Consultez « [Gestion du contexte dans GitHub Copilot CLI](/fr/copilot/concepts/agents/copilot-cli/context-management#compaction) ». |\n| `/context` | Afficher l’utilisation et la visualisation des jetons de fenêtre de contexte. Consultez « [Gestion du contexte dans GitHub Copilot CLI](/fr/copilot/concepts/agents/copilot-cli/context-management#checking-your-context-usage) ». |\n| `/copy` | Copiez la dernière réponse dans le presse-papiers. |\n| `/cwd`, `/cd [PATH]` | Modifiez le répertoire de travail ou affichez le répertoire actif. |\n| `/delegate [PROMPT]` | Déléguer les modifications à un référentiel distant avec une requête de tirage générée par l’IA. Consultez « [Délégation de tâches à Copilot](/fr/copilot/how-tos/copilot-cli/use-copilot-cli/delegate-tasks-to-cca) ». |\n| `/diagnose [PROMPT]`, `/diagnose` | Analysez le journal de session actuel pour les erreurs, le comportement inattendu et d’autres problèmes. Incluez éventuellement une invite personnalisée pour concentrer le diagnostic sur un problème spécifique. |\n| `/diff` | Passez en revue les modifications apportées au répertoire actif ; bascule automatiquement vers la différence de branche lorsque l’arborescence de travail est propre (expérimentale). |\n| `/downgrade VERSION` | Téléchargez et redémarrez dans une version CLI spécifique. Disponible pour les comptes d’équipe. |\n| `/env` | Afficher les détails de l’environnement chargé (instructions, serveurs MCP, compétences, agents, hooks, plug-ins, LSPs, extensions). |\n| `/every [INTERVAL] PROMPT`, `/every` | Programmez un prompt récurrent, une skill ou une commande slash planifiable pour la session en cours (par exemple, `/every 1h run tests` ou `/every 1d /chronicle standup`). Sans argument, le gestionnaire de planification s’affiche. Disponible uniquement en mode expérimental. |\n| `/exit`, `/quit` | Fermez la session en cours. Si d’autres sessions sont ouvertes, la plus récente de celles qui restent est mise au premier plan au lieu de quitter l’application. Quitte l’interface CLI uniquement quand il s’agit de la dernière session ouverte. `/exit print` supprime toujours l’interface CLI et propose de vider la transcription. `/exit` et `/quit` (y compris leur variante `print`) peuvent également être mis en attente avec Ctrl+Q pendant que l’agent est en cours d’exécution : l’interface en ligne de commande ferme la session une fois que le tour en cours, ainsi que toute commande shell mise en attente avant lui, est terminé. |\n| `/extensions [manage\\|mode]`, `/extension` | Gérer les extensions CLI. Disponible uniquement en mode expérimental. |\n| `/experimental [on\\|off\\|show]` | Basculez, définissez ou affichez des fonctionnalités expérimentales. |\n| `/feedback`, `/bug` | Fournissez des commentaires sur l’interface CLI. Peut proposer une procédure de feedback-with-logs ; consultez [Collecte et partage des journaux de débogage](#collecting-and-sharing-debug-logs). |\n| `/fleet [PROMPT]` | Activez l’exécution parallèle des sous-éléments d’une tâche. Consultez « [Accélération de l’achèvement de la tâche avec la \\`/fleet\\` commande](/fr/copilot/how-tos/copilot-cli/use-copilot-cli/speed-up-task-completion) ». |\n| `/help` | Affichez l’aide pour les commandes interactives. |\n| `/ide` | Connectez-vous à un espace de travail IDE. Consultez « [Connexion GitHub Copilot CLI à VS Code](/fr/copilot/how-tos/copilot-cli/use-copilot-cli/connecting-vs-code#managing-the-connection-with-the-ide-slash-command) ». |\n| `/init` | Initialisez des Copilot instructions personnalisées et des fonctionnalités agentiques pour ce référentiel. Consultez [l'initialisation du projet pour Copilot](#project-initialization-for-copilot). |\n| `/instructions` | Affichez et désactivez les fichiers d’instructions personnalisés. |\n| `/keep-alive [on\\|off\\|busy\\|DURATION]`, `/caffeinate [on\\|off\\|busy\\|DURATION]` | Empêchez l’ordinateur de se mettre en veille : pendant qu’une session CLI est active, pendant que l’agent est occupé ou pendant une durée définie. Accepte des durées telles que `30`, `30m`, `2h`, `1d` (les nombres seuls correspondent par défaut à des minutes). |\n| `/limits` | Ouvrez la boîte de dialogue des limites de réponse interactive. |\n| `/limits set max-ai-credits VALUE` | Définissez un maximum souple pour les crédits IA autorisés par réponse. Les limites de réponse sont des limites réversibles qui réinitialisent chaque message utilisateur. Consultez « [Définition d’une AI credit limite de session dans GitHub Copilot CLI](/fr/copilot/how-tos/copilot-cli/use-copilot-cli/set-session-limit) ». |\n| `/limits unset [max-ai-credits\\|all]` | Supprimez une limite de réponse spécifique ou toutes les limites de réponse. |\n| `/list-dirs` | Affichez tous les répertoires pour lesquels l’accès au fichier a été autorisé. |\n| `/login` | Connectez-vous à Copilot. |\n| `/logout` | Déconnectez-vous de Copilot. |\n| `/lsp [show\\|test\\|reload\\|logs\\|help] [SERVER-NAME]` | Gérez la configuration du serveur de langue. La `logs` sous-commande ouvre le panneau de journal des services LSP en direct. |\n| `/mcp [config\\|list\\|show\\|add\\|edit\\|delete\\|disable\\|enable\\|auth\\|reload\\|search] [SERVER-NAME]` | Gérez la configuration du serveur MCP. Sans sous-commande ou avec `config`, le tableau de bord des plug-ins s’ouvre épinglé à la liste des serveurs MCP ; l’ajout, la modification et l’authentification des formulaires s’ouvrent à l’intérieur de ce tableau de bord, de sorte que la fermeture d’un formulaire vous renvoie à la liste des serveurs. Utilisez `show` ou `show SERVER-NAME` affichez tous les serveurs configurés ou ouvrez directement les détails d’un serveur, y compris ses outils disponibles et pour l’activer ou le désactiver. Pour un serveur fourni par un plug-in, `show SERVER-NAME` affiche également l’attribution source (par exemple, `Source: Plugin my-plugin (1.2.0)`). |\n| `list` (alias `ls`) imprime une liste de serveurs configurés en texte brut avec l’état de connexion et l’état actif. Bare `/mcp`, `config`, `show`, et `list` (également appelé `ls`) sont en mode lecture seule ou ouvrent le tableau de bord, et peuvent donc s’exécuter pendant que l’agent est occupé à traiter une requête. Les sous-commandes mutantes (`add`, , `edit`, `delete``disable`, `auth``enable`, , `reload`et `search`) sont bloquées jusqu’à ce que le tour se termine. | |\n| `edit ` rejette un serveur provenant de l’espace de travail (défini dans le `.mcp.json` d’un dépôt) au lieu d’ouvrir l’assistant du niveau utilisateur, car l’enregistrer créerait silencieusement une entrée utilisateur du même nom, que celle de l’espace de travail continuerait à masquer. L’erreur nomme le fichier à modifier directement. | |\n| `delete ` signale le même fichier lorsqu’il est demandé de supprimer un serveur source d’espace de travail. Les serveurs locaux isolés affichent l’état `connected (sandboxed)`. Consultez « [Ajout de serveurs MCP pour GitHub Copilot CLI](/fr/copilot/how-tos/copilot-cli/customize-copilot/add-mcp-servers#managing-mcp-servers) ». | |\n| `/model [--session\\|--global\\|--repo\\|--local] [MODEL\\|auto TIER]`, `/models` | Sélectionnez le modèle IA que vous souhaitez utiliser, ou choisissez **Auto**. Les ID de modèle ne sont pas sensibles à la casse et l’ID canonique est enregistré. Par défaut (ou avec `--session`, alias `-s`), modifie le modèle, l’effort de raisonnement ou la fenêtre de contexte de la session active uniquement, sans toucher aux paramètres enregistrés. `--repo`/`--local` épingle plutôt le modèle par défaut dans les paramètres du référentiel ; `--global` (ou `/config model`) définit la valeur par défaut pour les sessions futures. Appuyez sur Tab sur un modèle avec une variante de contexte long pour activer la colonne Contexte entre la fenêtre par défaut et la fenêtre de contexte long. Le sélecteur regroupe les modèles en sections. Appuyez sur Maj+Tab pour parcourir les différents modes de regroupement : recommandations (Récent, Recommandé, Nouveau et autres modèles), fournisseur et catégorie. Un modèle avec des termes de rétention de données spécifiques au fournisseur affiche une bannière d’avertissement de rétention des données avec un lien vers la stratégie du fournisseur. Utilisable en cours de tour : une modification demandée pendant l’exécution de l’assistant est mise en file d’attente sous forme de commande annulable (Ctrl+C) et appliquée une fois le tour en cours terminé, au lieu de changer de modèle à la volée en cours de requête. Utilisez `/model auto TIER` (`efficiency`, `balance`ou `intelligence`) pour sélectionner directement un niveau de routage automatique spécifique, y compris à partir de l’action « switch » sur un indicateur de recommandation de niveau automatique. Lorsque Auto sélectionne un modèle, la chronologie affiche la raison de ce choix chaque fois que l’API en fournit une. Consultez « [À propos de Copilotauto model selection](/fr/copilot/concepts/models/auto-model-selection) ». |\n| `/permissions [default\\|assisted\\|allow-all\\|show]` | Basculer entre les modes d’autorisation (`default`, , `assisted``allow-all`) ou afficher le mode actuel (`show`). Il s’agit de la commande canonique pour les modifications du mode d’autorisation ; `/allow-all` et `/yolo` restent pris en charge en tant qu’alias. |\n| `/permissions reset` | Réinitialiser toutes les autorisations en mémoire des outils et des chemins d’accès pour la session en cours (redemander une confirmation lors de la prochaine utilisation). |\n| `/plan [PROMPT]` | Créez un plan d’implémentation avant de coder. |\n| `/plugin` | Ouvrez le tableau de bord des plug-ins montrant vos plug-ins installés. Sélectionnez un plug-in, puis appuyez sur Entrée pour obtenir ses détails et pour les actions telles que l’activation, la désactivation, la mise à jour ou la désinstallation. Utilisez les clés ← et → pour basculer entre les vues **Installée**, **En ligne** et **Marketplace** . Le tableau de bord affiche uniquement les plug-ins , à utiliser `/mcp` pour les serveurs MCP et `/skills` pour les compétences. Consultez « [À propos des GitHub Copilot plug-ins](/fr/copilot/concepts/agents/about-plugins) ». |\n| `/plugin install SOURCE` | Installez un plug-in à partir d’une spécification de marketplace, d’un référentiel GitHub, d’une URL Git ou d’un chemin local. |\n| `/plugin update PLUGIN[@MARKETPLACE]` | Mettez à jour un plug-in installé. |\n| `/plugin uninstall PLUGIN[@MARKETPLACE]` (les alias `remove`, `rm`) | Désinstallez un plug-in. |\n| `/plugin list` (alias `ls`) | Répertorier les plug-ins installés. |\n| `/plugin marketplace add SOURCE` | Ajoutez une place de marché. |\n| `/plugin marketplace remove NAME` | Supprimez une place de marché. |\n| `/plugin marketplace list` | Répertorier les places de marché inscrites. |\n| `/plugin marketplace browse NAME` | Parcourez les plug-ins dans une Place de marché. |\n| `/plugin marketplace update [NAME]` (alias `refresh`) | Récupérez à nouveau le catalogue de plug-ins d’une place de marché ou chaque place de marché inscrite lorsqu’aucun nom n’est donné. |\n| `/pr [view\\|create\\|fix\\|auto\\|automerge]` | Gérer les demandes de tirage pour la branche actuelle. |\n| `auto` dirige la demande de tirage en vert et s’arrête ; `automerge` (alias : `agentmerge`) dirige la demande de tirage en vert et la fusionne. Lorsque le dépôt dispose d’un modèle de pull request (`.github/pull_request_template.md` ou d’un fichier sous `.github/PULL_REQUEST_TEMPLATE/`), `create` le suit par défaut, en conservant les titres, les commentaires et les éléments de liste de contrôle, et en renseignant des informations précises au lieu de rédiger une description générique. Demandez à Copilot de passer le modèle si vous ne souhaitez pas l’appliquer. Consultez « [Gestion des pull requests avec la commande /pr](/fr/copilot/how-tos/copilot-cli/use-copilot-cli/manage-pull-requests) ». | |\n| `/refine TEXT` | Réécrire un prompt rédigé de manière approximative en un prompt clair pour examen. Exécutez sans argument (via Ctrl+X puis `/refine`) pour nettoyer la zone d’entrée actuelle. Peut être particulièrement utile pour les requêtes saisies oralement. |\n| `/remote [on\\|off]` | Affichez l’état du contrôle à distance (si aucun argument n’est fourni), activez la direction à distance (`on`) ou terminez la connexion à distance (`off`). Consultez « [Direction d’une session à partir d’un GitHub Copilot CLI autre appareil](/fr/copilot/how-tos/copilot-cli/use-copilot-cli/steer-remotely) ». |\n| `/rename [NAME]` | Renommez la session active (génère automatiquement un nom s’il est omis ; alias pour `/session rename`). |\n| `/research TOPIC` | Effectuez une investigation approfondie en utilisant GitHub des sources de recherche et web. Consultez « [Recherche avec GitHub Copilot CLI](/fr/copilot/how-tos/copilot-cli/use-copilot-cli/research-with-copilot-cli) ». |\n| `/reset-allowed-tools` | Réinitialisez la liste des outils autorisés. |\n| `/restart` | Redémarrez le CLI en restaurant toutes les sessions actives du processus actuel, et pas seulement celle au premier plan. Si la version de l’interface CLI cible ne peut pas restaurer plusieurs sessions, vous êtes invité à continuer uniquement avec la session de premier plan ou l’annulation. |\n| `/resume [SESSION-ID]`, `/continue [SESSION-ID]` | Basculez vers une autre session en choisissant dans une liste (spécifiez éventuellement un ID de session). |\n| `/review [PROMPT]` | Exécutez l’agent de révision de code pour analyser les modifications. Consultez « [Demande d’une révision de code avec GitHub Copilot CLI](/fr/copilot/how-tos/copilot-cli/use-copilot-cli/agentic-code-review) ». |\n| `/rubber-duck [PROMPT]` | Consultez l’agent « rubber duck » pour obtenir un deuxième avis sur les plans, le code et les tests. Consultez « [Obtenir un deuxième avis avec l’agent Rubber Duck](/fr/copilot/concepts/agent-capabilities/choosing-and-delegating-agent-work/getting-a-second-opinion) ». |\n| `/sandbox [config\\|status\\|policy [COMMAND]\\|enable\\|disable]` | Gérer les restrictions du sandbox sur le système de fichiers et l’accès réseau. |\n| `config` (ou simplement `/sandbox`) ouvre la boîte de dialogue paramètres, qui suggère des secrets d’environnement possibles et vous permet d’ajouter des hôtes de masquage avant d’enregistrer. | |\n| `status` indique si le bac à sable est activé pour la session active. Lorsque le sandbox est activé, `policy` affiche les autorisations et restrictions de chemin d’accès regroupées par type de source et d’accès, paramètres réseau, accès aux outils de développement et fonctionnalités de sandbox. Ajoutez éventuellement une commande, par exemple `/sandbox policy npm install`, pour inspecter son accès à l’outil développeur sans l’exécuter. | |\n| `enable` et `disable` mettent normalement à jour votre paramètre enregistré. Si votre organisation a besoin d’un bac à sable (`disable` sandbox), `disable` est refusé, sauf si le contournement est autorisé. Dans ce cas, la désactivation s’applique uniquement à la session active. | |\n| `/sandbox ca [create\\|trust\\|rotate\\|remove]` | Gérez l’autorité de certification du proxy du sandbox. |\n| `create` l’écrit sans lui faire confiance. | |\n| `trust` l’ajoute à la liste de confiance du système d’exploitation. | |\n| `rotate` le remplace tout en préservant son état de confiance. | |\n| `remove` perd la confiance du système d’exploitation. Consultez [l’utilisation de `copilot sandbox ca`](#using-copilot-sandbox-ca) pour exécuter les mêmes opérations en dehors d’une session, par exemple sur des appareils gérés. | |\n| `/search [QUERY]`, `/find [QUERY]` | Recherchez la chronologie de la conversation. |\n| `/security-review [PROMPT]` | Exécutez une révision de sécurité axée sur les modifications de code local actives et retournez des résultats de vulnérabilité hiérarchisés avec des suggestions de correction. Cette commande n’est pas un audit de sécurité complet du référentiel. |\n| `/session [info\\|checkpoints [n]\\|files\\|plan\\|rename [NAME]\\|cleanup\\|prune\\|delete [ID]\\|delete-all]`, `/sessions [info\\|checkpoints [n]\\|files\\|plan\\|rename [NAME]\\|cleanup\\|prune\\|delete [ID]\\|delete-all]` | Affichez les informations de session et gérez les sessions. La `info` sous-commande affiche les détails de la session, y compris le lien de session (le cas échéant). Sous-commandes : `info`, , `checkpoints`, `files``plan`, `rename``cleanup``prune``delete`, , . `delete-all` |\n| `/settings [--repo\\|--local] [show KEY\\|KEY\\|KEY VALUE]`,
`/config [--repo\\|--local] [show KEY\\|KEY\\|KEY VALUE]` | Ouvrez la boîte de dialogue paramètres, ouvrez-la sur un paramètre spécifique (`KEY`), définissez un paramètre inline (`KEY VALUE`) ou affichez la valeur actuelle d’un paramètre (`show KEY`). `show` masque les valeurs nommées secrètes (par exemple, les jetons ou les clés API imbriquées sous un paramètre) au lieu de les imprimer en texte clair. La boîte de dialogue affiche les onglets **Utilisateur**, **Dépôt**, **Dépôt (local)** et **Problèmes** — passez de l’un à l’autre avec Tab+/Tab ; un paramètre redéfini dans une autre étendue affiche un badge indiquant quelle étendue l’emporte. L’onglet **Problèmes** est une vue inter-étendue des paramètres qui ont besoin d’attention (par exemple, des clés inconnues ou non valides) ; son étiquette affiche un nombre, par `Problems (2)`exemple, lorsqu’une étendue a un problème et qu’il suffit de lire `Problems`. Ajoutez `--repo` ou `--local` pour cibler `.github/copilot/settings.json` ou `.github/copilot/settings.local.json` au lieu du fichier de paramètres de l’utilisateur, par exemple `/settings --repo model gpt-6-astra`. Seules les [clés redéfinissables par le repo](/fr/copilot/reference/copilot-cli-reference/cli-config-dir-reference#repository-settings-githubcopilotsettingsjson) peuvent être définies de cette façon. Les lignes régies par une organisation active ou une stratégie gérée par MDM s’affichent en lecture seule avec une balise `(managed)`. Consultez « [Modification des paramètres avec la \\`/settings\\` commande](/fr/copilot/how-tos/copilot-cli/customize-copilot/change-settings) ». |\n| `/share [link\\|off\\|file\\|html\\|gist\\|research] [...]`, `/export [...]` | Partagez la session en cours. Sans sous-commande, génère un lien partageable GitHub lorsque vous êtes connecté et synchronisé (revient à l’exportation de fichier Markdown dans le cas contraire). `off` arrête le partage. `link` est un alias explicite pour le flux de liens par défaut ; `link off` arrête le partage de liens. `file [session\\|research] [PATH]` exporte vers un fichier Markdown. `html [session\\|research] [PATH]` exporte vers un fichier HTML. `gist [session\\|research]` crée un GitHub gist. `research [PATH]` exporte le rapport de recherche. |\n| `/skills` | Ouvrez le tableau de bord des plug-ins sous l’onglet Compétences. |\n| `/skills list` | Répertorier toutes les compétences disponibles. |\n| `/skills info NAME` | Afficher les détails d’une compétence spécifique. |\n| `/skills add [--project] ` | Ajouter une compétence à partir d’un fichier, d’une URL ou d’un répertoire ; `--project` étend un fichier ou une URL installé dans ce référentiel au lieu de votre compte d’utilisateur. |\n| `/skills remove ` | Supprimez une compétence par nom ou annulez l’inscription d’un répertoire de compétences personnalisé. |\n| `/skills reload` | Recharger les compétences depuis tous les répertoires. Consultez « [Ajout de compétences d’agent pour GitHub Copilot CLI](/fr/copilot/how-tos/copilot-cli/customize-copilot/add-skills) ». |\n| `/statusline`, `/footer` | Configurez les éléments qui apparaissent dans la ligne d’état. |\n| `/subagents`, `/agents` | Configurez les modèles de sous-agent par défaut et propres à chaque agent. Pour un agent avec `modelPolicy: \"required\"` — qu’il soit défini dans la définition propre de l’agent ou dans la surcharge des paramètres `subagents` — le sélecteur affiche une entrée **Modèle** verrouillée et une ligne **Application du modèle** indiquant « requis - ne peut pas être remplacé » (ou « requis par la définition de l’agent » lorsque la définition de l’agent elle-même définit la stratégie). Remettez la stratégie sur `\"preferred\"` à l’aide du sélecteur pour autoriser de nouveau les remplacements, sauf si la définition de l’agent l’exige. Consultez « [GitHub Copilot le répertoire de configuration du CLI](/fr/copilot/reference/copilot-cli-reference/cli-config-dir-reference#configuration-file-settings) ». |\n| `/tasks` | Affichez et gérez les tâches (sous-agents et commandes shell). |\n| `/terminal-setup` | Configurez le terminal pour la prise en charge des entrées multilignes (Maj+Entrée et Ctrl+Entrée). |\n| `/theme [default\\|github\\|dim\\|high-contrast\\|colorblind]` | Affichez ou définissez le mode de couleur. |\n| `/tuikit [colors\\|icons\\|select\\|tabbar]` | Aperçu des composants du système de conception TUIkit et des jetons de couleur. |\n| `/undo`, `/rewind` | Ouvrez le sélecteur de retour en arrière pour restaurer la session à un tour utilisateur antérieur. Choisissez entre : **Conversation uniquement** (restaurez la conversation, laissez les fichiers tels qu’ils sont) ou **Conversation + fichiers** (restaurez également les fichiers modifiés à ce tour, puis ignorés, à leur contenu avant modification, en ignorant les fichiers Copilot que vous avez modifiés vous-même). Les modifications apportées aux fichiers sont suivies par tour entre les outils d’édition, les commandes d’interpréteur de commandes et les sous-agents. Git n’est donc pas nécessaire. |\n| `/update`, `/upgrade` | Mettez à jour l’interface CLI vers la dernière version. |\n| `/usage` | Affichez les métriques et statistiques d’utilisation de session, y compris les totaux de jetons par modèle. Pour les comptes à facturation par jetons, la ligne de chaque modèle affiche également sa propre consommation AI credit (par exemple, `1 AIC`). Les modèles facturés sans nombre de tokens n’affichent que des crédits. |\n| `/user [show\\|list\\|switch]` | Gérer les comptes connectés. |\n| `/version` | Affichez les informations de version et recherchez les mises à jour. |\n| `/vim` | Activer le mode Vim pour la zone de saisie afin d’activer l’édition modale de style Vim : mouvements (par exemple, `hjkl`, `w`, `b`, `e`, `0`, `$`, `gg`, `G`), recherche de caractère (`f`/`F`/`t`/`T`/`;`/`,`), commandes d’insertion (`i`/`a`/`o`), commandes d'édition (`r`/`~`/`J`/`x`/`D`/`C`), operators (`d`/`c`/`y`), yank et put (`y`/`p`/`P`), répétition (`.`), annulation et rétablissement (`u`/Ctrl+R), counts, and Esc pour revenir au mode normal. Configurable également avec le `editorMode` paramètre. Consultez « [GitHub Copilot le répertoire de configuration du CLI](/fr/copilot/reference/copilot-cli-reference/cli-config-dir-reference#user-settings-copilotsettingsjson) ». |\n| `/voice [on\\|off\\|models\\|devices]` | Basculez le mode vocal, parcourez les modèles vocaux disponibles ou choisissez l’appareil d’entrée (microphone). |\n| `/workflows` | Observez les exécutions de flux de travail, les phases, les agents et la progression. Nécessite un plan de facturation basé sur des jetons. Consultez [Utiliser `copilot workflow run`](#using-copilot-workflow-run) pour exécuter un flux de travail inscrit directement. |\n| `/fork [NAME]`, `/branch [NAME]` | Dupliquez la session en cours dans une nouvelle session, en la nommant éventuellement. Utilisable pendant l’exécution de l’agent : la session source continue de fonctionner en arrière-plan. `/fork worktree` duplique la session en cours, en conservant son contexte de conversation, dans un nouvel arbre de travail Git créé à partir de la branche `HEAD`. |\n| `/worktree [branch\\|task]` | Créez un nouvel arbre de travail Git et basculez dessus, en laissant les modifications non validées dans l’arbre de travail actuel. Transmettez un nom de branche, une description de tâche (multiligne prise en charge, utilisée comme invite d’ouverture dans la nouvelle arborescence de travail) ou omettez l’argument pour générer automatiquement un nom de branche à partir de la conversation. Par défaut, la branche est créée à partir de la révision extraite actuelle (`HEAD`) ; définissez le paramètre `worktreeBaseRef` sur `\"defaultBranch\"` pour créer plutôt la branche à partir de la branche par défaut distante. Consultez « [GitHub Copilot le répertoire de configuration du CLI](/fr/copilot/reference/copilot-cli-reference/cli-config-dir-reference#user-settings-copilotsettingsjson) ». Nécessite un dépôt Git. |\n| `/worktree new [PROMPT]` | Déconseillé : utilisez `/new worktree` à la place. Démarre une nouvelle conversation dans une nouvelle arborescence de travail Git, laissant la conversation actuelle et son répertoire de travail inchangés. Fournissez éventuellement la première instruction. |\n| `new` est réservé en tant que mot clé de sous-commande et ne peut pas être utilisé comme nom de branche littérale. Suit le même `worktreeBaseRef` paramètre que `/worktree`. | |\n| `/move [branch\\|task]` | Déplacez les modifications non validées dans une nouvelle arborescence de travail Git et passez-y. Transmettez un nom de branche, une description de tâche (multiligne prise en charge, utilisée comme invite d’ouverture dans la nouvelle arborescence de travail) ou omettez l’argument pour générer automatiquement un nom de branche à partir de la conversation. Nécessite un dépôt Git. |\n\nPour obtenir la liste complète des commandes de barre oblique disponibles, entrez `/help` dans l’interface interactive de l’interface CLI.\n\nDans le gestionnaire de planification ouvert par un `/every` nu ou `/after`, utilisez ^/> pour sélectionner une entrée et `x` la supprimer. Les planifications peuvent uniquement être ajoutées à partir du champ de saisie de la requête à l’aide de `/every` ou `/after` avec des arguments ; la boîte de dialogue permet uniquement de les consulter et de les supprimer.\n\nLe pied de page affiche par défaut un indicateur « N planifications » chaque fois que la session comporte des planifications actives, même si `/every` et `/after` ne sont pas activés pour vous.\n\n`/plugin` signale un plug-in installé ou une place de marché lorsqu’une version plus récente est disponible en amont et offre une action **de mise à jour** à partir du tableau de bord.\n\n`/mcp list`\n/\n`ls` et `/plugin list`/`ls` (y compris nu `/plugin`) sont en lecture seule et peuvent s’exécuter pendant que l’agent est occupé à traiter une interaction. Toutes les autres `/mcp` et `/plugin` sous-commandes sont bloquées jusqu’à la fin du tour.\n\n> \\[!NOTE]\n> La commande expérimentale `/plugins` a été supprimée. Ses ressources ont été déplacées vers `/plugin`, `/mcp`et `/skills`. Utilisez `/subagents` et `/instructions` pour les agents et les instructions.\n\n### Collecte et partage des journaux de débogage\n\nUtilisez `/collect-debug-logs [file|gist|share] [PATH]` pour collecter les journaux de débogage pour la résolution des problèmes :\n\n| Target | Description |\n| ------- | ------------------------------------------------------------------------------------------------------------------- |\n| `file` | Enregistrez les journaux dans une archive locale à `PATH` (emplacement par défaut utilisé lorsque `PATH` est omis). |\n| `gist` | Chargez les journaux sur un gist secret GitHub . |\n| `share` | Enregistrez une archive locale, puis chargez-la dans GitHub. |\n\n`/collect-debug-logs share`, et l’itinéraire feedback-with-logs proposé à partir de `/feedback`, enregistrez tout d’abord une archive locale, puis demandez un nouveau consentement (**non** par défaut) avant de la charger sur GitHub. Le téléversement est actuellement disponible uniquement pour GitHub le personnel et les utilisateurs internes, et n’est pas encore disponible en général. Les utilisateurs en dehors de GitHub continuent à utiliser les itinéraires d’archivage et de gist existants, ainsi que l’itinéraire de commentaires public existant.\n\n## Options de ligne de commande\n\n| Choix | Objectif | |\n| -------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------- |\n| `--add-dir=PATH` | Autoriser l’accès à un répertoire et charger son `.github/skills` et `.github/agents` en tant que configurations de confiance (pouvant être utilisées plusieurs fois). Un chemin relatif est résolu par rapport au répertoire de travail de la session (le répertoire `--worktree`, `-C` ou `--resume`), quel que soit l’ordre des options. Le chemin d’accès doit être un répertoire existant ; si le chemin est introuvable ou s’il s’agit d’un fichier ordinaire, le démarrage échoue immédiatement avec une erreur propre à l’indicateur, de la même manière dans tous les modes. | |\n| `--add-github-mcp-tool=TOOL` | Ajoutez un outil pour activer pour le GitHub serveur MCP, au lieu du sous-ensemble CLI par défaut (peut être utilisé plusieurs fois). Utiliser `*` pour tous les outils. | |\n| `--add-github-mcp-toolset=TOOLSET` | Ajoutez un ensemble d’outils pour activer pour le GitHub serveur MCP, au lieu du sous-ensemble CLI par défaut (peut être utilisé plusieurs fois). Utiliser `all` pour tous les ensembles d’outils. | |\n| `--additional-mcp-config=JSON` | Ajoutez un serveur MCP pour cette session uniquement. La configuration du serveur peut être fournie sous la forme d’une chaîne JSON ou d’un chemin d’accès de fichier (préfixe avec `@`). Un chemin relatif `@file` est résolu par rapport au répertoire de travail de la session (le répertoire `--worktree`, `-C` ou `--resume`), quel que soit l’ordre des options. Optimisez la configuration de `~/.copilot/mcp-config.json`. Remplace toute configuration de serveur MCP installée avec le même nom. Consultez « [Ajout de serveurs MCP pour GitHub Copilot CLI](/fr/copilot/how-tos/copilot-cli/customize-copilot/add-mcp-servers) ». | |\n| `--agent=AGENT` | Spécifiez un custom agent à utiliser. Consultez « [À propos des agents personnalisés](/fr/copilot/concepts/agents/copilot-cli/about-custom-agents) ». | |\n| `--allow-all` | Activez toutes les autorisations (équivalentes à `--allow-all-tools --allow-all-paths --allow-all-urls`). | |\n| `--allow-all-mcp-server-instructions` | Incluez des instructions d’initialisation de tous les serveurs MCP dans l’invite système. Par défaut, seules les instructions des serveurs sur liste d’autorisation sont incluses d’emblée ; les instructions des autres serveurs sont récupérées à la demande. | |\n| `--allow-all-paths` | Désactivez la vérification du chemin d’accès du fichier et autorisez l’accès à n’importe quel chemin d’accès. | |\n| `--allow-all-tools` | Autoriser l’exécution automatique de tous les outils sans confirmation. Obligatoire lors de l’utilisation de l’interface CLI par programmation (env : `COPILOT_ALLOW_ALL`). | |\n| `--allow-all-urls` | Autoriser l’accès à toutes les URL sans confirmation. | |\n| `--allow-tool=TOOL ...` | Les outils que l’interface CLI dispose de l’autorisation d’utiliser. Ne demande pas l’autorisation. Pour plusieurs outils, utilisez une liste séparée par des virgules entre guillemets. Consultez « [Autorisation et refus de l’utilisation de l’outil](/fr/copilot/how-tos/copilot-cli/use-copilot-cli/allowing-tools#allowing-or-denying-permission-for-specific-tools) ». | |\n| `--allow-url=URL ...` | Autoriser l’accès à des URL ou domaines spécifiques. Pour plusieurs URL, utilisez une liste séparée par des virgules entre guillemets. | |\n| `--acp` | Démarrez en tant que serveur de protocole client agent. | |\n| `--attachment PATH` | Joindre un fichier à l’invite initiale (peut être utilisé plusieurs fois). Les fichiers image sont acceptés, mais leur envoi ne peut être effectué avec succès que si le modèle sélectionné et la politique de l’organisation autorisent l’entrée visuelle. | |\n| `--autopilot` | Activez la poursuite en mode pilote automatique : l’agent continue à travailler jusqu’à l’appel de `task_complete`, puis revient en mode interactif. Consultez « [Utilisation du mode Autopilot dans GitHub Copilot CLI](/fr/copilot/how-tos/copilot-cli/use-copilot-cli/use-autopilot-mode) ». | |\n| `--available-tools=TOOL ...` | Seuls ces outils seront disponibles pour le modèle. Pour plusieurs outils, utilisez une liste séparée par des virgules entre guillemets. Consultez « [Autorisation et refus de l’utilisation de l’outil](/fr/copilot/how-tos/copilot-cli/use-copilot-cli/allowing-tools) ». | |\n| `--banner`, `--no-banner` | Afficher ou masquer la bannière de démarrage. | |\n| `--bash-env` | Activez la `BASH_ENV` prise en charge des interpréteurs de commandes bash. | |\n| `-C DIRECTORY` | Modifiez le répertoire de travail avant d’effectuer autre chose. | |\n| `--connect[=SESSION-ID]` | Connectez-vous directement à une session distante (spécifiez éventuellement un ID de session ou un ID de tâche). Conflits avec `--resume` et `--continue`. | |\n| `--context TIER` | Définissez le niveau de la fenêtre de contexte pour les modèles à tarification hiérarchisée (remplace le paramètre enregistré et est appliqué dans les nouvelles sessions interactives). Choix : « default », « long\\_context ». | |\n| `--config-dir=DIRECTORY` | Cette option pour définir le répertoire de configuration est déconseillée. Utilisez plutôt la variable d’environnement `COPILOT_HOME` . | |\n| `--continue` | Reprendre la session la plus récente dans le répertoire de travail actuel, en se repliant sur la session la plus récente dans un contexte global. Conflits avec `--resume`. | |\n| `--deny-tool=TOOL ...` | Les outils que l’interface CLI n’a pas l’autorisation d’utiliser. Ne demande pas l’autorisation. Pour plusieurs outils, utilisez une liste séparée par des virgules entre guillemets. | |\n| `--deny-url=URL ...` | Refuser l’accès à des URL ou domaines spécifiques est prioritaire sur `--allow-url`. Pour plusieurs URL, utilisez une liste séparée par des virgules entre guillemets. | |\n| `--disable-builtin-mcps` | Désactivez tous les serveurs MCP intégrés (actuellement : `github-mcp-server`). | |\n| `--disable-mcp-server=SERVER-NAME` | Désactivez un serveur MCP spécifique (peut être utilisé plusieurs fois). | |\n| `--disallow-temp-dir` | Empêchez l’accès automatique au répertoire temporaire système. | |\n| `--effort=LEVEL`, `--reasoning-effort=LEVEL` | Définissez le niveau d’effort de raisonnement (`low`, `medium`, `high`, `xhigh`). `max` `max` est le niveau de profondeur maximal pour les modèles Anthropic. | |\n| `--enable-all-github-mcp-tools` | Activez tous les GitHub outils serveur MCP, au lieu du sous-ensemble CLI par défaut. Remplace les options `--add-github-mcp-toolset` et `--add-github-mcp-tool`. | |\n| `--enable-mcp-server=SERVER-NAME` | Réactivez un serveur MCP désactivé dans vos paramètres, pour cette session uniquement (peut être utilisé plusieurs fois). La modification n’est pas conservée dans votre configuration. | |\n| `--enable-memory` | Activez la mémoire en mode d’invite (désactivée par défaut). | |\n| `--enable-reasoning-summaries` | Option de compatibilité déconseillée (acceptée mais ignorée). Les résumés de raisonnement détaillés pour la prise en charge des modèles OpenAI sont affichés par défaut. Activez-les ou désactivez-les avec Ctrl+T. | |\n| `--excluded-tools=TOOL ...` | Ces outils ne seront pas disponibles pour le modèle. Pour plusieurs outils, utilisez une liste séparée par des virgules entre guillemets. | |\n| `--experimental` | Activer les fonctionnalités expérimentales (utiliser `--no-experimental` pour désactiver). | |\n| `--extension-sdk-path DIRECTORY` | Remplacez le `@github/copilot-sdk` fourni injecté dans les sous-processus d’extension par un dossier local `copilot-sdk/`. Les chemins d’accès non valides utilisent par défaut le kit de développement logiciel (SDK) fourni. | |\n| `--fleet` | Exécutez la requête en mode flotte (orchestration parallèle de sous-agents). Combinez avec `-i`, `-p` ou l’entrée standard via un tube. Cela nécessite une instruction provenant de l’une de ces sources et n’a aucun effet à lui seul. Cela équivaut à faire précéder une invite interactive du prompt slash `/fleet`. Avec `-p` ou une entrée standard redirigée, il déclenche la même orchestration de la flotte sans interaction. Consultez « [Accélération de l’achèvement de la tâche avec la \\`/fleet\\` commande](/fr/copilot/how-tos/copilot-cli/use-copilot-cli/speed-up-task-completion) ». | |\n| `-h`, `--help` | Afficher l'aide. | |\n| `-i PROMPT`, `--interactive=PROMPT` | Démarrez une session interactive et exécutez automatiquement cette invite. | |\n| `--log-dir=DIRECTORY` | Définissez le répertoire du fichier journal (par défaut : `~/.copilot/logs/`). | |\n| `--log-level=LEVEL` | Définissez le niveau de journalisation (choix : `none`, `error`, `warning`, `info`, `debug`, `all`, `default`). | |\n| `--max-ai-credits=CREDITS` | Définissez un maximum souple pour les crédits IA autorisés pour chaque réponse. La limite est réinitialisée pour chaque message utilisateur et peut être ajustée en cours de session avec `/limits`. Consultez « [Définition d’une AI credit limite de session dans GitHub Copilot CLI](/fr/copilot/how-tos/copilot-cli/use-copilot-cli/set-session-limit) ». | |\n| `--max-autopilot-continues=COUNT` | Nombre maximal de messages de continuation en mode Autopilot (valeur par défaut : illimitée). Doit être un entier non négatif. Les valeurs mal formées (`NaN`, négatives, fractionnaires ou notation scientifique) sont rejetées. Consultez « [Utilisation du mode Autopilot dans GitHub Copilot CLI](/fr/copilot/how-tos/copilot-cli/use-copilot-cli/use-autopilot-mode) ». | |\n| `--mode=MODE` | Définissez le mode d’agent initial (choix : `interactive`, `plan`). `autopilot` Combinez avec `--plan` (comme `--plan --mode autopilot`) pour plan-then-autopilot : la session démarre en mode plan et passe automatiquement en mode autopilot une fois le plan prêt, au lieu d’attendre qu’un humain l’approuve. Toute autre `--plan --mode MODE` paire est rejetée. | |\n| `--model=MODEL` | Définissez le modèle IA que vous souhaitez utiliser. Passez `auto` en tant que valeur pour laisser Copilot choisir automatiquement le meilleur modèle disponible. Consultez « [À propos de Copilotauto model selection](/fr/copilot/concepts/models/auto-model-selection) ». | |\n| `--mouse[=VALUE]` | Activez ou désactivez la prise en charge de la souris dans l’interface interactive. VALUE peut être `on` (par défaut) ou `off`. Lorsque cette option est activée, l’interface CLI capture les événements de souris (roulette de défilement, clics, etc.) pour naviguer dans sa propre interface, par exemple en faisant défiler la chronologie ou en cliquant sur des onglets. En cas de désactivation, le comportement de la souris native du terminal, tel que la sélection de texte et le défilement, est conservé. Lorsque vous définissez cette option explicitement, la valeur est conservée dans votre fichier de configuration. | |\n| `-n NAME`, `--name=NAME` | Définissez un nom pour la nouvelle session. Utilisé par `--resume` et `/resume` pour rechercher des sessions par nom. | |\n| `--no-ask-user` | Désactivez l’outil (l’agent `ask_user` fonctionne de manière autonome sans poser de questions). | |\n| `--no-auto-update` | Désactivez le téléchargement automatique des mises à jour CLI. | |\n| `--no-bash-env` | Désactivez la prise en charge de `BASH_ENV` pour les interpréteurs de commandes Bash. | |\n| `--no-color` | Désactivez toutes les sorties de couleur. | |\n| `--no-custom-instructions` | Désactivez le chargement d'instructions personnalisées de `AGENTS.md` et des fichiers associés. | |\n| `--no-experimental` | Désactivez les fonctionnalités expérimentales. | |\n| `--no-mouse` | Désactivez la prise en charge de la souris. | |\n| `--no-remote` | Désactivez l’accès à distance pour cette session. | |\n| `--no-remote-export` | Désactivez l’exportation de votre session vers GitHub.com et GitHub Mobile (désactive également le contrôle à distance). | |\n| `--output-format=FORMAT` | Format peut être `text` (par défaut) ou `json` (génère JSONL : un objet JSON par ligne). | |\n| `-p PROMPT`, `--prompt=PROMPT` | Exécutez un prompt de manière programmatique (quitte après l’exécution). Le récapitulatif de fin comprend un `copilot --resume=SESSION-ID` indice pour poursuivre la session. Consultez « [Exécution GitHub Copilot CLI par programmation](/fr/copilot/how-tos/copilot-cli/automate-copilot-cli/run-cli-programmatically) ». | |\n| `--plan` | Démarrez en mode plan. Raccourci pour `--mode plan`. Impossible de combiner avec `--autopilot`. Peut être combiné avec `--mode autopilot` pour plan-then-autopilot ; toute autre valeur de `--mode` est rejetée. | |\n| `--plain-diff` | Désactivez le rendu des différences enrichies (mise en surbrillance de la syntaxe via l’outil de différences spécifié par votre configuration Git). | |\n| `--plugin-dir=DIRECTORY` | Charger un plug-in à partir d’un répertoire local (peut être utilisé plusieurs fois). Un chemin relatif est résolu par rapport au répertoire de travail de la session (le répertoire `--worktree`, `-C` ou `--resume`), quel que soit l’ordre des options. Les agents fournis par un plugin `--plugin-dir` sont disponibles dans les sessions en mode serveur (`--server`), ainsi que dans les sessions interactives et `-p`. | |\n| `--remote` | Activez l’accès à distance à cette session depuis GitHub.com et GitHub Mobile. Consultez « [Direction d’une session à partir d’un GitHub Copilot CLI autre appareil](/fr/copilot/how-tos/copilot-cli/use-copilot-cli/steer-remotely) ». | |\n| `--remote-export` | Exportez votre session vers GitHub.com et GitHub Mobile (en lecture seule ; n’active pas le contrôle à distance). | |\n| `-r`, `--resume[=VALUE]` | Reprendre une session interactive précédente en choisissant dans une liste. Spécifiez éventuellement un ID de session, un préfixe d’ID ou un nom de session. La correspondance de noms est exacte et insensible à la casse ; bascule vers le résumé généré automatiquement lorsqu’aucun nom explicite ne correspond. Conflits avec `--continue`. L’option `--resume` seule (sans valeur) ouvre un sélecteur de session interactif, qui nécessite un TTY. Si plusieurs sessions existent et que le sélecteur ne peut pas être affiché (par exemple, sous `-p`, un stdin non-TTY `-i`ou piped), l’interface CLI se ferme avec une erreur au lieu de démarrer en mode silencieux une nouvelle session, transmettez une instruction explicite `--resume=SESSION-ID` ou utilisée `--continue`. | |\n| `-s`, `--silent` | Affichez uniquement la réponse de l’agent (sans statistiques d’utilisation), utile pour l’écriture de scripts avec `-p`. | |\n| `--screen-reader` | Activez les optimisations du lecteur d’écran. | |\n| `--secret-env-vars=VAR ...` | Réactez une variable d’environnement à partir d’environnements de serveur shell et MCP (peut être utilisée plusieurs fois). Pour plusieurs variables, utilisez une liste séparée par des virgules entre guillemets. Les valeurs dans les variables d’environnement `GITHUB_TOKEN` et `COPILOT_GITHUB_TOKEN` sont masquées par défaut. | |\n| `--session-id ID` | Utilisez un ID de session ou de tâche exact lorsque vous ne souhaitez pas utiliser la correspondance plus large de `--resume` basée sur le préfixe de l’ID ou le nom de session. Si l’ID correspond à une session ou une tâche existante, cette session ou cette tâche est reprise. Si rien ne correspond, une nouvelle session est créée uniquement lorsque la valeur est un UUID valide. Les noms et les préfixes d’ID ne créent pas de sessions. Ne combinez pas cette option avec d’autres options de sélection de session ou de démarrage de session telles que `--resume`, `--continue`ou , parce `--connect`qu’elles concurrencent pour décider de la session à ouvrir ou créer. | |\n| `--sandbox` | Activez le bac à sable du shell au niveau du système d’exploitation pour cette session uniquement, sans modifier votre paramètre de bac à sable enregistré. Utile avec `-p`. | |\n| `--no-sandbox` | Désactivez uniquement le bac à sable local pour cette session, sans modifier votre paramètre de bac à sable enregistré. Cette option est ignorée si une stratégie gérée par l’entreprise a été configurée pour appliquer le sandboxing. | |\n| `--share=PATH` | Partagez une session dans un fichier Markdown après l’achèvement d’une session programmatique (chemin d’accès par défaut : `./copilot-session-.md`). | |\n| `--share-gist` | Partagez une session sur un gist secret GitHub après la terminaison d'une session programmée. | |\n| `--stream=MODE` | Activez ou désactivez le mode de diffusion en continu, qui affiche progressivement la réponse de Copilot à mesure qu’elle est générée, au lieu d’attendre la réponse complète (choix de mode : `on` ou `off`, par défaut : `on`). | |\n| `-v`, `--version` | Afficher les informations de version. | |\n| `-w`, `--worktree[=NAME]` | Créer ou réutiliser un worktree Git isolé sous `.worktrees/` par défaut et démarrer la session dans celui-ci. Utilisez le `worktreePathTemplate` paramètre pour configurer l’emplacement. `NAME` est facultatif : omettez-le pour générer automatiquement un nom de branche. Par défaut, la branche est créée à partir de la révision extraite actuelle (`HEAD`) ; définissez le paramètre `worktreeBaseRef` sur `\"defaultBranch\"` pour créer plutôt la branche à partir de la branche par défaut distante. Conflits avec `--resume`, `--continue`et `--connect`. | |\n| `--yolo` | Activez toutes les autorisations (équivalentes à `--allow-all`). | |\n\nPour obtenir la liste complète des commandes et des options, exécutez `copilot help`.\n\n> \\[!NOTE]\n> Les options `--remote`, `--no-remote`, `--remote-export`, `--no-remote-export` et `--connect` nécessitent que la fonctionnalité de sessions à distance soit disponible sur votre compte.\n\nVous pouvez utiliser `--remote` avec `--resume ` pour reprendre une tâche à distance localement. Cela fonctionne même lorsque la tâche a été créée à l’origine en dehors d’un dépôt Git.\n\nSi une session était toujours ouverte lorsque son processus CLI est parti, par exemple en raison d’un incident ou d’un redémarrage de la machine, la prochaine fois que vous démarrez `copilot` , vous avez la possibilité de la restaurer. Vous pouvez examiner les sessions disponibles pour restaurer ou démarrer une nouvelle session à la place. Une session restaurée dont l’assistant était en plein traitement reprend automatiquement cette tâche.\n\n### Planification puis pilotage automatique\n\nPlan-then-autopilot permet à une session de démarrer en mode plan et de continuer automatiquement en mode Autopilot une fois le plan prêt, sans attendre qu’un humain approuve la transition. Activez-le avec `--plan --mode autopilot`, ou avec la `COPILOT_PLAN_THEN_AUTOPILOT` variable d’environnement pour les harnais qui peuvent uniquement injecter des variables d’environnement et non des options de ligne de commande. Si les deux sont définis, les options explicites sont prioritaires et l’interface CLI affiche un avertissement indiquant que la variable d’environnement a été ignorée.\n\n### Niveau minimal de bac à sable géré par l’entreprise\n\nUne stratégie gérée par l’entreprise peut imposer l’utilisation d’un bac à sable pour le shell au niveau du système d’exploitation comme niveau de protection minimal. En d’autres termes, même si vous fournissez `--no-sandbox`, la stratégie peut toujours forcer l’activation de l’isolation en bac à sable. Il s’agit d’une dérogation de stratégie, et non d’un échec de l’option elle-même. En revanche, `--sandbox` n’est pas affecté, car il active uniquement le bac à sable (sandbox) et ne le supprime jamais. Si la stratégie en vigueur autorise le contournement de l’environnement de test, vous pouvez désactiver explicitement cet environnement pour le reste de la session en cours lorsque vous répondez à une invite active d’autorisation de contournement.\n\nLorsqu’un niveau géré active le bac à sable avec une valeur effective de `true` pour `sandbox.allowBypass` (valeur par défaut lorsqu’une stratégie définit uniquement `sandbox.enabled` sur `true`), exécutez `/sandbox disable` pour désactiver le bac à sable pour le reste de la session en cours ; aucune invite de contournement préalable n’est nécessaire. La désactivation ne vaut que pour la session en cours : rien n’est enregistré dans `settings.json`, une nouvelle session redémarre isolée, et `/sandbox enable` rétablit immédiatement l’isolation sans attendre une nouvelle session. Si `allowBypass` est `false`, `/sandbox disable` refuse avec un message indiquant que l’isolation en bac à sable est imposée par la stratégie gérée et ne peut pas être désactivée.\n\nLorsqu’une stratégie managée remplace votre paramètre, l’interface CLI affiche un avertissement dans la chronologie interactive (ou sur stderr lors de l’utilisation `-p`) afin qu’il soit clair que le comportement provient de l’application de la stratégie plutôt que de l’option qui ne fonctionne pas. Contactez votre administrateur si vous avez besoin de la stratégie modifiée. Utilisez `/sandbox status` ou `/sandbox policy` pour examiner les restrictions effectives de la session.\n\nL’ajout du paramètre géré `sandbox.failIfUnavailable` défini sur `true`, avec `sandbox.enabled` défini sur `true`, rend le bac à sable obligatoire si celui-ci ne peut pas être établi. Au lieu de se rabattre sur l’exécution de commandes hors bac à sable, Copilot bloque l’exécution du modèle et de l’outil si la stratégie ne peut pas être validée, compilée ou appliquée par un backend de sandbox exploitable. Consultez « [Paramètres gérés par l’entreprise](/fr/copilot/reference/enterprise-administrators/enterprise-managed-settings#sandbox) ».\n\nLa CLI affiche également un avertissement lorsqu’une stratégie gérée active le bac à sable dans une session alors que vous ne l’avez pas demandé, et pas uniquement lorsqu’elle remplace l’option `--no-sandbox`. Cela inclut les sessions où la stratégie arrive après le démarrage, car les paramètres gérés par le serveur ne sont disponibles qu’après la connexion. L’avertissement n’est pas affiché si vos propres paramètres ou l’option `--sandbox` ont déjà demandé l’activation du bac à sable, puisque l’état de la session est alors celui attendu.\n\nSi un appareil a une stratégie gérée qui n’a pas pu être lue, l’interface CLI échoue et applique le bac à sable à son niveau le plus restrictif. L’avis explique que la stratégie n’a pas pu être déterminée et vous indique d’attendre qu’elle soit résolue. L’avertissement de démarrage d’un hôte non pris en charge utilise la même formulation.\n\n### Restriction des options --allow-all\n\nQuand `permissions.disableBypassPermissionsMode` est défini sur `\"disable\"`, toutes les options de ligne de commande qui accordent toutes les autorisations (`--allow-all-tools`, `--allow-all-paths`, `--allow-all-urls`, `--allow-all`, `--yolo`) sont désactivées au démarrage et ne peuvent pas être utilisées pour accorder des privilèges élevés. L’interface CLI affiche un avertissement de stratégie lorsqu’elle masque ces options. La `/permissions allow-all` commande barre oblique, ainsi que ses alias `/allow-all` et `/yolo`, sont également supprimés.\n\nDéfinissez `permissions.disableBypassPermissionsMode` sur `\"allow-auto-only\"` pour bloquer les autorisations globales complètes, tout en permettant `/permissions assisted` (approbation des autorisations assistée par LLM). L’approbation assistée demande toujours une confirmation pour chaque requête, mais ajoute une recommandation de sécurité de l’LLM afin que l’interface en ligne de commande puisse approuver automatiquement les requêtes que le modèle juge acceptables.\n\nSi `permissions.disableBypassPermissionsMode` est défini sur une valeur non reconnue, l’outil CLI ne la rejette plus d’emblée. Au lieu de cela, l’outil en ligne de commande (CLI) consigne le problème et impose `\"disable\"` comme comportement par défaut en échec fermé, de sorte qu’une stratégie gérée mal formée continue de restreindre les options d’autorisation totale au lieu de les autoriser silencieusement.\n\nTrois sources peuvent définir cette restriction, en ordre croissant de permanence :\n\n| Origine | Étendue | Supprimé lors d’un changement de compte ? |\n| ---------------------------------------------------- | -------- | --------------------------------------------------------------------------------------------------------- |\n| Paramètres utilisateur (`~/.copilot/settings.json`) | Machine | Non : s’applique à tous les comptes |\n| Paramètres managés (extraits par serveur par compte) | Account | Oui — effacé lors du passage à un autre compte qui ne désactive pas les options « Tout autoriser » |\n| Stratégie MDM (plist/registre/fichier) | Appareil | Jamais — politique au niveau de l’appareil qui ne peut pas être outrepassée par les changements de compte |\n\nPour plus d’informations sur la configuration MDM, consultez [GitHub Copilot le répertoire de configuration du CLI](/fr/copilot/reference/copilot-cli-reference/cli-config-dir-reference#mdm-managed-settings).\n\n## Modèles pris en charge\n\nUtilisez `--model=MODEL` ou la variable d’environnement `COPILOT_MODEL` pour sélectionner le modèle IA. Passez `auto` pour laisser Copilot choisir automatiquement le meilleur modèle disponible.\n\n| Modèle | Idéal pour |\n| ------------------- | --------------------------------------------------------- |\n| `claude-sonnet-5.5` | Codage à usage général (par défaut) |\n| `gpt-5.4` | Tâches de raisonnement complexes |\n| `gpt-6.1-sol` | Recommandé, opt-in (pas la valeur par défaut automatique) |\n| `gpt-6-astra` | Recommandé, opt-in (pas la valeur par défaut automatique) |\n| `gpt-6-luna` | Recommandé, opt-in (pas la valeur par défaut automatique) |\n| `claude-opus-5.5` | Tâches complexes recommandées et très performantes |\n| `claude-haiku-5.5` | Opérations rapides et légères |\n| `claude-haiku-4.5` | Opérations rapides et légères |\n| `gpt-5.3-codex` | Tâches axées sur le code |\n| `gemini-3.7-flash` | Réponses Google Gemini rapides |\n| `gemini-3.8-flash` | Réponses Google Gemini rapides |\n\nVous pouvez également changer de modèle au cours d’une session interactive à l’aide de la commande `/model` slash.\n\n## Valeurs de disponibilité des outils\n\nLes options `--available-tools` et `--excluded-tools` prennent en charge ces valeurs :\n\n### Outils Shell\n\n| Nom de l’outil | Description |\n| --------------------------------- | -------------------------------------- |\n| `bash` / `powershell` | Exécuter des commandes |\n| `list_bash` / `list_powershell` | Répertorier les sessions shell actives |\n| `read_bash` / `read_powershell` | Lire la sortie d’une session shell |\n| `stop_bash` / `stop_powershell` | Terminer une session shell |\n| `write_bash` / `write_powershell` | Envoyer une entrée à une session shell |\n\n### Outils d’opération de fichier\n\n| Nom de l’outil | Description |\n| -------------- | ----------------------------------------------------------------------------------- |\n| `apply_patch` | Appliquer des correctifs (utilisés par certains modèles au lieu de `edit`/`create`) |\n| `create` | Créer des fichiers |\n| `edit` | Modifier des fichiers via le remplacement de chaîne |\n| `view` | Lire des fichiers ou des répertoires |\n\n### Outils de délégation d’agent et de tâche\n\n| Nom de l’outil | Description |\n| -------------- | -------------------------------------------------- |\n| `list_agents` | Répertorier les agents disponibles |\n| `read_agent` | Vérifier l'état de l'agent d'arrière-plan |\n| `task` | Exécuter des sous-agents |\n| `write_agent` | Envoyer un message à un agent en cours d’exécution |\n\n### Autres outils\n\n| Nom de l’outil | Description |\n| ---------------- | ------------------------------------------------ |\n| `ask_user` | Poser une question à l’utilisateur |\n| `glob` | Trouver des fichiers correspondant à des modèles |\n| `grep` (ou `rg`) | Rechercher du texte dans des fichiers |\n| `skill` | Appeler des compétences personnalisées |\n| `web_fetch` | Extraire et analyser le contenu web |\n\n## Modèles d’autorisation d’outil\n\nLes `--allow-tool` options et `--deny-tool` acceptent les modèles d’autorisation au format `Kind(argument)`. L’argument est facultatif : l'omission concerne tous les outils de ce type.\n\n| Type | Description | Exemples de modèles |\n| ------------------------------------------- | --------------------------------------------- | ------------------- |\n| `memory` | Stockage des faits dans la mémoire de l’agent | `memory` |\n| `read` | Lectures de fichiers ou de répertoires | |\n| `read`, `read(.env)` | | |\n| `shell` | Exécution de commandes shell | |\n| `shell(git push)` | | |\n| `shell(git:*)` | | |\n| `shell` | | |\n| | | |\n| `url` | Accès URL via web-fetch ou via le shell | |\n| `url(github.com)`, `url(https://*.api.com)` | | |\n| `write` | Création ou modification de fichier | |\n| `write`, `write(src/*.ts)` | | |\n| SERVER-NAME | Appel de l’outil serveur MCP | |\n| `MyMCP(create_issue)`, `MyMCP` | | |\n\nPour les règles `shell`, le suffixe `:*` correspond à la racine de la commande suivie d’un espace, ce qui empêche les correspondances partielles. Par exemple, `shell(git:*)` correspond `git push` et `git pull` ne correspond `gitea`pas.\n\nLes règles de refus sont toujours prioritaires sur les règles d’autorisation, même lorsque `--allow-all` est défini.\n\n```shell\n# Allow all git commands except git push\ncopilot --allow-tool='shell(git:*)' --deny-tool='shell(git push)'\n\n# Allow a specific MCP server tool\ncopilot --allow-tool='MyMCP(create_issue)'\n\n# Allow all tools from a server\ncopilot --allow-tool='MyMCP'\n\n# Deny writes to a specific path (exact or trailing-path-segment match; no glob support yet)\ncopilot --deny-tool='write(secret.txt)'\n```\n\n`--deny-tool='write(PATH)'` limite le déni à ce chemin : d’autres écritures ne sont pas affectées. La correspondance résout les liens symboliques et les segments `.`/`..`, et n’est pas sensible à la casse sur macOS et Windows.\n\n## Variables d'environnement\n\n| Variable | Description |\n| ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |\n| `COPILOT_ALLOW_ALL` | Autoriser toutes les autorisations automatiquement (équivalentes à `--allow-all`). Accepte `true`, `yes`, `1`, `on` ou `y` (sans tenir compte de la casse, les espaces en début et en fin étant ignorés) pour l’activer ; `false`, `0`, `no`, `off`, `n` ou une valeur vide pour le désactiver. Le définir exactement sur `true` fait également confiance au répertoire de travail sans demander de confirmation, en chargeant les compétences, les plug-ins, les serveurs MCP et les hooks de ce répertoire (y compris les hooks qui exécutent des commandes shell). Les autres orthographes vraies n’approuvent que les outils d’approbation automatique. |\n| `COPILOT_AUTO_UPDATE` | Définissez sur `false` pour désactiver les mises à jour automatiques de la CLI et des plugins propriétaires. |\n| `COPILOT_CACHE_HOME` | Remplacez le répertoire du cache (utilisé pour les caches de la Place de marché, les packages de mise à jour automatique et d’autres données éphémères). Consultez [GitHub Copilot le répertoire de configuration du CLI](/fr/copilot/reference/copilot-cli-reference/cli-config-dir-reference#changing-the-location-of-the-configuration-directory) pour connaître les valeurs par défaut de la plateforme. |\n| `COPILOT_CHILD_OOM_SCORE_ADJ` | Linux uniquement. Remplace le biais `oom_score_adj` appliqué aux arborescences de processus de commandes shell générées par l’interface CLI, de sorte que le tueur OOM du noyau récupère une arborescence de processus enfant de perte de contrôle (par exemple, un build) avant l’interface CLI elle-même. Par défaut : `300`. Plage : `-1000`–`1000`. Définissez sur `off` pour désactiver le biais. |\n| `COPILOT_CUSTOM_INSTRUCTIONS_DIRS` | Liste séparée par des virgules de répertoires supplémentaires pour obtenir des instructions personnalisées. |\n| `COPILOT_EDITOR` | Commande de l’éditeur pour la modification interactive (cochée après `$VISUAL` et `$EDITOR`). |\n| `vi` Par défaut, si aucun n’est défini. | |\n| `COPILOT_ENABLE_HTTP2` | Définissez sur `1` ou `true` pour activer le transport HTTP/2. HTTP/1.1 est la valeur par défaut. |\n| `COPILOT_ENABLE_INTERRUPTED_SESSION_RESTORE` | Définissez sur `1` pour activer la restauration d’une session qui était encore ouverte lorsque le processus CLI s’est arrêté, par exemple en raison d’un plantage ou d’un redémarrage de la machine. Ce comportement de restauration est temporairement accepté pendant que sa boîte de dialogue de démarrage est retravaillée. Consultez [Restauration d’une session interrompue](#restoring-an-interrupted-session). |\n| `COPILOT_GH_HOST` | |\n| GitHub le nom d’hôte pour Copilot CLI uniquement, remplaçant `GH_HOST`. Utilisez quand `GH_HOST` cible GitHub Enterprise Server, mais Copilot doit s’authentifier contre GitHub.com ou un nom d’hôte GitHub Enterprise Cloud. | |\n| `COPILOT_GITHUB_TOKEN` | Jeton d’authentification. Prend la priorité sur `GH_TOKEN` et `GITHUB_TOKEN`. |\n| `COPILOT_HOME` | Outrepassez le répertoire de configuration et d’état. Par défaut : `$HOME/.copilot`. |\n| `COPILOT_LARGE_OUTPUT_THRESHOLD_BYTES` | Taille maximale d’octets UTF-8 pour la sortie de l’outil retournée directement au modèle. Valeur par défaut : `20480` (20 Kib). Consultez « [Gestion du contexte dans GitHub Copilot CLI](/fr/copilot/concepts/agents/copilot-cli/context-management#managing-large-tool-output) ». |\n| `COPILOT_MCP_TOOL_CACHE` | Définissez sur `false` pour désactiver le chargement et l’enregistrement des instantanés des outils du serveur MCP local pour tout le processus. Consultez la [mise en cache des instantanés de l’outil](#tool-snapshot-caching). |\n| `COPILOT_MODEL` | Définissez le modèle IA. |\n| `COPILOT_PLAN_THEN_AUTOPILOT` | Définissez cette variable sur `1`, `true`, `yes`, ou `on` pour demander le mode planification, puis pilote automatique (équivalent à `--plan --mode autopilot`) pour les environnements d’exécution qui peuvent uniquement injecter des variables d’environnement. Ignoré, avec un avertissement, lorsqu’une option explicite `--autopilot`, `--plan` ou `--mode` est spécifiée. Voir [Plan-then-autopilot](#plan-then-autopilot). |\n| `COPILOT_PROMPT_FRAME` | Définissez sur `1` pour activer le cadre décoratif autour de l’interface utilisateur de l’invite de commande, ou sur `0` pour le désactiver. Remplace l’indicateur `PROMPT_FRAME` de fonctionnalité expérimental pour la session active. |\n| `COPILOT_PROVIDER_API_KEY_COMMAND` | Commande Shell qui imprime une nouvelle clé API BYOK (bring-your-own-key) avant chaque demande de fournisseur. Est prioritaire sur la variable d’environnement `COPILOT_PROVIDER_API_KEY` . La sortie remplace l’en-tête d’authentification correspondant, même si un en-tête personnalisé défini via `COPILOT_PROVIDER_HEADERS` entrerait sinon en conflit. |\n| `COPILOT_PROVIDERS_CONFIG` | Chemin d’accès à un fichier JSON qui définit un fournisseur BYOK (bring-your-own-key) et un registre des modèles, sous la forme d’un objet avec les clés `providers` et `models`. Par défaut : `/providers.json`. Lorsque ce fichier déclare un fournisseur ou un modèle, il est prioritaire sur les variables d’environnement héritées `COPILOT_PROVIDER_*` . Consultez [`providers.json`](/fr/copilot/reference/copilot-cli-reference/cli-config-dir-reference#providersjson). |\n| `COPILOT_SKILLS_DIRS` | Liste de répertoires supplémentaires pour les compétences, séparés par des virgules. |\n| `PLUGINS_DASHBOARD` | Définissez cette option sur `false` pour désactiver le tableau de bord des plug-ins ouvert par les commandes `/plugin`, `/mcp` et `/skills` utilisées seules, ainsi que pour désactiver les commandes non interactives `copilot plugin`/`copilot plugins`. |\n| `COPILOT_STRIP_REASONING_ON_RESUME` | Définissez sur `0` ou `false` pour conserver les jetons de raisonnement BYOK lors de la reprise d’une session au lieu de les supprimer. La valeur par défaut est de les supprimer. |\n| `COPILOT_SUBAGENT_MAX_CONCURRENT` | Nombre maximal de sous-éléments simultanés par session (valeur par défaut : `32`, plage : `1`–`256`). |\n| `COPILOT_SUBAGENT_MAX_DEPTH` | Profondeur maximale d’imbrication des sous-éléments (valeur par défaut : `4`, plage : `1`–`128`). |\n| `COPILOT_TASK_WAIT_TIMEOUT_SECONDS` | Nombre maximal de secondes `-p` (et `-p --autopilot`) pendant lesquelles l’application attend que les agents d’arrière-plan ou les commandes shell en attente se terminent avant de quitter (valeur par défaut : `600` ; `0` se ferme immédiatement sans attendre). |\n| `GH_HOST` | |\n| GitHub nom d’hôte pour les deux GitHub CLI et Copilot CLI (par défaut : `github.com`). Paramétrez sur votre GitHub Enterprise Cloud nom d'hôte de résidence des données. Remplacez par `COPILOT_GH_HOST` pour Copilot CLI uniquement. | |\n| `GH_TOKEN` | Jeton d’authentification. Prend la priorité sur `GITHUB_TOKEN`. |\n| `GITHUB_COPILOT_PROMPT_MODE_EXTENSIONS` | Définissez sur `true` pour charger des extensions de projet et autoriser les outils de gestion des extensions en mode de requête (`-p`). Désactivé par défaut pour empêcher l’exécution du code d’extension contrôlé par le référentiel sans approbation interactive. |\n| `GITHUB_COPILOT_PROMPT_MODE_REPO_HOOKS` | Définissez sur `true` pour charger les hooks de référentiel en mode de requête (`-p`). Les hooks du référentiel se chargent aussi automatiquement lorsque le dossier est déjà considéré comme fiable ou que `COPILOT_ALLOW_ALL` est défini. |\n| `GITHUB_COPILOT_PROMPT_MODE_WORKSPACE_MCP` | Définissez sur `true` pour charger les sources MCP de l’espace de travail en mode de requête (`-p`). Désactivé par défaut pour empêcher le démarrage des serveurs MCP contrôlés par le référentiel sans approbation interactive. |\n| `GITHUB_TOKEN` | Jeton d’authentification. |\n| `PLAIN_DIFF` | Définir sur `true` pour désactiver le rendu enrichi des diffs. |\n| `USE_BUILTIN_RIPGREP` | Définir sur `false`, pour utiliser la version système de ripgrep au lieu de la version fournie. |\n| `USE_TGREP` | Définissez sur `true` pour toujours utiliser [tgrep](http://gfffh3e2b966b640040f3sxv6nxvvcb0nq6kxk.ffgi.yc2.bjmu.edu.cn/microsoft/tgrep), un moteur de recherche indexé par trigrammes, même en dehors d’un dépôt Git ou sur un système de fichiers virtualisé ou en réseau (par exemple, un VFS pour un checkout Git, ou un point de montage SMB/9p), ou sur `false` pour toujours utiliser ripgrep. Lorsqu’il est forcé en dehors d’un référentiel Git, tgrep indexe le répertoire de travail lui-même. Évitez donc de le forcer quelque part à grande échelle, comme votre répertoire de base. Les dossiers Windows synchronisés dans le cloud (par exemple, OneDrive) utilisent toujours ripgrep, même lorsque cette valeur est définie sur `true`. Lorsqu’il n’est pas défini, Copilot CLI bascule automatiquement de ripgrep vers tgrep uniquement à l’intérieur d’un référentiel Git, sur un système de fichiers non virtualisé, et une fois qu’il atteint le seuil de nombre de fichiers défini par `TGREP_FILE_COUNT_THRESHOLD`. La définition `USE_TGREP=true` contourne entièrement ce seuil. |\n| `USE_TGREP=false` désactive toujours tgrep. | |\n| `TGREP_FILE_COUNT_THRESHOLD` | Nombre minimal de fichiers pour la recherche indexée tgrep automatique (entier non négatif ; valeur par défaut : `10000` sur Windows, `50000` ailleurs). Les valeurs non valides reviennent à la plateforme par défaut. |\n| `0` supprime uniquement l’exigence de nombre de fichiers : d’autres vérifications de démarrage automatique s’appliquent toujours. | |\n\n## Paramètres du fichier de configuration\n\nPour plus d’informations sur les paramètres de fichier de configuration, notamment la liste complète des paramètres utilisateur, des paramètres de référentiel, des paramètres locaux et leur cascade, consultez [GitHub Copilot le répertoire de configuration du CLI](/fr/copilot/reference/copilot-cli-reference/cli-config-dir-reference#configuration-file-settings).\n\n## Initialisation du projet pour Copilot\n\nLorsque vous utilisez la commande `copilot init`, ou la commande `/init` de barre oblique dans une session interactive, Copilot analyse votre codebase et écrit ou met à jour un `.github/copilot-instructions.md` fichier dans le référentiel. Ce fichier d’instructions personnalisées contient des instructions spécifiques au projet qui amélioreront les futures sessions CLI.\n\nVous utiliserez `copilot init`généralement , ou `/init`, lorsque vous démarrez un nouveau projet, ou lorsque vous commencez à utiliser Copilot CLI dans un référentiel existant.\n\nLe fichier `copilot-instructions.md` qui est créé ou mis à jour documente généralement :\n\n* Commandes dédiées à la compilation, aux tests et à la vérification de la syntaxe.\n* Architecture de haut niveau.\n* Conventions spécifiques à Codebase.\n\nSi le fichier existe déjà, Copilot suggère des améliorations que vous pouvez choisir d’appliquer ou de rejeter.\n\nL’interface CLI recherche le `copilot-instructions.md` fichier au démarrage et, s’il est manquant, il affiche le message :\n\n> 💡 Aucune instruction copilote n’a été trouvée. Exécutez /init pour générer un fichier copilot-instructions.md pour ce projet.\n\nSi vous ne souhaitez pas créer ce fichier, vous pouvez masquer définitivement ce message de démarrage pour le référentiel actuel à l’aide de la `/init suppress` commande barre oblique.\n\nPour plus d’informations, consultez « [Ajout d’instructions personnalisées de référentiel pour GitHub Copilot](/fr/copilot/how-tos/copilot-on-github/customize-copilot/add-custom-instructions/add-repository-instructions) ».\n\nUtilisez `--sandbox` ou `--no-sandbox` avec `copilot init` pour activer ou désactiver le bac à sable du shell au niveau du système d’exploitation uniquement pour la session d’initialisation, sans modifier votre paramètre de bac à sable enregistré. Ces options sont soumises au même seuil minimal du sandbox géré par l’entreprise que les autres points d’entrée — voir [Seuil minimal du sandbox géré par l’entreprise](#enterprise-managed-sandbox-floor).\n\n### Emplacements des instructions personnalisées\n\nCopilot CLI charge des instructions personnalisées à partir de ces emplacements simultanément (toutes sont fusionnées) :\n\n| Lieu | Remarques |\n| -------------------------------------------------- | ----------------------------------------------------------------- |\n| `CLAUDE.md` | À la racine du dépôt Git et dans le répertoire de travail courant |\n| `GEMINI.md` | À la racine du dépôt Git et dans le répertoire de travail courant |\n| `AGENTS.md` | À la racine du dépôt Git et dans le répertoire de travail courant |\n| `.github/instructions/**/*.instructions.md` | À la racine du dépôt Git et dans le répertoire de travail courant |\n| `.claude/rules/**/*.md` | À la racine du dépôt Git et dans le répertoire de travail courant |\n| `.github/copilot-instructions.md` | À la racine du dépôt Git et dans le répertoire de travail courant |\n| `$HOME/.copilot/copilot-instructions.md` | — |\n| `$HOME/.copilot/instructions/**/*.instructions.md` | — |\n| `COPILOT_CUSTOM_INSTRUCTIONS_DIRS` | Répertoires supplémentaires via une variable d’environnement. |\n\nCopilot CLI lit les fichiers de règle Claude Code de `.claude/rules/**/*.md` la même façon qu’il lit les `.github/instructions/**/*.instructions.md` fichiers. Limiter une règle aux fichiers correspondant à une clé de front matter `paths` (ou `applyTo`) :\n\n```markdown\n---\npaths: \"src/api/**/*.ts\"\ndescription: API layer conventions\n---\n\nUse the shared `ApiError` type for all thrown errors in this directory.\n```\n\n### Importations d’instructions personnalisées\n\nLes fichiers d’instructions prennent en charge `@path` les importations. Préfixez une ligne par `@` suivi d’un chemin d’accès pour inclure le contenu d’un autre fichier. Les chemins d’accès peuvent être relatifs au répertoire du fichier d’instruction ou absolu. Les importations sont résolues de manière récursive, jusqu’à une limite de profondeur, avec des gardes de cycle et de taille. Ceci est pris en charge dans `AGENTS.md`, `CLAUDE.md`et `.github/copilot-instructions.md`.\n\n## Référence des hooks\n\nPour plus d’informations sur les hooks, notamment les formats de configuration de hook, les événements de hook, les charges utiles d’entrée et le contrôle de décision, consultez [Références sur les hooks GitHub Copilot](/fr/copilot/reference/hooks-reference).\n\n## Configuration du serveur MCP\n\nLes serveurs MCP fournissent des outils supplémentaires à l’agent CLI. Configurer des serveurs persistants dans `~/.copilot/mcp-config.json`. Permet `--additional-mcp-config` d’ajouter des serveurs pour une seule session.\n\nLes serveurs locaux (stdio) qui se lancent dans le bac à sable (voir la `/sandbox` commande de barre oblique) affichent un `connected (sandboxed)` état dans `copilot mcp list` et `/mcp list`. Les serveurs distants (HTTP/SSE) ne sont pas isolés localement dans un bac à sable, bien que leurs connexions à partir de l’interface CLI puissent être limitées par la stratégie réseau du bac à sable.\n\n`copilot mcp list` et `/mcp list` marquent un serveur désactivé avec le suffixe `(disabled)` dans la sortie texte, ou `\"enabled\": false` par serveur dans la sortie `--json`.\n`copilot mcp get` affiche une `Status: Enabled`/`Disabled` ligne.\n\nLe fait d’activer ou de désactiver `/sandbox` redémarre uniquement les serveurs MCP locaux (stdio), puisqu’ils sont lancés dans l’environnement isolé. Les serveurs distants (HTTP/SSE) restent connectés.\n\n`/mcp edit ` rejette un serveur provenant de l’espace de travail — c’est-à-dire un serveur défini dans le `.mcp.json` d’un dépôt — au lieu d’ouvrir l’assistant du niveau utilisateur, car l’enregistrement créerait silencieusement une entrée utilisateur de même nom qu’une entrée de l’espace de travail continuerait à masquer. L’erreur nomme le fichier à modifier directement.\n`/mcp delete ` signale le même fichier lorsqu’il est demandé de supprimer un serveur source d’espace de travail.\n\n### `copilot mcp` Sous-commande\n\nPermet `copilot mcp` de gérer les configurations de serveur MCP à partir de la ligne de commande sans démarrer une session interactive.\n\n| Sous-commande | Description |\n| ---------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------- |\n| `list [--json]` | Répertoriez tous les serveurs MCP configurés regroupés par source, y compris les serveurs fournis par plug-in. |\n| `get [--json]` | Afficher la configuration et les outils d’un serveur spécifique. Pour les serveurs fournis par le plug-in, affiche également le nom et la version du plug-in source. |\n| `add [options] [url]` | Ajoutez un serveur à la configuration utilisateur. Écrit dans `~/.copilot/mcp-config.json`. |\n| `enable ` / `disable ` | Activez ou désactivez un serveur par nom. La modification persiste dans la configuration utilisateur et s’applique aux sessions ultérieures. |\n| `remove ` | Supprimez un serveur au niveau de l’utilisateur. Les serveurs d’espace de travail doivent être modifiés directement dans leurs fichiers de configuration. |\n\nPour les serveurs locaux (stdio), fournissez la commande après `--`:\n\n```shell copy\ncopilot mcp add SERVER-NAME -- COMMAND [ARGS...]\n```\n\nPour les serveurs HTTP ou SSE distants, spécifiez le transport et fournissez l’URL :\n\n```shell copy\ncopilot mcp add --transport http SERVER-NAME URL\n```\n\n\\*\\*\n`copilot mcp add` Options:\\*\\*\n\n| Choix | Description |\n| -------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |\n| `-- [args...]` | Commande et arguments pour les serveurs locaux (stdio). |\n| `` | URL des serveurs distants. |\n| `--transport ` | Type de transport : `stdio`, `http`ou `sse`. La valeur par défaut est `stdio`. |\n| `--env KEY=VALUE` | Variable d’environnement (réutilisable). |\n| `--header \"HEADER: VALUE\"` | En-tête HTTP pour les serveurs distants (reproductible). |\n| `--tools ` | Filtre d’outil : `\"*\"` pour tous, une liste séparée par des virgules ou `\"\"` pour aucun. |\n| `--timeout ` | Délai d’expiration en millisecondes pour la découverte d’outils et les appels d’outils. Par défaut : `30000`. Doit être un entier positif sans partie fractionnaire, suffixe d’unité, signe ou exposant, de `1` vers `4294967295`. |\n| `--json` | Afficher la configuration ajoutée au format JSON. |\n| `--show-secrets` | Afficher les valeurs complètes de la variable d’environnement et de l’en-tête. |\n\nDans le `/mcp add`/`/mcp edit` formulaire interactif, entrez le `env` champ sous forme de paires séparées par `KEY=VALUE` des virgules ou en tant qu’objet JSON (par exemple). `{\"API_KEY\":\"secret\"}`\n`$PATH` est inclus par défaut et n’a pas besoin d’être répertorié.\n\n> \\[!CAUTION]\n> `--show-secrets` peut afficher les valeurs sensibles des variables d’environnement et des en-têtes dans votre terminal ou vos logs. Utilisez cette option uniquement dans les environnements approuvés et évitez de copier, coller ou capturer la sortie dans les journaux ou historiques partagés.\n\n### Types de transport\n\n| Type | Description | Champs obligatoires |\n| --------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------ | ------------------- |\n| `local` / `stdio` | Processus local de communication via stdin/stdout. | |\n| `command`, `args` | | |\n| `http` | Serveur distant utilisant le transport HTTP par diffusion en continu. | |\n| `\"streamable-http\"` est également accepté en tant qu’alias et est normalisé à `\"http\"`. | `url` | |\n| `sse` | Un serveur distant utilisant le transport d'événements envoyés par le serveur. | `url` |\n\n### Champs de configuration de serveur local\n\n| Champ | Obligatoire | Description |\n| ------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ----------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |\n| `command` | Oui | Commande pour démarrer le serveur. |\n| `args` | Oui | Arguments de commande (tableau). |\n| `tools` | Oui | Outils à activer : `[\"*\"]` pour tous ou une liste de noms d’outils spécifiques. |\n| `env` | Non | Variables d'environnement. Prend en charge l’expansion de `$VAR`, `${VAR}` et de `${VAR:-default}`. |\n| `cwd` | Non | Répertoire de travail du serveur. |\n| `timeout` | Non | Délai d’expiration en millisecondes pour la découverte d’outils et les appels d’outils. Par défaut : `30000`. |\n| `type` | Non | |\n| `\"local\"` ou `\"stdio\"`. Par défaut : `\"local\"`. | | |\n| `deferTools` | Non | |\n| `\"auto\"` (par défaut) ou `\"never\"`. Définissez sur `\"never\"` pour que les outils de ce serveur restent toujours visibles, même lorsque la recherche d’outils est active. | | |\n| `disableToolCache` | Non | Définissez sur `true` pour ignorer le chargement et l’enregistrement de l’instantané de l’outil pour ce serveur. |\n| `slowConnectionThresholdMs` | Non | Millisecondes avant Copilot CLI d’avertir que ce serveur prend plus de temps que prévu pour se connecter. Par défaut : `10000`. Ce paramètre affecte uniquement lorsque l’avertissement s’affiche : il ne modifie pas le délai d’expiration de la connexion. Doit être un entier positif inférieur ou égal à `2147483647`. |\n\n`slowConnectionThresholdMs` et `timeout` sont indépendants : `timeout` définit le budget réel de connexion (avec un minimum de `60000` ms), tandis que `slowConnectionThresholdMs` contrôle uniquement le moment où Copilot CLI affiche un avertissement pour une connexion toujours en cours. Augmentez `slowConnectionThresholdMs` pour rendre silencieuses les liaisons lentes attendues, par exemple pour les serveurs derrière un flux d’authentification, sans étendre le temps imparti aux appels d’outils.\n\n### Mise en cache des instantanés de l’outil\n\nCopilot CLI conserve un instantané de la liste des outils de chaque serveur local afin que les outils soient disponibles immédiatement au démarrage pendant que la découverte dynamique se termine en arrière-plan. La découverte en direct s’exécute toujours et remplace l’instantané une fois terminée.\n\nDéfinissez `disableToolCache: true` sur un serveur pour forcer la découverte en direct uniquement pour ce serveur, ou définissez la variable d’environnement `COPILOT_MCP_TOOL_CACHE=false` pour désactiver le chargement et la persistance des instantanés pour l’ensemble du processus. Les deux opt-outs conservent les fichiers de cache existants non touchés.\n\n### Registre npm privé\n\nUtilisez `--registry` dans le `args` tableau pour extraire un package à partir d’un registre npm privé, par exemple, Artifactory ou un GitHub flux Packages :\n\n```json\n{\n \"mcpServers\": {\n \"my-internal-server\": {\n \"command\": \"npx\",\n \"args\": [\n \"--registry\", \"http://gfffhc71d606c01764a0csxv6nxvvcb0nq6kxk.ffgi.yc2.bjmu.edu.cn\",\n \"@my-org/internal-mcp-server\"\n ],\n \"tools\": [\"*\"]\n }\n }\n}\n```\n\nL’option `--registry` et les autres options de configuration npm (`--userconfig`, `--globalconfig`, `--prefix`, `--cache``--node-options`, `--workspace`, ) `-w`sont traitées comme des arguments consommant des valeurs lors de l’informatique de l’empreinte digitale de l’identité du serveur. Cela garantit que les vérifications de la liste d’autorisation de l’entreprise et du registre fonctionnent correctement lorsque ces options figurent avant le nom du paquet.\n\n### Champs de configuration de serveur distant\n\n| Champ | Obligatoire | Description |\n| ------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ----------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |\n| `type` | Oui | |\n| `\"http\"` ou `\"sse\"` (`\"streamable-http\"` est également accepté en tant qu’alias pour `\"http\"`). | | |\n| `url` | Oui | URL du serveur. |\n| `tools` | Oui | Outils à activer. |\n| `headers` | Non | En-têtes HTTP. Prend en charge l’expansion des variables. |\n| `oauthClientId` | Non | ID client OAuth statique (ignore l’inscription dynamique). |\n| `oauthScopes` | Non | Tableau non vide de jetons de portée OAuth à requérir. Exige `oauthClientId`. Une portée non vide dans le challenge du serveur `WWW-Authenticate` reste prioritaire ; sinon, cela prévaut sur les métadonnées `scopes_supported` découvertes. |\n| `oauthPublicClient` | Non | Indique si le client OAuth est public. Par défaut : `true`. Défini sur `false` pour les clients confidentiels avec un secret stocké. |\n| `oauthGrantType` | Non | Type d’octroi OAuth : `\"authorization_code\"` (par défaut, flux basé sur le navigateur) ou `\"client_credentials\"` (entièrement sans tête, aucun navigateur ni rappel). |\n| `oidc` | Non | Activez l’injection de jeton OIDC. Quand `true`, l'interface CLI injecte des jetons OIDC pour toute variable `GITHUB_COPILOT_OIDC_MCP_TOKEN``GITHUB_COPILOT_OIDC_MCP_TOKEN_` référencée dans le bloc du serveur (serveurs locaux) ou envoie le jeton comme en-tête `env``Bearer` (serveurs distants). Pour les serveurs locaux, préférez les variantes suffixees (par exemple `${GITHUB_COPILOT_OIDC_MCP_TOKEN_MY_SVC}`) pour affecter un nom de variable unique par serveur. |\n| `timeout` | Non | Délai d’expiration en millisecondes pour la découverte d’outils et les appels d’outils. Par défaut : `30000`. |\n| `deferTools` | Non | |\n| `\"auto\"` (par défaut) ou `\"never\"`. Définissez sur `\"never\"` pour que les outils de ce serveur restent toujours visibles, même lorsque la recherche d’outils est active. | | |\n| `slowConnectionThresholdMs` | Non | Millisecondes avant Copilot CLI d’avertir que ce serveur prend plus de temps que prévu pour se connecter. Par défaut : `10000`. Ce paramètre affecte uniquement lorsque l’avertissement s’affiche : il ne modifie pas le délai d’expiration de la connexion. Doit être un entier positif inférieur ou égal à `2147483647`. |\n\n### Réauthentification OAuth\n\nLes serveurs MCP distants qui utilisent OAuth peuvent afficher un `needs-auth` état lorsqu’un jeton expire ou lorsqu’un autre compte est requis. Utilisez `/mcp auth ` pour déclencher un nouvel flux OAuth. Cela ouvre une invite d’authentification du navigateur, ce qui vous permet de vous connecter ou de changer de compte. Une fois le flux terminé, le serveur se reconnecte automatiquement.\n\nSous Windows, les serveurs MCP distants protégés par Microsoft Entra ID s’authentifient plutôt via le courtier d’authentification du système d’exploitation (Gestionnaire de comptes Web), généralement sans invite. Sur Linux et macOS, où aucun courtier système n’existe, la CLI génère discrètement un jeton par ressource à partir du compte Entra établi via `/login` → Microsoft Entra. Si ce compte ne peut pas satisfaire silencieusement la demande( par exemple, aucune identité Entra connectée, un compte ambigu ou une ressource pré-autorisée pour un autre client), la connexion revient au flux de navigateur décrit ci-dessus. Le fait de passer `--device-code` contourne le broker et force le flux de code d’appareil OAuth plutôt que le flux du navigateur, et les machines Windows sans la bibliothèque broker reviennent également au flux du navigateur.\n\n### WorkIQ issu du compte\n\nLa connexion avec un compte Microsoft Entra rend le serveur WorkIQ MCP hébergé disponible dans `/mcp`. Elle est désactivée par défaut. La découverte seule ne se connecte pas, n’acquiert pas de jeton et n’expose pas d’outils : activez-la avec les contrôles MCP normaux (`/mcp enable WorkIQ` ou `copilot mcp enable WorkIQ`) pour essayer d’abord l’authentification silencieuse.\n`/mcp auth WorkIQ` reste disponible pour la récupération.\n\nLe serveur utilise des informations d’identification liées au compte Entra qui s’est connecté, et non un jeton émis pour un autre service, et son activation est liée à cette identité Entra plutôt qu’à un autre compte. La configuration et la désactivation explicites du serveur, ainsi que la stratégie de liste verte ou de liste de refus de l’organisation, sont toujours prioritaires. Aucune entrée WorkIQ n’est enregistrée dans `mcp-config.json`. Cela n’est pas lié à l’exécution `npx @microsoft/workiq mcp` en tant que serveur stdio authentifié indépendamment.\n\n### OAuth sans interface (autorisation `client_credentials`)\n\nPour les cas d’utilisation ci ou cron où aucun navigateur n’est disponible, définissez `oauthGrantType: \"client_credentials\"`. Cela nécessite :\n\n* `oauthClientId`: ID client statique émis par le fournisseur MCP.\n* `oauthPublicClient: false`— le client est confidentiel.\n* Un `client_secret` stocké dans le trousseau système (configuré une fois via l’interface utilisateur `/mcp` ou en écrivant dans le magasin de jetons OAuth).\n\nQuand elle est configurée, l’interface CLI ignore entièrement le navigateur, le serveur de rappel, PKCE et l’inscription dynamique du client. À chaque réponse 401, il envoie `grant_type=client_credentials` directement vers le point de terminaison de jeton détecté du serveur.\n\n```json\n{\n \"mcpServers\": {\n \"headless-api\": {\n \"type\": \"http\",\n \"url\": \"http://gfffhcaae69729a4f4704sxv6nxvvcb0nq6kxk.ffgi.yc2.bjmu.edu.cn/mcp\",\n \"tools\": [\"*\"],\n \"oauthClientId\": \"YOUR-CLIENT-ID\",\n \"oauthPublicClient\": false,\n \"oauthGrantType\": \"client_credentials\"\n }\n }\n}\n```\n\n### Mappage de filtres\n\nContrôlez la façon dont la sortie de l’outil MCP est traitée à l’aide du champ dans la `filterMapping` configuration d’un serveur.\n\n| Mode | Description |\n| ------------------- | --------------------------------------------------------- |\n| `none` | Aucun filtrage. |\n| `markdown` | Formater la sortie en Markdown. |\n| `hidden_characters` | Supprimez les caractères masqués ou de contrôle. Default. |\n\n### Serveurs MCP intégrés\n\nL’interface CLI inclut des serveurs MCP intégrés disponibles sans configuration supplémentaire.\n\n| Serveur | Description |\n| ----------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------- |\n| `github-mcp-server` | |\n| GitHub Intégration de l’API : problèmes, pull requests, étiquettes, commits, recherche de code et GitHub Actions. | |\n| `playwright` | Automatisation du navigateur : naviguez, cliquez, tapez, capture d’écran et gestion des formulaires. |\n| `fetch` | Requêtes HTTP via l’outil `fetch` . |\n| `time` | Utilitaires de temps : `get_current_time` et `convert_time`. |\n\nPermet `--disable-builtin-mcps` de désactiver tous les serveurs intégrés ou `--disable-mcp-server SERVER-NAME` de désactiver un serveur spécifique.\n\nLes serveurs intégrés apparaissent dans `copilot mcp list`, `copilot mcp get`et l’affichage interactif `/mcp` en même temps que les serveurs utilisateur, espace de travail et plug-in.\n\n#### GitHub Outils serveur MCP\n\nLe `github-mcp-server` fournit les outils suivants.\n\n| Tools | Description |\n| -------------------------------------------------------------- | -------------------------------------- |\n| `get_file_contents`, `search_code` | Parcourez les fichiers du référentiel. |\n| `list_issues``issue_read``search_issues` | Suivi des problèmes. |\n| `get_pull_request``list_pull_requests``get_pull_request_files` | Demandes de tirage |\n| `list_commits`, `get_commit` | Historique des commits. |\n| `list_workflow_runs`, `get_workflow_run_logs` | GitHub Actions |\n| `get_label``list_label``label_write` | Gestion des étiquettes. |\n\n### Découverte de ressources\n\nDisponible uniquement en mode expérimental. Lorsqu’une fonctionnalité locale est manquante, l’agent peut rechercher dans un catalogue distant des serveurs et compétences MCP publics à ajouter, à l’aide d’une compétence intégrée `discover-resources` . La compétence interroge le catalogue pour les serveurs MCP classés par pertinence et les compétences correspondant à une fonctionnalité abstraite (par exemple, « accès à la base de données » ou « diagrammes d’architecture »), puis présente les candidats parmi lesquels vous pouvez choisir. La compétence elle-même n’installe rien. Les tableaux de bord `/plugin`, `/skills` et `/mcp` incluent également une recherche dans le catalogue par saisie qui intègre les mêmes résultats distants à la liste locale des ressources.\n\n### Nommage du serveur MCP\n\nLes noms de serveur peuvent contenir tous les caractères imprimables, y compris les espaces, les caractères Unicode et la ponctuation. Les caractères de contrôle (U+0000-U+001F, U+007F) et l’accolade fermante (`}`) ne sont pas autorisés. Les noms de serveur sont utilisés comme préfixes pour les noms d’outils , par exemple, un serveur nommé `my-server` produit des noms d’outils comme `my-server-fetch`, et un serveur nommé `My Server` produit `My Server-fetch`.\n\n### Assainissement du nom de l’outil MCP\n\nLes noms de serveurs MCP et les noms d’outils sont nettoyés avant d’être envoyés au modèle. Les caractères non valides dans les noms d’outils (autre que `a-z`, , `A-Z``0-9`, `-`, `_`) sont remplacés par `-`. Les caractères Unicode sont codés en Punycode. Le `@` symbole est également remplacé par `-` pour éviter les conflits avec l’encodage Punycode.\n\nLe nom combiné (`serverName-toolName`) est limité à 64 caractères. Lorsque la troncation crée une collision de noms, un suffixe numérique est ajouté (par exemple, `my-server-tool2`, `my-server-tool3`) pour garantir l’unicité.\n\n### Niveaux d’approbation du serveur MCP\n\nLes serveurs MCP sont chargés à partir de plusieurs sources, chacun avec un niveau de confiance différent.\n\n| Origine | Niveau de confiance | Révision requise |\n| -------------------------------------------------------- | ------------------- | ------------------------------- |\n| Intégré | Élevé | Non |\n| Référentiel (`.github/mcp.json`) | Moyenne | Recommandé |\n| Espace de travail (`.mcp.json`) | Moyenne | Recommandé |\n| Configuration utilisateur (`~/.copilot/mcp-config.json`) | User-defined | Responsabilité de l’utilisateur |\n| Serveurs distants | Faible | Toujours |\n\nTous les appels d’outils MCP nécessitent une autorisation explicite. Cela s’applique même aux opérations en lecture seule sur les services externes.\n\n### Priorité de chargement du serveur MCP\n\nLes serveurs MCP provenant de différentes sources sont fusionnés dans l’ordre de priorité (le plus élevé en premier). Lorsque les serveurs partagent un nom, la source de priorité supérieure est prioritaire.\n\n1. `--additional-mcp-config` option (la plus élevée)\n2. Serveurs fournis par le plug-in\n3. Serveurs de l’espace de travail : `.mcp.json` et `.github/mcp.json` chargés depuis le répertoire de travail jusqu’à la racine Git ; nécessite que le dossier soit approuvé\n4. `~/.copilot/mcp-config.json` (plus bas)\n\n> \\[!NOTE]\n> Les serveurs MCP de l’espace de travail (`.mcp.json` et `.github/mcp.json`) sont chargés lors des sessions interactives et des sessions en mode serveur du SDK, à condition que le répertoire de travail soit fiable. Pour plus d’informations sur la confiance accordée aux dossiers, consultez [Autorisation et refus de l’utilisation de l’outil](/fr/copilot/how-tos/copilot-cli/use-copilot-cli/allowing-tools).\n\nSi un fichier de configuration d’espace de travail contient une entrée de serveur non valide, l’interface CLI ignore uniquement cette entrée et continue de charger ses frères valides, en imprimant `Warning: workspace MCP config \"\": ` pour chaque entrée ignorée. Un fichier mal formé ou non lisible (JSON non valide ou une structure de niveau supérieur non valide) est toujours ignoré entièrement.\n\n### Liste d'autorisation MCP d'entreprise\n\nGitHub Enterprise les organisations peuvent appliquer une liste verte de serveurs MCP autorisés. Lorsqu’elle est active, l’interface CLI évalue chaque serveur non par défaut par rapport à la stratégie d’entreprise avant de se connecter.\n\nLorsqu’une GitHub Enterprise stratégie de registre est détectée (ou que l’indicateur `MCP_ENTERPRISE_ALLOWLIST` de fonctionnalité expérimentale est activé), l’interface CLI :\n\n1. Calcule une empreinte digitale pour chaque serveur non par défaut configuré en fonction de sa commande, de ses arguments et de son URL distante.\n2. Envoie les empreintes digitales au point de terminaison d'évaluation de la liste d'autorisation de l'entreprise.\n3. Autorise uniquement les serveurs dont les empreintes digitales sont approuvées ; tous les autres sont bloqués avec un message nommant l’entreprise.\n\nCette vérification échoue : si le point de terminaison d’évaluation est inaccessible ou retourne une erreur, les serveurs non par défaut sont bloqués jusqu’à ce que la stratégie puisse être vérifiée.\n\nLorsqu’un serveur est bloqué par une liste d’autorisation d’entreprise, le CLI affiche :\n\n```text\nMCP server \"SERVER-NAME\" was blocked by your enterprise \"ENTERPRISE-NAME\".\nContact your enterprise administrator to add this server to the allowlist.\n```\n\nLes serveurs par défaut intégrés sont toujours exemptés de l'application des règles de la liste de permis.\n\n### Migration à partir de `.vscode/mcp.json`\n\nSi votre projet utilise `.vscode/mcp.json` (format de configuration MCP de VS Code), migrez vers `.mcp.json`GitHub Copilot CLI . La migration remapise la `servers` clé sur `mcpServers`.\n\n**Coquilles POSIX (bash, zsh, poisson, etc.) :**\n\n```shell\njq '{mcpServers: .servers}' .vscode/mcp.json > .mcp.json\n```\n\nNécessite [`jq`](http://gfffha41c2c28869c412csxv6nxvvcb0nq6kxk.ffgi.yc2.bjmu.edu.cn/jq/).\n\n**PowerShell** :\n\n```powershell\npwsh -NoProfile -Command \"`$json = Get-Content '.vscode/mcp.json' -Raw | ConvertFrom-Json; `$content = ([pscustomobject]@{ mcpServers = `$json.servers } | ConvertTo-Json -Depth 100); [System.IO.File]::WriteAllText('.mcp.json', `$content, (New-Object System.Text.UTF8Encoding `$false))\"\n```\n\nSur Windows, remplacez `pwsh` par `powershell` si vous utilisez Windows PowerShell au lieu de PowerShell Core.\n\n### Sortie du serveur Stdio\n\nLe transport stdio MCP réserve stdout exclusivement pour les trames JSON-RPC délimitées par la ligne. L’interface CLI filtre automatiquement toutes les lignes non JSON (journaux de texte brut, traces de pile d’exceptions ou lignes d’espace blanc uniquement) avant de passer la sortie à l’analyseur de protocole.\n\nÉcrivez toutes les sorties de diagnostic dans **stderr**, et non stdout. Un serveur qui écrit des journaux d’activité ou des messages d’erreur dans stdout peut déclencher une boucle de commentaires d’erreur d’analyse qui bloque l’établissement d’une liaison d’initialisation ; le filtre empêche cela en supprimant silencieusement des images non JSON.\n\nLes lignes de plus de 1 Mo contournent la vérification structurelle et sont transmises telles quelles, afin d’éviter de fractionner ou de supprimer des trames de protocole surdimensionnées mais valides (par exemple, une réponse `tools/list` volumineuse).\n\n## Informations de référence sur les compétences\n\nLes compétences sont des fichiers Markdown qui étendent ce que l’interface CLI peut faire. Chaque compétence se trouve dans son propre répertoire contenant un `SKILL.md` fichier. Lorsqu’elle est appelée (via `/SKILL-NAME` ou automatiquement par l’agent), le contenu de la compétence est injecté dans la conversation.\n\n### Champs de frontmatter des compétences\n\n| Champ | Type | Obligatoire | Description |\n| -------------------------- | ------------------- | ----------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |\n| `name` | ficelle | Oui | Identificateur unique de la compétence. Doit commencer par une lettre ou un chiffre et contenir uniquement des lettres, des chiffres, des traits d’union, des caractères de soulignement, des points, des deux-points et des espaces. 64 caractères maximum. Les deux-points permettent les noms qualifiés (par exemple, `my-plugin:search`). |\n| `description` | ficelle | Oui | Que fait la compétence et quand l’utiliser. Nombre maximal de 1024 caractères. |\n| `argument-hint` | ficelle | Non | Indicateur de forme libre décrivant les arguments attendus, affichés dans le sélecteur de compétences (par exemple). `\"[target] [mode]\"` |\n| `allowed-tools` | chaîne ou chaîne\\[] | Non | Liste séparée par des virgules ou tableau YAML d’outils qui sont automatiquement autorisés lorsque la compétence est active. Utiliser `\"*\"` pour tous les outils. |\n| `user-invocable` | booléen | Non | Indique si les utilisateurs peuvent appeler la compétence avec `/SKILL-NAME`. Par défaut : `true`. |\n| `disable-model-invocation` | booléen | Non | Empêcher l'agent d'activer automatiquement cette fonctionnalité. Par défaut : `false`. |\n\n### Emplacements des compétences\n\nLes compétences sont chargées depuis ces emplacements par ordre de priorité (la première trouvée l’emporte en cas de noms en double).\n\n| Lieu | Étendue | Description |\n| ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------- |\n| `.github/skills/` | Projet | Compétences spécifiques au projet |\n| `.agents/skills/` | Projet | Autre emplacement du projet. |\n| `.claude/skills/` | Projet | Emplacement compatible avec Claude. |\n| Parent `.github/skills/` | Inherited | Prise en charge du répertoire parent d’un monorepo. |\n| `~/.copilot/skills/` | Personnel | Compétences personnelles pour tous les projets. |\n| `~/.agents/skills/` | Personnel | Compétences de l’agent partagées entre tous les projets. |\n| Répertoires de plug-in | Plug-in | Compétences des plug-ins installés. |\n| `COPILOT_SKILLS_DIRS` | Personnalisée | Répertoires supplémentaires (séparés par des virgules). |\n| `--add-dir ` | Ajout de la racine | |\n| `.github/skills/` sous les répertoires ajoutés avec `--add-dir`, `/add-dir` ou le `additionalDirectories` du SDK. Il s’agit d’une décision d’approbation : les compétences ajoutées s’exécutent avec la même confiance que les compétences du projet. | | |\n| (groupé avec l’Interface en Ligne de Commande) | Intégré | Compétences fournies avec l’interface CLI. Priorité la plus basse : substituable par n’importe quelle autre source. |\n| (org/enterprise) | Remote | Compétences hébergées par votre organisation ou votre entreprise, projetées via le relais AHP. Le contenu est récupéré à la demande lorsque la compétence est appelée. |\n\nLes compétences distantes sont projetées en même temps que les compétences locales et suivent la même priorité basée sur le nom lorsqu’une compétence locale porte le même nom.\n\nUtilisez le paramètre `ignoredSkillsLocations` pour exclure des répertoires spécifiques (et leurs descendants) lors de la découverte, quel que soit l’emplacement ci-dessus qui les ferait autrement découvrir. Consultez « [GitHub Copilot le répertoire de configuration du CLI](/fr/copilot/reference/copilot-cli-reference/cli-config-dir-reference#configuration-file-settings) ».\n\nLorsque deux plug-ins fournissent des compétences portant le même nom, elles coexistent toutes deux à l’aide de noms d’appel qualifiés par le plug-in, tels que `/my-plugin/search` et `/other-plugin/search`. Le nom simple est redirigé vers le plug-in ayant la priorité la plus élevée. Cela s’applique uniquement aux compétences ; les commandes conservent la déduplication basée sur les niveaux standard, où la source de priorité supérieure gagne.\n\n### Gestion des compétences non interactives\n\nPermet `copilot skill` de gérer les compétences à partir de la ligne de commande sans ouvrir une session interactive.\n\n| Sous-commande | Description |\n| ---------------------------------- | ----------------------------------------------------------------------------------------------------------------------- |\n| `list [--json]` | Répertoriez toutes les compétences découvertes. |\n| `add [--project]` | Ajoutez une compétence à partir d’un chemin d’accès de fichier, d’une URL ou d’un répertoire. |\n| `remove ` | Supprimez une compétence personnelle ou de projet ou annulez l’inscription d’un répertoire de compétences personnalisé. |\n| `enable ` / `disable ` | Activez ou désactivez une compétence par nom. |\n\n```bash\n# Install a skill for your user account (default)\ncopilot skill add ./my-skill/SKILL.md\n\n# Install a skill into the current project (.github/skills; file or URL skills only)\ncopilot skill add --project ./my-skill/SKILL.md\n\n# Enable, disable, or remove a skill by name\ncopilot skill enable my-skill\ncopilot skill disable my-skill\ncopilot skill remove my-skill\n```\n\nL’installation d’un répertoire l’inscrit en tant que source de compétence personnalisée plutôt que de la copier. L’installation d’un fichier ou d’une URL copie le contenu de la compétence dans votre répertoire de compétences personnelles ou de projet. La commande interactive équivalente est `/skills add [--project] `.\n\n`copilot skill list --json` les lignes ont la forme `{ name, description, source, path, enabled }`. Avec `remove`, passez un nom de compétence ou le chemin d’accès à un répertoire de compétences personnalisé que vous avez ajouté : un nom de compétence supprime les fichiers de cette compétence, tandis qu’un chemin d’accès de répertoire personnalisé annule l’inscription du répertoire et laisse ses fichiers sur le disque. Seules les compétences personnelles et de projet que vous avez ajoutées peuvent être supprimées ; les compétences fournies par un plug-in ou l’ensemble intégré ne peuvent pas être supprimées de cette façon (désactivez-les à la place). Cela remplace les éléments retirés `copilot plugins install --skill [--scope project]` et `copilot plugins remove/enable/disable --skill`.\n\n### Commandes (autre format de compétence)\n\nLes commandes sont une alternative aux compétences stockées en tant que fichiers individuels `.md` dans `.claude/commands/`. Le nom de la commande est dérivé du nom de fichier. Les fichiers de commande utilisent un format simplifié (aucun champ `name` requis) et prennent en charge `argument-hint`, `description`, `allowed-tools` et `disable-model-invocation`. Les commandes ont une priorité inférieure à celle des compétences portant le même nom.\n\n## Référence des assistants personnalisés\n\nLes agents personnalisés sont des agents IA spécialisés définis dans les fichiers Markdown. Pour les agents utilisateur, de projet et de racine ajoutée, l’ID de l’agent est dérivé du chemin du fichier par rapport au répertoire `agents`. L’interface de ligne de commande supprime l’extension `.agent.md` ou `--` et remplace les séparateurs de répertoires par `.md`. Par exemple, `agents/team/reviewer.agent.md` a l’ID `team--reviewer`.\n\n### Agents intégrés\n\n| Agent | Modèle par défaut | Description |\n| ----------------- | ------------------------------------------------------------ | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |\n| `code-review` | claude-sonnet-4.6 | Revue de code à fort rapport signal/bruit. Analyse les différences pour les bogues, les problèmes de sécurité et les erreurs logiques. Ne modifie pas le code. |\n| `explore` | gpt-5.4-mini | Exploration de base de code rapide. Recherche des fichiers, lit le code et répond aux questions. Retourne des réponses ciblées inférieures à 300 mots. Peut être exécuté en parallèle en toute sécurité. |\n| `general-purpose` | claude-sonnet-4.6 | Agent de capacité complète pour les tâches multi-étapes complexes. S’exécute dans une fenêtre contextuelle distincte. |\n| `research` | claude-haiku-4.5 | Exécute des recherches approfondies en fonction des instructions. Recherche des GitHub référentiels, extrait des fichiers, vérifie les revendications et signale des résultats détaillés avec des citations. |\n| `rubber-duck` | modèle complémentaire | Utilisez un modèle complémentaire pour fournir une critique constructive des propositions, des conceptions, des implémentations ou des tests. Identifie les points faibles et suggère des améliorations. Consultez « [Obtenir un deuxième avis avec l’agent Rubber Duck](/fr/copilot/concepts/agent-capabilities/choosing-and-delegating-agent-work/getting-a-second-opinion) ». |\n| `security-review` | claude-sonnet-4.6 | Révision du code axée sur la sécurité. Analyse les modifications pour les vulnérabilités à haut niveau de confiance entre 11 catégories. Signale uniquement les problèmes dont le niveau de confiance quant à leur exploitabilité est supérieur à 80 %. Signale la gravité et les scores de confiance. Ne modifie pas le code. |\n| `task` | gpt-5.6-luna (revient à gpt-5.4-mini, puis claude-haiku-4.5) | Exécution de commandes (tests, builds, lints). Retourne un résumé bref en cas de réussite, et la sortie complète en cas d’échec. |\n\n`code-review` et `security-review` ne transfèrent jamais un examen complet à un autre agent d’examen : le fait d’en lancer un répond déjà à une demande d’« utiliser » ou d’« appeler » un réviseur ; il effectue donc lui-même l’examen au lieu de déléguer l’ensemble de la tâche à un sous-agent imbriqué `code-review` ou `security-review`, de manière récursive, tout au long de la chaîne de délégation.\n`code-review` transfère toujours au spécialiste dédié `security-review` les parties d’une demande axées sur la sécurité, et les deux agents peuvent déléguer des tâches ciblées de recherche d’informations, définies de manière indépendante, à des agents qui ne sont pas chargés de la révision, tels que `explore`.\n\nSeul l’agent racine peut appeler `store_memory` ou `vote_memory` pour sauvegarder une mémoire ou voter pour celle-ci. Les sous-agents conservent un accès en lecture aux mémoires stockées via `read_memories`, mais ne peuvent pas y écrire ni voter sur celles-ci.\n\n### Champs frontmatter personnalisés d’assistant\n\n| Champ | Type | Obligatoire | Description |\n| ------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------- | ----------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |\n| `description` | ficelle | Oui | Description affichée dans la liste des agents et l'outil `task`. |\n| `include-custom-instructions` | booléen | Non | Incluez les fichiers d’instructions du référentiel (`copilot-instructions.md`, `AGENTS.md`, `CLAUDE.md`) lorsque cet agent s’exécute en tant que sous-agent. Par défaut : `false`. Consultez [les instructions personnalisées du dépôt pour les sous-agents](#repository-custom-instructions-for-subagents). |\n| `infer` | booléen | Non | Autoriser la délégation automatique par l’agent principal. Par défaut : `true`. |\n| `mcp-servers` | objet | Non | Serveurs MCP à connecter. Utilise le même schéma que `~/.copilot/mcp-config.json`. |\n| `model` | ficelle | Non | Modèle IA pour cet agent. Lorsqu’il n’est pas défini, hérite du modèle de l’assistant parent. Lorsque le modèle de session est défini `Auto` sur (serveur sélectionné), les sous-éléments héritent toujours du modèle de session résolu, quel que soit ce champ. |\n| `models` | chaîne de caractères\\[] | Non | Modèles créés dans l’ordre de priorité. Le runtime utilise le premier modèle que le plan de l’utilisateur peut accéder ; si aucune résolution n’est résolue, la répartition revient au modèle de la session. Remplace `model` lorsque les deux sont définis. |\n| `modelPolicy` | ficelle | Non | |\n| `\"preferred\"` (par défaut) permet de remplacer `model`/`models` par une substitution `subagents` dans `~/.copilot/settings.json` ou dans le sélecteur `/subagents`. | | | |\n| `\"required\"` verrouille l’envoi vers l’un des modèles définis ; les surcharges sont rejetées et l’entrée **Model** du sélecteur est désactivée. | | | |\n| `name` | ficelle | Non | Nom complet. Vous pouvez également utiliser cette valeur pour sélectionner l’agent, par exemple avec `--agent`. La valeur par défaut est l’ID de l’agent. |\n| `reasoningEffort` | ficelle | Non | Effort de raisonnement par défaut pour cet agent (par exemple, `\"low\"`, `\"medium\"`ou `\"high\"`). Lorsque ce paramètre n’est pas défini, il hérite du niveau d’effort de l’assistant parent. |\n| `tools` | chaîne de caractères\\[] | Non | Outils disponibles pour l’agent. Valeur par défaut : `[\"*\"]` (tous les outils). Incluez `*` n’importe où dans la liste pour accorder un accès complet aux outils ; par exemple, `[\"view\", \"*\"]` donne accès à tous les outils, et pas seulement à `view`. |\n\n`model`, `models`, `modelPolicy` et `reasoningEffort` s’appliquent, que l’agent soit déployé à l’aide de l’outil `task` ou démarré directement — par exemple, via la `session.startSubagent` du SDK. Le modèle et l’effort sont déterminés selon l’ordre de priorité suivant, du plus élevé au plus faible : une valeur explicite par appel, la valeur de substitution / dans /, le champ `reasoningEffort``model``models``~/.copilot/settings.json``subagents` de la définition de l’agent, puis la valeur de la session parente. Un modèle ou un niveau d’effort déclaré qui ne peut pas être respecté retombe sur la valeur de la session au lieu de faire échouer la répartition, sauf si l’agent déclare `modelPolicy: \"required\"`, auquel cas la répartition est refusée plutôt que de remplacer silencieusement par un modèle non spécifié.\n\n### Emplacements d’agent personnalisés\n\nL’interface CLI charge les agents personnalisés dans l’ordre de priorité suivant. Lorsque les agents ont le même identifiant, le premier agent chargé est utilisé.\n\n| Priority | Étendue | Lieu |\n| ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------ | ------------------------------------- |\n| 1 (plus élevé) | Utilisateur | `~/.copilot/agents/` |\n| 2 | Projet | |\n| `.github/agents/`, du répertoire de travail actuel vers le haut à la racine Git | | |\n| 3 | Projet | |\n| `.claude/agents/`, du répertoire de travail actuel vers le haut à la racine Git | | |\n| 4 | Ajout de la racine | |\n| `.github/agents/` sous un répertoire ajouté avec `--add-dir`, `/add-dir` ou avec le `additionalDirectories` du SDK. L’ajout du répertoire est une décision de confiance : ses agents sont chargés comme configuration de confiance. | | |\n| 5 | Plug-in | `/agents/` |\n| 6 (plus bas) | Remote | Agents d’entreprise ou d’organisation |\n\nAu sein de chaque ligne de projet, l’interface CLI vérifie d’abord le répertoire de travail actif, puis chaque répertoire parent jusqu’à la racine Git, de sorte que le répertoire le plus profond a la priorité la plus élevée. Chaque répertoire de projet `.github/agents/` est chargé avant tout répertoire de projet `.claude/agents/` . Cela signifie que chaque paquet ou sous-répertoire d’un monorepo peut fournir ses propres agents.\n\nLe champ frontmatter facultatif `name` ne contrôle pas la déduplication. Les agents ayant le même `name` mais des ID différents se chargent tous les deux. Si la valeur transmise à `--agent` correspond à l’ID de plusieurs agents ou à `name`, l’interface de ligne de commande utilise le premier agent correspondant dans l’ordre de priorité ci-dessus.\n\n### Instructions personnalisées du dépôt pour les sous-agents\n\nUn agent personnalisé créé en tant que sous-agent — via l’outil `task` ou le `session.startSubagent` du SDK — ne reçoit pas par défaut les fichiers d’instructions du dépôt (`copilot-instructions.md`, `AGENTS.md`, `CLAUDE.md`). Définissez `include-custom-instructions: true` dans son frontmatter pour l’activer :\n\n```markdown\n---\nname: RepoAwareReviewer\ndescription: Reviews a change against this repository's conventions\ntools: [\"*\"]\ninclude-custom-instructions: true\n---\n\nReview the change and flag anything that violates the repository's conventions.\n```\n\n| Agent | Reçoit les instructions du dépôt |\n| ------------------------------------------------------------------------------------ | --------------------------------------------------- |\n| Agent de session (agent par défaut ou agent personnalisé sélectionné avec `--agent`) | Oui |\n| `general-purpose` sous-agent | Oui |\n| Sous-agents intégrés `explore`, `task` et `code-review` | Non |\n| Agent personnalisé créé en tant que sous-agent | Uniquement avec `include-custom-instructions: true` |\n\nLorsqu’un sous-agent a `include-custom-instructions: true`, il lit les propres fichiers d’instructions de votre référentiel (`copilot-instructions.md`, , `AGENTS.md``CLAUDE.md`). Il n’hérite pas des répertoires d’instructions supplémentaires que vous avez chargés uniquement pour la session principale( par exemple, un répertoire personnel auquel `COPILOT_CUSTOM_INSTRUCTIONS_DIRS`vous avez signalé la session. Le lancement d’une session avec `--no-custom-instructions` a toujours la priorité : lorsque vous utilisez cette option, aucun agent ne reçoit les instructions du dépôt, même un agent qui définit `include-custom-instructions: true`. Activez uniquement le paramètre pour les agents qui doivent suivre les conventions de votre référentiel, telles qu’un agent qui passe en revue ou modifie du code. Les instructions du dépôt s’ajoutent à ce qu’un agent doit traiter chaque fois qu’il s’exécute. Laisser ce paramètre désactivé pour les agents qui n’en ont pas besoin — par exemple, un agent qui recherche uniquement des fichiers ou résume des textes — permet donc à ces agents de s’exécuter plus rapidement et à moindre coût.\n\nPour plus d’informations, consultez « [Création et utilisation d’agents personnalisés pour GitHub Copilot CLI](/fr/copilot/how-tos/copilot-cli/customize-copilot/create-custom-agents-for-cli) ».\n\n### Communication de l’agent\n\nUtilisez `list_agents` et `write_agent` dans des agents personnalisés pour inspecter les agents à proximité et coordonner le travail dans une session multi-agents.\n\n#### Étiquettes de relation dans `list_agents`\n\nLes étiquettes de relation identifient la relation entre les agents visibles et l’agent actuel. Les étiquettes s’affichent lorsqu’un sous-agent s’exécute dans une session parente avec la communication partagée entre agents frères activée.\n\n| Étiquette | Meaning | Utilisez-le pour |\n| ----------- | --------------------------------- | ------------------------------------------------------- |\n| `\"self\"` | L’agent actuel | Confirmez quelle entrée correspond à l’agent actif. |\n| `\"sibling\"` | Un agent lancé par le même parent | Coordonner avec les agents homologues via `write_agent` |\n| `\"child\"` | Un agent lancé par l’agent actuel | Suivre les travaux de suivi délégués par l’agent actuel |\n\n#### Liste délimitée\n\nUtilisez `scope` sur `list_agents` pour affiner la liste avant de choisir les cibles.\n\n| `scope` valeur | Returns | Utilisez-le pour |\n| -------------- | ----------------------------------------------- | ------------------------------------------------------------------------------------------ |\n| omis | Agents proches dans le contexte actuel | Voir le jeu de travail par défaut pour le flux de travail actuel |\n| `\"siblings\"` | Seuls les agents frères | Rechercher des agents homologues lancés par le même parent |\n| `\"children\"` | Uniquement les agents enfants de l’agent actuel | Consulter le travail délégué par l’agent actuel |\n| `\"all\"` | Tous les agents visibles | Inspectez l’arborescence complète de la session sans l’utiliser à des fins de coordination |\n\nDans les sessions à agent unique, la vue par défaut se concentre sur les agents enfants. Dans les sessions multi-agent, la vue par défaut affiche le contexte local immédiat au lieu de l’arborescence entière.\n\n```text\nlist_agents(scope=\"siblings\")\nlist_agents(scope=\"children\")\nlist_agents(scope=\"all\")\n```\n\n#### Messagerie délimitée\n\nUtilisez `scope` sur `write_agent` pour diffuser un message à plusieurs agents associés.\n\nUtilisez la messagerie à portée limitée uniquement depuis un sous-agent s’exécutant dans une session parente avec la communication partagée entre pairs activée. Dans les sessions de niveau supérieur, ciblez plutôt les agents avec des valeurs `agent_id` explicites.\n\n| `scope` valeur | Envoie à | Utilisez-le pour |\n| -------------- | ----------------------------------------- | ----------------------------------------------------------- |\n| `\"siblings\"` | Tous les agents frères visibles | Coordonner le travail entre pairs dans une session partagée |\n| `\"children\"` | Tous les agents enfants de l’agent actuel | Envoyer la même relance pour le travail délégué |\n\nSi une portée correspond à trop d’agents, `write_agent` renvoie une erreur et demande à la place des valeurs explicites `agent_id` de la part de `list_agents`.\n\n```text\nwrite_agent(scope=\"children\", message=\"Re-check your findings against the updated schema.\")\nwrite_agent(scope=\"siblings\", message=\"Post status when your current check completes.\")\nwrite_agent(agent_id=\"explore-auth\", message=\"Focus on token refresh flow and report only confirmed issues.\")\n```\n\n### Limites des sous-agents\n\nL'interface CLI impose des limites de profondeur et de concurrence pour empêcher la génération incontrôlée d’agents.\n\n| Limite | Par défaut | Max |\n| ------------------------ | ---------------- | ----- |\n| Profondeur maximale | `6` | `256` |\n| Nombre maximal simultané | basé sur un plan | `32` |\n\n**La profondeur** compte le nombre d’agents imbriqués entre eux. Lorsque la limite de profondeur est atteinte, l’agent le plus interne ne peut pas générer de sous-agents supplémentaires.\n**La concurrence** correspond au nombre de sous-agents exécutés simultanément dans l’ensemble de l’arborescence de session. Lorsque la limite est atteinte, les nouvelles demandes de sous-agent sont rejetées jusqu'à ce qu'un agent actif ait terminé son opération.\n\nLa limite de concurrence par défaut dépend de votre Copilot plan :\n\n| Plan | Nombre maximal simultané |\n| ----------------------------------- | ------------------------ |\n| Gratuit / Éducation | `2` |\n| Pro / Pro+ | `4` |\n| Max | `8` |\n| Métier | `16` |\n| Entreprise | `32` |\n| Facturation basée sur l’utilisation | `32` |\n\nLes utilisateurs de la facturation à l’usage peuvent outrepasser ces limites avec les paramètres `subagents.maxConcurrency` et `subagents.maxDepth` :\n\n```json\n{\n \"subagents\": {\n \"maxConcurrency\": 16,\n \"maxDepth\": 10\n }\n}\n```\n\nLes valeurs en dehors de la plage valide sont limitées : `maxConcurrency` est limitée à `32`, et `maxDepth` est limitée à `256`. Ces paramètres sont ignorés pour les plans qui n’utilisent pas la facturation basée sur l’utilisation. Consultez [les paramètres du fichier de configuration](/fr/copilot/reference/copilot-cli-reference/cli-config-dir-reference#configuration-file-settings).\n\n## Agents auxiliaires\n\nLes agents Sidekick s’exécutent automatiquement en arrière-plan et publient des informations de contexte dans la boîte de réception de la session. Ils répondent aux événements de session au lieu d’être appelés explicitement.\n\nAjoutez un `sidekick:` bloc à n’importe quelle définition d’agent pour en faire un agent sidekick :\n\n```yaml\n---\nname: Context Gatherer\ndescription: Gathers relevant context when the working directory changes\nsidekick:\n triggers:\n - session.context_changed\n - event: user.message\n limit: 1\n behavior: persistent\n maxSendsPerTurn: 2\n---\n\nGather useful context about the current repository and working directory.\nSummarize recent changes and any relevant project structure.\n```\n\n### Déclencheurs d’assistant\n\nChaque entrée `triggers` est une chaîne de nom d’événement nue, qui déclenche un nombre illimité de fois, ou un objet avec `event` et une chaîne facultative `limit`.\n\n| Événement | Description |\n| ------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------- |\n| `user.message` | Se déclenche à chaque message utilisateur. |\n| `session.context_changed` | Se déclenche lorsque le répertoire de travail, le dépôt ou la branche changent (par exemple, après `cd` ou après avoir changé de branche Git). |\n\n| Champ déclencheur | Type | Par défaut | Description |\n| ----------------- | -------- | ----------- | -------------------------------------------------------------------------------------------------------------------------- |\n| `event` | `string` | Obligatoire | Type d’événement de session qui lance cet agent. |\n| `limit` | `number` | Unlimited | Nombre maximal de fois où ce déclencheur peut être déclenché par session. Doit être un entier positif quand il est défini. |\n\n### Champs de configuration de l’assistant\n\n| Champ | Type | Par défaut | Description |\n| ------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------- | ---------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------- |\n| `triggers` | | | |\n| `string[]` ou object\\[] | Obligatoire | Types d’événements de session qui lancent cet agent. Au moins un déclencheur est requis. | |\n| `behavior` | `string` | `\"restart\"` | |\n| `\"restart\"`: annulez toute exécution antérieure et démarrez à nouveau sur chaque déclencheur. | | | |\n| `\"persistent\"`: conserver la même exécution de longue durée et acheminer de nouveaux messages vers la boucle existante au lieu de relancer l’exécution. | | | |\n| `maxSendsPerTurn` | `number` | `1` | Nombre maximal d’envois de boîte de réception autorisés par déclencheur. En `\"persistent\"` mode, chaque message utilisateur remis réinitialise ce budget. |\n\nLe comportement `\"restart\"` convient aux agents de collecte de contexte sans état. Le comportement `\"persistent\"` est adapté aux agents qui accumulent l’état d’un tour à l’autre.\n\n## Réponses d’approbation des autorisations\n\nLorsque l’interface CLI demande l’autorisation d’exécuter une opération, vous pouvez répondre avec les clés suivantes.\n\n| Clé | Résultat |\n| --- | --------------------------------------------------------------------- |\n| `y` | Autorisez cette requête spécifique une seule fois. |\n| `n` | Refuser cette demande spécifique une seule fois. |\n| `!` | Autorisez toutes les demandes similaires pour le reste de la session. |\n| `#` | Refuser toutes les demandes similaires pour le reste de la session. |\n| `?` | Affichez des informations détaillées sur la demande. |\n\nLorsque la boîte de dialogue complète s’affiche, vous pouvez également choisir parmi ces options :\n\n| Choix | Étendue | Persévérance |\n| --------------- | -------------------------------------------- | ---------------------------------------- |\n| Une fois | Utilisation unique | Aucun |\n| Cet emplacement | Jusqu’à ce qu’elle soit effacée manuellement | Enregistré sur le disque par emplacement |\n| Toujours | Permanent | Fichier de configuration |\n\nL’option **Cet emplacement** s’affiche lorsque l’interface CLI peut déterminer une clé d’emplacement (racine Git ou répertoire actif). Il conserve l’approbation sur le disque pour que la même autorisation soit automatiquement accordée la prochaine fois que vous travaillez dans ce répertoire sans demander à nouveau.\n\nUtilisez `/permissions reset` pour effacer les approbations en mémoire pour la session en cours.\n\n## Sécurité\n\n### Mode plan\n\n`/plan` démarre une session de planification où Copilot CLI peut explorer et analyser votre base de code, mais ne peut pas modifier les fichiers de votre projet. Specifically:\n\n* **Vos fichiers projet sont protégés.** Toute tentative de modification, de correctif ou d’exécution d’une commande d’interpréteur de commandes qui modifierait un fichier dans votre espace de travail est bloquée automatiquement, ce n’est pas simplement une suggestion au modèle, elle est appliquée directement, de sorte qu’elle ne dépend pas du modèle choisi pour se comporter.\n* **Le plan lui-même peut toujours être écrit.**\n Copilot a besoin d’un endroit pour consigner des notes et rédiger une ébauche du plan ; il est donc autorisé à créer et à modifier des fichiers dans son propre espace de planification privé (y compris le fichier de plan que vous examinerez et approuverez).\n* **Les sous-tâches déléguées sont également protégées.** Si Copilot démarre une session auxiliaire pour examiner une partie de votre question, cette session auxiliaire hérite des mêmes restrictions et ne peut pas non plus modifier votre projet.\n* **C’est un filet de sécurité, pas une garantie.** Cette protection est conçue pour intercepter les tentatives claires et directes de modifier vos fichiers, ce n’est pas un verrouillage étanche. Certaines choses sont intentionnellement autorisées afin de ne pas trop restreindre la recherche : par exemple, les commandes shell dont l’effet ne peut pas être clairement déterminé à l’avance, ainsi que les appels à des outils externes/MCP que vous avez connectés. Dans la pratique, il s’agit rarement d’un problème, mais le mode plan doit être considéré comme « les modifications nécessitent votre révision avant d’appliquer », pas une garantie absolue que rien sur le disque ne peut changer.\n\nUne fois que vous êtes satisfait du plan, approuvez-le pour quitter le mode de planification et laisser Copilot effectuer les modifications réelles.\n\n### Analyse de la sécurité des commandes\n\nLes commandes shell sont analysées avant l’exécution pour identifier les modèles potentiellement dangereux :\n\n* Suppression de fichiers (`rm -rf`)\n* Modifications système (`sudo`, `chmod 777`)\n* Exfiltration réseau (`curl` avec des chemins sensibles)\n* Accès aux identifiants (lecture de `.env`, clés SSH)\n* Affectations de variables d’environnement inline qui remplacent des variables dangereuses (par exemple, `PATH=...`, `LD_PRELOAD=...`)\n\nLes commandes à haut risque affichent des avertissements supplémentaires et nécessitent une confirmation explicite.\n\nLorsque le bac à sable est activé et que le paramètre **Autoriser le contournement du bac à sable** est activé (valeur par défaut), une commande shell synchrone bloquée par le système de fichiers ou la stratégie réseau du bac à sable vous invite à le réexécuter en dehors du bac à sable ( aucun aller-retour de modèle n’est nécessaire). L’approbation de la demande réexécute la commande et renvoie son résultat. En cas de refus, le résultat du bac à sable (bloqué) est conservé.\n\nUne invite de contournement du bac à sable offre également une option **Oui, et désactiver le bac à sable pour le reste de cette session**. Le choix de celui-ci désactive le bac à sable pour chaque commande restante de la session active, pas seulement la commande approuvée. Cela s’applique uniquement à la session en cours : démarrer une nouvelle session avec `/new` replace de nouveau les commandes en bac à sable, et l’option n’a aucun effet sur le paramètre de configuration `sandbox` enregistré ni sur les autres sessions en cours.\n\nUne commande détachée (en arrière-plan) ne peut pas du tout être exécutée dans un bac à sable, car le bac à sable ne peut pas isoler un processus qui continue à s’exécuter après l’appel de l’outil. Lorsque le paramètre **Autoriser le contournement du bac à sable** est activé, cette opération demande l’approbation avant le démarrage de la commande, au lieu d’être refusée. L’approbation exécute la commande non approuvée à partir du démarrage.\n\nSur les hôtes Windows dont la stratégie de bac à sable prend en charge la capture des refus, une commande interactive du shell bloquée passe à un niveau supérieur en une seule étape au lieu d’aboutir directement à un contournement total. L’approbation relance la commande avec des restrictions sur les fichiers et les processus configurées pour consigner au lieu de bloquer (la politique réseau s’applique toujours), puis bascule sur le contournement complet indiqué uniquement si la commande est toujours bloquée. Un seul message s’affiche pendant toute la procédure d’escalade. Une demande de socket loopback ou de réseau local refusée (par exemple, l’association ou la connexion à `127.0.0.1`) déclenche également cette même escalade au lieu d’échouer silencieusement. Le résultat de nouvelle tentative est intitulé « bac à sable détendu » lorsque la stratégie réseau est toujours appliquée, ou « bac à sable contourné » lorsqu’elle n’est pas entièrement annulée. Si la nouvelle tentative échoue toujours, le message explique que les autorisations au niveau de l’hôte s’appliquent toujours.\n\nUne commande qui échoue avec un diagnostic `EPERM` ou `EACCES` mentionnant un chemin bloqué par la sandbox propose désormais de l’exécuter en dehors de la sandbox, même si la ligne de commande elle-même n’a jamais mentionné ce chemin.\n\nLorsqu’un refus est causé par un lien symbolique dont la cible se trouve en dehors de ce qu’autorise la politique de sandbox, le message de refus précise que le lien du chemin autorisé pointe en dehors de l’autorisation accordée et indique la cible réelle, de sorte que vous sachiez exactement quel chemin d’accès ajouter à votre politique de sandbox.\n\nPour plus d’informations, consultez « [Configuration des paramètres de bac à sable local](/fr/copilot/how-tos/cloud-and-local-sandboxes/configuring-local-sandbox-settings#allowing-sandbox-bypass) ».\n\n#### Liste de refus des variables d’environnement\n\nL’interface CLI bloque l’attribution inline de variables d’environnement qui peuvent être exploitées pour exécuter du code arbitraire même dans les commandes en lecture seule. Les catégories bloquées sont les suivantes :\n\n| Catégorie | Examples |\n| ---------------------------------------------------------------------------------------------------------------------------- | -------- |\n| Injection dynamique de l’éditeur de liens | |\n| `LD_*`, `DYLD_*` (tous les préfixes) | |\n| Remplacements de configuration de l’index Git | |\n| `GIT_CONFIG_COUNT`, `GIT_CONFIG_KEY_*`, `GIT_CONFIG_VALUE_*` (tous les préfixes `GIT_CONFIG_`) | |\n| Hooks de programme externe Git | |\n| `GIT_EXTERNAL_DIFF`, `GIT_PROXY_COMMAND` | |\n| Remplacements de fichier de configuration Git | |\n| `GIT_CONFIG` | |\n| `GIT_CONFIG_GLOBAL` | |\n| `GIT_CONFIG_SYSTEM` | |\n| | |\n| Shell PATH et fichiers de démarrage | |\n| `PATH` | |\n| `BASH_ENV` | |\n| `ENV` | |\n| | |\n| Variables bloquées existantes | |\n| `PAGER`, `GIT_PAGER`, `GIT_EDITOR`, `VISUAL`, `EDITOR`, `GIT_SSH`, `GIT_SSH_COMMAND`, `GIT_ASKPASS`, `BROWSER`, `GH_BROWSER` | |\n\n### `web_fetch` Protection contre les SSRF\n\nL’outil `web_fetch` applique des protections de falsification de requête côté serveur (SSRF) avant d’effectuer une requête HTTP :\n\n* **Liste d’autorisation des protocoles** : seules les URL `http://` et `https://` sont autorisées.\n `file://` et d’autres schémas sont rejetés.\n* **Liste de blocage d’IP** : les requêtes vers des adresses de bouclage (`127.x.x.x`, `::1`), les plages privées RFC 1918 (`10.x`, `172.16–31.x`, `192.168.x`) et les points de terminaison de métadonnées du cloud (par exemple, `169.254.169.254`) sont bloqués par la vérification des IP littérales et la pré-résolution DNS.\n* **Redirections validées** : `web_fetch` suit `3xx` les redirections (jusqu’à 10 tronçons, au sein d’un budget réseau de 60 secondes), validant à nouveau la cible de chaque tronçon par rapport à la même liste de blocs IP avant de la suivre. Une redirection vers une origine différente de l’URL d’origine nécessite une approbation d’autorisation, identique à toute autre extraction d’origine croisée ; Les redirections de même origine sont suivies sans invite supplémentaire. Le résultat final indique à quel moment le contenu était `(redirected from )`.\n\nLorsque le sandboxing est activé, les requêtes sont vérifiées au regard de la politique réseau du sandbox (accès sortant, hôtes locaux et privés) avant toute demande d’autorisation, de sorte qu’une cible bloquée par cette politique échoue immédiatement au lieu d’afficher une demande d’autorisation. Si le paramètre **Autoriser le contournement du bac à sable** est activé et que le proxy réseau de bac à sable ne peut pas atteindre une URL, contrairement à l’URL refusée par la stratégie,`web_fetch` vous invite à réessayer la requête en dehors du bac à sable. L’approbation effectue une autre tentative d’extraction et retourne son résultat.\n\nPour permettre `web_fetch` d’atteindre `localhost` pendant le développement( par exemple, pour un serveur docs local), définissez la variable d’environnement suivante :\n\n```bash\nexport COPILOT_WEB_FETCH_ALLOW_LOCALHOST=1\n```\n\n### Autorisations des répertoires de l’outil de bac à sable\n\nLorsque le sandboxing local est activé, Copilot CLI découvre les répertoires d’outils dont une commande isolée est susceptible d’avoir besoin et accorde à chacun un accès **en lecture seule**, afin qu’une commande puisse exécuter une chaîne d’outils installée sans pouvoir la modifier. La découverte s’exécute pour chaque commande, avant le démarrage du processus et lit deux types de source à partir de l’environnement de la commande.\n\n* **`PATH`**(`Path` sur Windows). Chaque répertoire répertorié constitue une autorisation potentielle.\n* **Variables nommées de la chaîne d’outils.** La CLI inspecte les variables dans le tableau ci-dessous. Une valeur de répertoire donne accès à ce répertoire. Une liste de chemins est divisée sur le séparateur de chemin d'accès du système d'exploitation (point-virgule sur Windows, un signe deux-points ailleurs) et chaque entrée devient une autorisation potentielle. Les variables de fichier Git sont inspectées uniquement sur macOS et Linux.\n\nUn chemin candidat n’est accepté que lorsqu’il s’agit d’un chemin absolu qui existe en tant que répertoire. Les chemins relatifs, les chemins manquants, les racines du système de fichiers (telles que `/` ou `C:\\`) et les emplacements critiques du système sont exclus de la découverte. Des exemples d’emplacements exclus sont `%WINDIR%` sur Windows et `/bin`, `/sbin`, `/usr/bin`, `/usr/sbin`, `/boot`, `/proc`, `/sys` et `/dev` sur macOS et Linux. La raison est consignée dans `sandbox_spawn`.\n\nCes autorisations conservent la forme de leur chemin plutôt que d’ajouter automatiquement la cible d’un lien symbolique. Si l’accès via un lien est bloqué, accordez explicitement l’accès à la cible prévue. Les répertoires en double sont supprimés, sans respect de la casse sur Windows.\n\n| Variable | Chaîne d’outils | Valeur | Généralement défini sur |\n| ----------------------- | ---------------------------- | ------------------------ | ----------------------- |\n| `BAZEL_VC` | Bazel / Visual C++ | Répertoire unique | Windows |\n| `BAZEL_VS` | Bazel / Visual Studio | Répertoire unique | Windows |\n| `BAZELISK_HOME` | Bazelisk | Répertoire unique | tous |\n| `BAZELISK_HOME_DARWIN` | Bazelisk | Répertoire unique | macOS |\n| `BAZELISK_HOME_LINUX` | Bazelisk | Répertoire unique | Linux |\n| `BAZELISK_HOME_WINDOWS` | Bazelisk | Répertoire unique | Windows |\n| `CONDA_PREFIX` | Conda | Répertoire unique | tous |\n| `DOTNET_ROOT` | .NET | Répertoire unique | tous |\n| `GIT_CONFIG_SYSTEM` | Configuration du système Git | Fichier | macOS et Linux |\n| `GIT_EXEC_PATH` | Assistants Git | Répertoire unique | tous |\n| `GIT_SSL_CAINFO` | bundle de certificats Git | Fichier | macOS et Linux |\n| `GIT_SSL_CAPATH` | Certificats Git | Répertoire unique | tous |\n| `GIT_TEMPLATE_DIR` | Modèles Git | Répertoire unique | tous |\n| `GOPATH` | Go | Liste de chemins d’accès | tous |\n| `GOROOT` | Go | Répertoire unique | tous |\n| `JAVA_HOME` | Java | Répertoire unique | tous |\n| `LD_LIBRARY_PATH` | Bibliothèques partagées | Liste de chemins d’accès | Linux |\n| `NODE_PATH` | Node.js | Liste de chemins d’accès | tous |\n| `NVM_HOME` | Node.js (nvm) | Répertoire unique | Windows |\n| `NVM_SYMLINK` | Node.js (nvm) | Répertoire unique | Windows |\n| `PATH` / `Path` | Exécutables (tous) | Liste de chemins d’accès | tous |\n| `PSModulePath` | PowerShell | Liste de chemins d’accès | tous |\n| `PYENV_ROOT` | Python (pyenv) | Répertoire unique | tous |\n| `PYTHONHOME` | Python | Répertoire unique | tous |\n| `PYTHONPATH` | Python | Liste de chemins d’accès | tous |\n| `RUSTUP_HOME` | Rust (rustup) | Répertoire unique | tous |\n| `VCINSTALLDIR` | Visual C++ | Répertoire unique | Windows |\n| `VCPKG_ROOT` | vcpkg | Répertoire unique | tous |\n| `VIRTUAL_ENV` | Python (venv) | Répertoire unique | tous |\n| `VSINSTALLDIR` | Visual Studio | Répertoire unique | Windows |\n\nÀ l’exception des deux variables de fichier liées à Git, chaque variable est lue sur chaque plateforme. La colonne **Généralement défini dans** indique où chaque champ est généralement renseigné. Une variable non définie ne contribue à rien.\n\n`CARGO_HOME` est géré séparément par le biais d’autorisations spécifiques à l’outil pour les répertoires et fichiers Cargo sélectionnés. Il n’accorde pas l’accès à tout l’accueil de Cargo. Les autorisations des outils de développement peuvent également suivre les caches déplacés, y compris les caches Go et NuGet.\n\nCe ne sont pas les seules autorisations accordées automatiquement. Avec **l’activation de l’accès à l’outil de développement**, Copilot CLI accorde l’accès à certains répertoires d’applications du profil utilisateur, y compris `~/.local/bin` et `~/.local/lib` sur macOS et Linux, ainsi que les sous-répertoires immédiats de `%LOCALAPPDATA%\\Programs` sous Windows. Il accorde également des caches et des registres spécifiques aux outils, dont certains sont accessibles en écriture, tels que le cache de npm et les caches de build partagés.\n\nExécutez `/sandbox policy` pour afficher les chemins résolus regroupés par source et par accès. La section **Outils de développement** répertorie les outils détectés dans le répertoire actif et leurs chemins d’accès. Ajoutez une commande, par exemple `/sandbox policy npm install`, pour inspecter son accès à l’outil développeur sans l’exécuter. Le rapport n’ajoute pas les caches manquants. Pour connaître les concepts liés à l’assemblage de la stratégie, consultez [Présentation des stratégies de système de fichiers pour le bac à sable local dans GitHub Copilot CLI](/fr/copilot/concepts/agents/copilot-cli/understanding-local-sandboxing).\n\n## Supervision OpenTelemetry\n\nCopilot CLI peut exporter des traces et des métriques via [OpenTelemetry (OTel](http://gfffha58ff65ae61847afsxv6nxvvcb0nq6kxk.ffgi.yc2.bjmu.edu.cn/) ), ce qui vous donne une visibilité sur les interactions de l’agent, les appels LLM, les exécutions d’outils et l’utilisation des jetons. Tous les noms et attributs de signal suivent les [conventions sémantiques OTel GenAI](http://gfffh3e2b966b640040f3sxv6nxvvcb0nq6kxk.ffgi.yc2.bjmu.edu.cn/open-telemetry/semantic-conventions-genai/tree/main/docs/gen-ai/).\n\nOTel est désactivé par défaut avec une surcharge nulle. Elle s’active quand l’une des conditions suivantes est remplie :\n\n* `COPILOT_OTEL_ENABLED=true`\n* `OTEL_EXPORTER_OTLP_ENDPOINT` est défini\n* `COPILOT_OTEL_FILE_EXPORTER_PATH` est défini\n\nLa configuration OTel peut également être définie dans VS Code, ou dans un fichier `managed-settings.json` à l’échelle de l’entreprise. Consultez [Activer la supervision OTel](http://gfffhebfdb2e504e84d52sxv6nxvvcb0nq6kxk.ffgi.yc2.bjmu.edu.cn/docs/agents/guides/monitoring-agents#_enable-otel-monitoring) dans la documentation VS Code et [Paramètres gérés par l’entreprise](/fr/copilot/reference/enterprise-administrators/enterprise-managed-settings).\n\n### Variables d’environnement OTel\n\n| Variable | Par défaut | Description |\n| ---------------------------------------------------- | ---------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------- |\n| `COPILOT_OTEL_ENABLED` | `false` | Activez explicitement OTel. Non obligatoire si `OTEL_EXPORTER_OTLP_ENDPOINT` est défini. |\n| `OTEL_EXPORTER_OTLP_ENDPOINT` | — | URL du point de terminaison OTLP. La définition de ce paramètre active automatiquement OTel. |\n| `COPILOT_OTEL_EXPORTER_TYPE` | `otlp-http` | Type d’exportateur : `otlp-http` ou `file`. Sélectionne `file` automatiquement quand `COPILOT_OTEL_FILE_EXPORTER_PATH` est défini. |\n| `OTEL_EXPORTER_OTLP_PROTOCOL` | `http/json` | Protocole de câble HTTP OTLP : `http/json` ou `http/protobuf`. S’applique uniquement à l’exportateur `otlp-http` . |\n| `OTEL_EXPORTER_OTLP_TRACES_PROTOCOL` | — | Remplacez `OTEL_EXPORTER_OTLP_PROTOCOL` pour les traces uniquement. |\n| `OTEL_EXPORTER_OTLP_METRICS_PROTOCOL` | — | Remplacez `OTEL_EXPORTER_OTLP_PROTOCOL` uniquement pour les métriques. |\n| `OTEL_SERVICE_NAME` | `github-copilot` | Nom du service dans les attributs de ressource. |\n| `OTEL_RESOURCE_ATTRIBUTES` | — | Attributs de ressource supplémentaires en tant que paires séparées par `key=value` des virgules. Utilisez l’encodage de pourcentage pour les caractères spéciaux. |\n| `OTEL_INSTRUMENTATION_GENAI_CAPTURE_MESSAGE_CONTENT` | `false` | Capturez le contenu complet de l’invite et de la réponse. Voir [capture de contenu](#content-capture). |\n| `OTEL_LOG_LEVEL` | — | Niveau du journal de diagnostic OTel : `NONE`, `ERROR``WARN``INFO``DEBUG``VERBOSE``ALL`. |\n| `COPILOT_OTEL_FILE_EXPORTER_PATH` | — | Écrivez tous les signaux dans ce fichier sous forme de lignes JSON. La définition de ce paramètre active automatiquement OTel. |\n| `COPILOT_OTEL_SOURCE_NAME` | `github.copilot` | Nom de l’étendue d’instrumentation pour le traceur et le compteur. |\n| `OTEL_EXPORTER_OTLP_HEADERS` | — | En-têtes d’authentification pour l’exportateur OTLP (par exemple, `Authorization=Bearer token`). |\n\n### Traces\n\nLe runtime émet un arbre de spans hiérarchiques pour chaque interaction de l’agent. Chaque arborescence contient un span racine `invoke_agent`, avec des spans enfants `chat` et `execute_tool`.\n\n#### `invoke_agent` attributs d’étendue\n\nEncapsule l'intégralité de l'appel de l'agent : appels LLM et exécutions d'outils pour chaque message utilisateur.\n\n* Les **sessions de niveau supérieur** et les **invocations de sous-agents** (par exemple, explorer, tâche) utilisent le type de span `INTERNAL` (in-process) ; l’inférence destinée au fournisseur est représentée par des spans enfants `CLIENT``chat`.\n* **Les sessions de niveau supérieur** incluent également `server.address` et `server.port` ; les invocations de sous-agents n’en incluent pas.\n\n| Caractéristique | Description | Étendue |\n| ------------------------------------------ | -------------------------------------------------------------------------------------------------------------------------------------- | --------------------------- |\n| `gen_ai.operation.name` | `invoke_agent` | Les deux |\n| `gen_ai.provider.name` | Fournisseur (par exemple, , `github``anthropic`) | Les deux |\n| `gen_ai.agent.id` | Identificateur de définition d’agent stable lorsqu’il est connu ; utilisations par défaut de niveau supérieur `github.copilot.default` | Les deux |\n| `gen_ai.agent.name` | Nom de l’agent (le cas échéant) | Les deux |\n| `gen_ai.agent.description` | Description de l’agent (le cas échéant) | Les deux |\n| `gen_ai.agent.version` | Version de définition de l’agent quand elle est connue ; sinon, version du runtime | Les deux |\n| `gen_ai.conversation.id` | Identificateur de session | Les deux |\n| `enduser.pseudo.id` | Identificateur pseudonyme d'utilisateur Copilot depuis `analytics_tracking_id` lorsqu'il est disponible | Les deux |\n| `gen_ai.request.model` | Modèle demandé | Les deux |\n| `gen_ai.response.finish_reasons` | | |\n| `[\"stop\"]` ou `[\"error\"]` | Les deux | |\n| `gen_ai.usage.input_tokens` | Nombre total de jetons d’entrée (toutes les itérations) | Les deux |\n| `gen_ai.usage.output_tokens` | Nombre total de jetons de sortie (tous les tours) | Les deux |\n| `gen_ai.usage.cache_read.input_tokens` | Lecture des jetons d’entrée mis en cache | Les deux |\n| `gen_ai.usage.cache_creation.input_tokens` | Jetons d’entrée créés et mis en cache | Les deux |\n| `github.copilot.turn_count` | Nombre d’allers-retours LLM | Les deux |\n| `github.copilot.cost` | Coefficient du modèle par requête utilisé pour la facturation. | |\n| **Pas une valeur monétaire.** | Les deux | |\n| `github.copilot.nano_aiu` | Unités IA consommées, en unités nano IA (1 AIU = 1 000 000 000 000 nano AIU) | Les deux |\n| `server.address` | Nom d’hôte du serveur | Niveau supérieur uniquement |\n| `server.port` | Port du serveur | Niveau supérieur uniquement |\n| `error.type` | Nom de la classe d’erreur (en cas d’erreur) | Les deux |\n| `gen_ai.input.messages` | Messages d’entrée complets au format JSON (capture de contenu uniquement) | Les deux |\n| `gen_ai.output.messages` | Messages de sortie complets au format JSON (capture de contenu uniquement) | Les deux |\n| `gen_ai.system_instructions` | Contenu de commande système en tant que JSON (capture de contenu uniquement) | Les deux |\n| `gen_ai.tool.definitions` | Schémas d’outil en tant que JSON (capture de contenu uniquement) | Les deux |\n\n#### `chat` attributs d’étendue\n\nUn span par requête LLM. Catégorie d’étendue : `CLIENT`.\n\n| Caractéristique | Description |\n| ------------------------------------------ | ------------------------------------------------------------------------------------------ |\n| `gen_ai.operation.name` | `chat` |\n| `gen_ai.provider.name` | Nom du fournisseur |\n| `gen_ai.request.model` | Modèle demandé |\n| `gen_ai.request.stream` | Indique si le mode de diffusion en continu a été utilisé (diffusion en continu uniquement) |\n| `gen_ai.conversation.id` | Identificateur de session |\n| `gen_ai.response.finish_reasons` | Raisons d'arrêt |\n| `gen_ai.response.id` | ID de réponse |\n| `gen_ai.response.model` | Modèle résolu |\n| `gen_ai.response.time_to_first_chunk` | Durée de la première diffusion en continu, en secondes (diffusion en continu uniquement) |\n| `gen_ai.usage.cache_creation.input_tokens` | Jetons créés en cache |\n| `gen_ai.usage.cache_read.input_tokens` | Lecture des jetons mis en cache |\n| `gen_ai.usage.input_tokens` | Jetons d’entrée pour ce tour |\n| `gen_ai.usage.output_tokens` | Jetons de sortie pour ce tour |\n| `github.copilot.cost` | Coefficient du modèle par requête utilisé pour la facturation. |\n| **Pas une valeur monétaire.** | |\n| `github.copilot.nano_aiu` | Unités IA consommées à ce tour, en unités nano AI (1 AIU = 1 000 000 000 nano AIU) |\n| `github.copilot.server_duration` | Durée côté serveur |\n| `github.copilot.initiator` | Initiateur de demande |\n| `github.copilot.turn_id` | Identifiant du tour |\n| `github.copilot.interaction_id` | Identificateur d’interaction |\n| `server.address` | Nom d’hôte du serveur |\n| `server.port` | Port du serveur |\n| `error.type` | Nom de la classe d’erreur (en cas d’erreur) |\n| `gen_ai.input.messages` | Messages d’invite complets au format JSON (capture de contenu uniquement) |\n| `gen_ai.output.messages` | Messages de réponse complets au format JSON (capture de contenu uniquement) |\n| `gen_ai.system_instructions` | Contenu de commande système en tant que JSON (capture de contenu uniquement) |\n\n#### `execute_tool` attributs d’étendue\n\nUn span par appel d’outil. Catégorie d’étendue : `INTERNAL`.\n\n| Caractéristique | Description |\n| ---------------------------- | --------------------------------------------------------------------------- |\n| `gen_ai.operation.name` | `execute_tool` |\n| `gen_ai.provider.name` | Nom du fournisseur (le cas échéant) |\n| `gen_ai.tool.name` | Nom de l’outil (par exemple, `readFile`) |\n| `gen_ai.tool.type` | `function` |\n| `gen_ai.tool.call.id` | Identificateur d’appel de l’outil |\n| `gen_ai.tool.description` | Description de l’outil |\n| `error.type` | Nom de la classe d’erreur (en cas d’erreur) |\n| `gen_ai.tool.call.arguments` | Arguments d’entrée d’outil en tant que JSON (capture de contenu uniquement) |\n| `gen_ai.tool.call.result` | Sortie de l’outil au format JSON (capture de contenu uniquement) |\n\n> \\[!NOTE]\n> Pour mesurer la consommation d’unités d’IA, lisez `github.copilot.nano_aiu` dans le span racine `invoke_agent` uniquement. L’attribut est également appliqué aux spans enfants `chat`, de sorte que le fait de l’additionner sur chaque span le compte deux fois.\n> `github.copilot.cost` est un multiplicateur de modèle par requête utilisé pour les calculs de facturation , il n’est pas une valeur monétaire et ne doit pas être interprété comme un.\n\n### Metrics\n\n#### Métriques de convention GenAI\n\n| Unité de mesure | Type | Unité | Description |\n| ----------------------------------------------- | ----------- | ------------------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |\n| `gen_ai.client.operation.duration` | Histogramme | s | Durée d’appel de l’API LLM et de l'invocation de l’agent |\n| `gen_ai.client.token.usage` | Histogramme | tokens | Nombre de jetons par type (`input`/`output`) |\n| `gen_ai.client.operation.time_to_first_chunk` | Histogramme | s | Temps de réception du premier segment de diffusion en continu |\n| `gen_ai.client.operation.time_per_output_chunk` | Histogramme | s | Latence entre segments après le premier segment |\n| `gen_ai.invoke_agent.duration` | Histogramme | s | Durée de bout en bout de l’invocation d’un agent |\n| `gen_ai.invoke_agent.inference_calls` | Histogramme | `{inference_call}` | Nombre d’appels au modèle effectués lors d’une invocation de l’agent, comptabilisés au moment de l’envoi au fournisseur (appels ayant échoué et appels partiels inclus ; requêtes bloquées avant l’envoi exclues). Dimension : `gen_ai.agent.name`. |\n| `gen_ai.invoke_agent.tool_calls` | Histogramme | `{tool_call}` | Nombre d’appels d’outils côté client effectués lors d’un appel d’agent (appels défaillants et partiels inclus ; cycle de vie d’outils CLI synthétiques et outils côté serveur exécutés par un fournisseur exclus). Dimension : `gen_ai.agent.name`. |\n| `gen_ai.invoke_workflow.duration` | Histogramme | s | Durée totale d’un flux de travail GenAI de bout en bout (par exemple, une exécution en mode flotte orchestrant des sous-agents parallèles). |\n\n#### Métriques spécifiques au fournisseur\n\n| Unité de mesure | Type | Unité | Description |\n| -------------------------------------------- | ----------- | ---------- | ----------------------------------------------------------------------------------- |\n| `github.copilot.tool.call.count` | Compteur | calls | Appels d’outils par `gen_ai.tool.name` et `success` |\n| `github.copilot.tool.call.duration` | Histogramme | s | Latence d’exécution des outils par `gen_ai.tool.name` |\n| `github.copilot.agent.turn.count` | Histogramme | Tourne | Allers-retours LLM par invocation d’agent |\n| `github.copilot.mcp.server.connection.count` | Compteur | Tentatives | Tentatives de connexion au serveur MCP finalisées selon le transport et le résultat |\n| `github.copilot.code.lines_added` | Compteur | Lignes | Lignes ajoutées par les outils d’édition de fichiers, enregistrées en temps réel |\n| `github.copilot.code.lines_removed` | Compteur | Lignes | Lignes supprimées par les outils d’édition de fichiers, enregistrées en temps réel |\n\n### Événements de span\n\nÉvénements du cycle de vie enregistrés sur le span actif `chat` ou `invoke_agent`.\n\n| Événement | Description | Attributs clés |\n| --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------- | ----------------------------- |\n| `github.copilot.hook.start` | Un hook a commencé à s’exécuter | |\n| `github.copilot.hook.type`, `github.copilot.hook.invocation_id` | | |\n| `github.copilot.hook.end` | Un hook a été exécuté avec succès | |\n| `github.copilot.hook.type`, `github.copilot.hook.invocation_id` | | |\n| `github.copilot.hook.error` | Échec d’un hook | |\n| `github.copilot.hook.type` | | |\n| `github.copilot.hook.invocation_id` | | |\n| `github.copilot.hook.error_message` | | |\n| | | |\n| `github.copilot.session.truncation` | L’historique des conversations a été tronqué | |\n| `github.copilot.token_limit`, `github.copilot.pre_tokens`, `github.copilot.post_tokens`, `github.copilot.pre_messages`, `github.copilot.post_messages`, `github.copilot.tokens_removed`, `github.copilot.messages_removed`, `github.copilot.performed_by` | | |\n| `github.copilot.session.compaction_start` | Le compactage de l’histoire a commencé | Aucun |\n| `github.copilot.session.compaction_complete` | Compactage de l’historique terminé | |\n| `github.copilot.success`, , `github.copilot.pre_tokens`, `github.copilot.post_tokens``github.copilot.tokens_removed`, , `github.copilot.messages_removed``github.copilot.message`(capture de contenu uniquement) | | |\n| `github.copilot.skill.invoked` | Une fonctionnalité a été activée | |\n| `github.copilot.skill.name` | | |\n| `github.copilot.skill.path` | | |\n| `github.copilot.skill.plugin_name` | | |\n| `github.copilot.skill.plugin_version` | | |\n| | | |\n| `github.copilot.session.shutdown` | La session s’arrête | |\n| `github.copilot.shutdown_type`, `github.copilot.total_premium_requests`, , `github.copilot.lines_added`, `github.copilot.lines_removed`, `github.copilot.files_modified_count` | | |\n| `github.copilot.session.abort` | L’utilisateur a annulé l’opération actuelle | `github.copilot.abort_reason` |\n| `exception` | Erreur de session | |\n| `github.copilot.error_type` | | |\n| `github.copilot.error_status_code` | | |\n| `github.copilot.error_provider_call_id` | | |\n| | | |\n\n### Attributs des ressources\n\nTous les signaux portent ces attributs de ressource.\n\n| Caractéristique | Valeur |\n| ------------------------------------------------------- | ------------------ |\n| `service.name` | |\n| `github-copilot` (configurable par `OTEL_SERVICE_NAME`) | |\n| `service.version` | Version du runtime |\n\n### Capture de contenu\n\nPar défaut, aucun contenu d’invite, aucune réponse ni argument d’outil ne sont capturés : seules des métadonnées telles que les noms de modèles, le nombre de jetons et les durées sont enregistrées. Pour capturer du contenu complet, définissez `OTEL_INSTRUMENTATION_GENAI_CAPTURE_MESSAGE_CONTENT=true`.\n\n> \\[!WARNING]\n> La capture de contenu peut inclure des informations sensibles telles que du code, du contenu de fichier et des invites utilisateur. Activez-le uniquement dans les environnements approuvés.\n\nLorsque la capture de contenu est activée, les attributs suivants sont renseignés.\n\n| Caractéristique | Contenu |\n| ---------------------------- | ----------------------------------- |\n| `gen_ai.input.messages` | Messages d’invite complets (JSON) |\n| `gen_ai.output.messages` | Messages de réponse complets (JSON) |\n| `gen_ai.system_instructions` | Contenu de l’invite système (JSON) |\n| `gen_ai.tool.definitions` | Schémas d’outil (JSON) |\n| `gen_ai.tool.call.arguments` | Arguments d’entrée de l’outil |\n| `gen_ai.tool.call.result` | Sortie de l’outil |\n\n## Lectures complémentaires\n\n* [GitHub Copilot CLI](/fr/copilot/how-tos/copilot-cli)\n* [Références sur les hooks GitHub Copilot](/fr/copilot/reference/hooks-reference)\n* [Référence du plug-in CLI GitHub Copilot](/fr/copilot/reference/copilot-cli-reference/cli-plugin-reference)\n* [référence programmatique du CLI GitHub Copilot](/fr/copilot/reference/copilot-cli-reference/cli-programmatic-reference)\n* [GitHub Copilot le répertoire de configuration du CLI](/fr/copilot/reference/copilot-cli-reference/cli-config-dir-reference)"}