Référence de commande CLI pour GitHub Copilot

Commandes de ligne de commande

Command	Objectif
`copilot`	Lancez l’interface utilisateur interactive.
`copilot help [TOPIC]`	Affichez les informations d’aide. Les rubriques d’aide incluent : `config`, , commands``environment, logging``monitoring, , `permissions`et `providers`.
`copilot init`	Initialisez des Copilot instructions personnalisées pour ce référentiel.
`copilot login`	Authentifiez-vous avec Copilot via le flux d'appareil OAuth. Accepte `--host HOST` de spécifier l’URL de l’hôte GitHub (valeur par défaut : `https://github.com`).
`copilot login` [OPTION]	Authentifiez-vous avec Copilot via le flux d'appareil OAuth. Voir `copilot login` les options.
`copilot mcp`	Gérez les configurations du serveur MCP à partir de la ligne de commande.
`copilot plugin`	Gérez les plug-ins et les places de marché de plug-ins.
`copilot update`	Téléchargez et installez la dernière version.
`copilot version`	Affichez les informations de version et recherchez les mises à jour.

Choix	Objectif
`--host HOST`

          GitHub URL de l’hôte (valeur par défaut : `https://github.com`). Utilisez ceci pour vous authentifier auprès d'une instance GitHub Enterprise Cloud qui utilise la localisation des données (par exemple, `https://example.ghe.com`). |

| --config-dir PATH | Définissez le répertoire de configuration (par défaut : ~/.copilot). |

Le mode d’authentification par défaut est un flux de navigateur web. Une 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 un magasin de stockage des informations d’identification est introuvable, le jeton est stocké dans un fichier de configuration en texte brut sous ~/.copilot/.

          Copilot pour 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.

Les 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.

          **Exemples :**

# Authenticate with github.com
copilot login

# Authenticate with GitHub Enterprise Cloud (data residency)
copilot login --host https://example.ghe.com

# Use a fine-grained PAT via environment variable
COPILOT_GITHUB_TOKEN=github_pat_... copilot

Raccourcis globaux dans l’interface interactive

Shortcut	Objectif
`@ FILENAME`	Incluez le contenu du fichier dans le contexte.
`# NUMBER`	Incluez un problème ou une pull request GitHub dans le contexte.
`! COMMAND`	Exécutez une commande dans votre interpréteur de commandes local, en contournant Copilot.
`?`	Ouvrez l’aide rapide (dans une invite vide).
`Échap`	Annulez l’opération actuelle.
`Ctrl`+`C`	Annuler l’opération / effacer la saisie. Appuyez deux fois pour quitter.
`Ctrl`+`D`	Arrêt.
`Ctrl`+`G`	Modifiez l’invite dans un éditeur externe (`$EDITOR`).
`Ctrl`+`L`	Effacez l’écran.
`Ctrl`+`Entrée` ou `Ctrl`+`Q`	Mettre en file d’attente un message à envoyer pendant que l’agent est occupé.
`Ctrl`+`R`	Recherche inversée par le biais de l’historique des commandes.
`Ctrl`+`V`	Collez le contenu du Presse-papiers en tant que pièce jointe.
`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.
`Ctrl`+`X` puis `e`	Modifiez l’invite dans un éditeur externe (`$EDITOR`).
`Ctrl`+`X` puis `o`	Ouvrez le lien le plus récent à partir de la chronologie.
`Ctrl`+`Z`	Suspendez le processus en arrière-plan (Unix).
`Maj`+`Entrée` ou `Option`+`Entrée` (Mac) / `Alt`+`Entrée` (Windows/Linux)	Insérez une nouvelle ligne dans l’entrée.
`Maj`+`Tab`	Alternez entre le mode standard, plan et pilote automatique.

Raccourcis de chronologie dans l’interface interactive

Shortcut	Objectif
`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.
`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.
`Ctrl`+`T`	Développer/réduire l’affichage du raisonnement dans les réponses.
`Page vers le haut`/`Page vers le bas`	Faites défiler la chronologie vers le haut ou vers le bas d’une page.

Shortcut	Objectif
`Ctrl`+`A`	Passez au début de la ligne (lors de la saisie).
`Ctrl`+`B`	Passez au caractère précédent.
`Ctrl`+`E`	Passez à la fin de la ligne (lors de la saisie).
`Ctrl`+`F`	Passez au caractère suivant.
`Ctrl`+`H`	Supprimez le caractère précédent.
`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.
`Ctrl`+`U`	Supprimer depuis le curseur jusqu'au début de la ligne.
`Ctrl`+`W`	Supprimez le mot précédent.
`Accueil`	Accédez au début du texte.
`Fin`	Passez à la fin du texte.
`Alt`+`←`/`→` (Windows/Linux)

          <kbd>Option</kbd>+<kbd>←</kbd>/<kbd>→</kbd> (Mac) | Déplacez le curseur par un mot.             |

Commandes slash dans l’interface interactive

Command	Objectif
`/add-dir PATH`	Ajoutez un répertoire à la liste autorisée pour l’accès aux fichiers.
`/agent`	Parcourez et sélectionnez parmi les agents disponibles (le cas échéant). Consultez « À propos des agents personnalisés ».
`/ask QUESTION`	Posez une question de côté rapide sans ajouter à l’historique des conversations. Disponible uniquement en mode expérimental.
`/allow-all [on\|off\|show]`, `/yolo [on\|off\|show]`	Activez toutes les autorisations (outils, chemins et URL).
`/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.
`/chronicle <standup\|tips\|improve\|reindex>`	Outils et analyses pour l’historique des sessions. Disponible uniquement en mode expérimental.
`/clear [PROMPT]`

          `/new [PROMPT]`
          `/reset [PROMPT]`
         | Démarrez une nouvelle conversation. |

Pour obtenir la liste complète des commandes de barre oblique disponibles, entrez /help dans l’interface interactive de l’interface CLI.

Options de ligne de commande

Choix	Objectif
`--add-dir=PATH`	Ajoutez un répertoire à la liste autorisée pour l’accès aux fichiers (peut être utilisé plusieurs fois).
`--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.
`--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.
`--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 `@`). 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 CLI GitHub Copilot ».
`--agent=AGENT`	Spécifiez un assistant personnalisé à utiliser. Consultez « À propos des agents personnalisés ».
`--allow-all`	Activez toutes les autorisations (équivalentes à `--allow-all-tools --allow-all-paths --allow-all-urls`).
`--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.
`--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`).
`--allow-all-urls`	Autoriser l’accès à toutes les URL sans confirmation.
`--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 ».
`--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.
`--autopilot`	Activez la poursuite de l’autopilot en mode prompt. Consultez « Autoriser GitHub Copilot CLI à fonctionner de manière autonome ».
`--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 ».
`--banner`, `--no-banner`	Afficher ou masquer la bannière de démarrage.
`--bash-env`	Activez la `BASH_ENV` prise en charge des interpréteurs de commandes bash.
`--config-dir=PATH`	Définissez le répertoire de configuration (par défaut : `~/.copilot`).
`--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`.
`--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.
`--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.
`--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.
`--disable-builtin-mcps`	Désactivez tous les serveurs MCP intégrés (actuellement : `github-mcp-server`).
`--disable-mcp-server=SERVER-NAME`	Désactivez un serveur MCP spécifique (peut être utilisé plusieurs fois).
`--disallow-temp-dir`	Empêchez l’accès automatique au répertoire temporaire système.
`--effort=LEVEL`, `--reasoning-effort=LEVEL`	Définissez le niveau d’effort de raisonnement (`low`, `medium`, `high`).
`--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`.
`--enable-reasoning-summaries`	Demander des résumés de raisonnement pour les modèles OpenAI qui les prennent en charge.
`--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.
`--experimental`	Activer les fonctionnalités expérimentales (utiliser `--no-experimental` pour désactiver).
`-h`, `--help`	Afficher l'aide.
`-i PROMPT`, `--interactive=PROMPT`	Démarrez une session interactive et exécutez automatiquement cette invite.
`--log-dir=DIRECTORY`	Définissez le répertoire du fichier journal (par défaut : `~/.copilot/logs/`).
`--log-level=LEVEL`	Définissez le niveau de journalisation (choix : `none`, `error`, `warning`, `info`, `debug`, `all`, `default`).
`--max-autopilot-continues=COUNT`	Nombre maximal de messages de continuation en mode Autopilot (valeur par défaut : illimitée). Consultez « Autoriser GitHub Copilot CLI à fonctionner de manière autonome ».
`--mode=MODE`	Définissez le mode d’agent initial (choix : `interactive`, `plan`). `autopilot` Impossible de combiner avec `--autopilot` ou `--plan`.
`--model=MODEL`	Définissez le modèle IA que vous souhaitez utiliser. Passez `auto` pour laisser Copilot choisir automatiquement le meilleur modèle disponible.
`--mouse[=VALUE]`	Activez la prise en charge de la souris en mode écran alternatif. VALUE peut être `on` (par défaut) ou `off`. Lorsque cette option est activée, l’interface CLI capture les événements de souris en mode d’écran de remplacement : roulette de défilement, clics, etc. En cas de désactivation, le comportement de la souris native du terminal est conservé. Une fois que le paramètre est défini, il est conservé en étant écrit dans votre fichier de configuration.
`-n NAME`, `--name=NAME`	Définissez un nom pour la nouvelle session. Utilisé par `--resume` et `/resume` pour rechercher des sessions par nom.
`--no-ask-user`	Désactivez l’outil (l’agent `ask_user` fonctionne de manière autonome sans poser de questions).
`--no-auto-update`	Désactivez le téléchargement automatique des mises à jour CLI.
`--no-bash-env`	Désactivez la prise en charge de `BASH_ENV` pour les interpréteurs de commandes Bash.
`--no-color`	Désactivez toutes les sorties de couleur.
`--no-custom-instructions`	Désactivez le chargement d'instructions personnalisées de `AGENTS.md` et des fichiers associés.
`--no-experimental`	Désactivez les fonctionnalités expérimentales.
`--no-mouse`	Désactivez la prise en charge de la souris.
`--no-remote`	Désactivez l’accès à distance pour cette session.
`--output-format=FORMAT`	Format peut être `text` (par défaut) ou `json` (génère JSONL : un objet JSON par ligne).
`-p PROMPT`, `--prompt=PROMPT`	Exécutez un prompt de manière programmatique (quitte après l’exécution). Consultez « Exécution CLI GitHub Copilot par programmation ».
`--plan`	Démarrez en mode plan. Raccourci pour `--mode plan`. Impossible de combiner avec `--mode` ou `--autopilot`.
`--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).
`--plugin-dir=DIRECTORY`	Charger un plug-in à partir d’un répertoire local (peut être utilisé plusieurs fois).
`--remote`	Activez l’accès à distance à cette session depuis GitHub.com et GitHub Mobile. Consultez « Direction d’une session à partir d’un CLI GitHub Copilot autre appareil ».
`--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.
`-s`, `--silent`	Affichez uniquement la réponse de l’agent (sans statistiques d’utilisation), utile pour l’écriture de scripts avec `-p`.
`--screen-reader`	Activez les optimisations du lecteur d’écran.
`--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.
`--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-<ID>.md`).
`--share-gist`	Partagez une session sur un gist secret GitHub après la terminaison d'une session programmée.
`--stream=MODE`	Activer ou désactiver le mode de diffusion en continu (choix de mode : `on` ou `off`).
`-v`, `--version`	Afficher les informations de version.
`--yolo`	Activez toutes les autorisations (équivalentes à `--allow-all`).

Pour obtenir la liste complète des commandes et des options, exécutez copilot help.

Remarque

Les options --remote, --no-remote et --connect nécessitent que la fonctionnalité de sessions distantes soit disponible sur votre compte.

Valeurs de disponibilité des outils

Les options --available-tools et --excluded-tools prennent en charge ces valeurs :

Outils Shell

Nom de l’outil	Description
`bash` / `powershell`	Exécuter des commandes
`list_bash` / `list_powershell`	Répertorier les sessions shell actives
`read_bash` / `read_powershell`	Lire la sortie d’une session shell
`stop_bash` / `stop_powershell`	Terminer une session shell
`write_bash` / `write_powershell`	Envoyer une entrée à une session shell

Outils d’opération de fichier

Nom de l’outil	Description
`apply_patch`	Appliquer des correctifs (utilisés par certains modèles au lieu de `edit`/`create`)
`create`	Créer des fichiers
`edit`	Modifier des fichiers via le remplacement de chaîne
`view`	Lire des fichiers ou des répertoires

Outils de délégation d’agent et de tâche

Nom de l’outil	Description
`list_agents`	Répertorier les agents disponibles
`read_agent`	Vérifier l'état de l'agent d'arrière-plan
`task`	Exécuter des sous-agents

Autres outils

Nom de l’outil	Description
`ask_user`	Poser une question à l’utilisateur
`glob`	Trouver des fichiers correspondant à des modèles
`grep` (ou `rg`)	Rechercher du texte dans des fichiers
`show_file`	Afficher des extraits de code en ligne dans la chronologie. Disponible uniquement en mode expérimental.
`skill`	Appeler des compétences personnalisées
`web_fetch`	Extraire et analyser le contenu web

Modèles d’autorisation d’outil

Les --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.

Type	Description	Exemples de modèles
`memory`	Stockage des faits dans la mémoire de l’agent	`memory`
`read`	Lectures de fichiers ou de répertoires

          `read`, `read(.env)` |

| shell | Exécution de commandes shell | shell(git push) shell(git:*) shell | | url | Accès URL via web-fetch ou via le shell | url(github.com), url(https://*.api.com) | | write | Création ou modification de fichier | write, write(src/*.ts) | | SERVER-NAME | Appel de l’outil serveur MCP | MyMCP(create_issue), MyMCP |

Pour 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 giteapas.

Les règles de refus sont toujours prioritaires sur les règles d’autorisation, même lorsque --allow-all est défini.

# Allow all git commands except git push
copilot --allow-tool='shell(git:*)' --deny-tool='shell(git push)'

# Allow a specific MCP server tool
copilot --allow-tool='MyMCP(create_issue)'

# Allow all tools from a server
copilot --allow-tool='MyMCP'

Variables d'environnement

Variable	Description
`COLORFGBG`	Solution de repli pour la détection de terminal à arrière-plan clair/foncé.
`COPILOT_ALLOW_ALL`	Définir sur `true` pour autoriser toutes les autorisations automatiquement (équivalent à `--allow-all`).
`COPILOT_AUTO_UPDATE`	Définissez sur `false` pour désactiver les mises à jour automatiques.
`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 pour connaître les valeurs par défaut de la plateforme.
`COPILOT_CUSTOM_INSTRUCTIONS_DIRS`	Liste séparée par des virgules de répertoires supplémentaires pour obtenir des instructions personnalisées.
`COPILOT_EDITOR`	Commande de l’éditeur pour la modification interactive (cochée après `$VISUAL` et `$EDITOR`).

          `vi` Par défaut, si aucun n’est défini. |

| COPILOT_GH_HOST | GitHub le nom d’hôte pour Copilot pour 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. | | COPILOT_GITHUB_TOKEN | Jeton d’authentification. Prend la priorité sur GH_TOKEN et GITHUB_TOKEN. | | COPILOT_HOME | Outrepassez le répertoire de configuration et d’état. Par défaut : $HOME/.copilot. | | COPILOT_MODEL | Définissez le modèle IA. | | 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. | | COPILOT_SKILLS_DIRS | Liste de répertoires supplémentaires pour les compétences, séparés par des virgules. | | COPILOT_SUBAGENT_MAX_CONCURRENT | Nombre maximal de sous-agents simultanés dans l'ensemble de l'arborescence de la session. Par défaut : 32. Plage : 1–256. | | COPILOT_SUBAGENT_MAX_DEPTH | Profondeur maximale d’imbrication des sous-agents. Par défaut : 6. Plage : 1–256. | | GH_HOST | GitHub nom d’hôte pour les deux GitHub CLI et Copilot pour 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 pour CLI uniquement. | | GH_TOKEN | Jeton d’authentification. Prend la priorité sur GITHUB_TOKEN. | | GITHUB_TOKEN | Jeton d’authentification. | | PLAIN_DIFF | Définir sur true pour désactiver le rendu enrichi des diffs. | | USE_BUILTIN_RIPGREP | Définir sur false, pour utiliser la version système de ripgrep au lieu de la version fournie. |

Paramètres du fichier de configuration

Pour 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.

Remarque

Les paramètres utilisateur ont été précédemment stockés dans ~/.copilot/config.json. Les paramètres existants de cet emplacement sont automatiquement migrés vers ~/.copilot/settings.json le démarrage.

Initialisation du projet pour Copilot

Lorsque 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.

Vous utiliserez copilot initgénéralement , ou /init, lorsque vous démarrez un nouveau projet, ou lorsque vous commencez à utiliser Copilot pour CLI dans un référentiel existant.

Le fichier copilot-instructions.md qui est créé ou mis à jour documente généralement :

Commandes dédiées à la compilation, aux tests et à la vérification de la syntaxe.
Architecture de haut niveau.
Conventions spécifiques à Codebase.

Si le fichier existe déjà, Copilot suggère des améliorations que vous pouvez choisir d’appliquer ou de rejeter.

L’interface CLI recherche le copilot-instructions.md fichier au démarrage et, s’il est manquant, il affiche le message :

          💡 Aucune instruction copilote n’a été trouvée. Exécutez /init pour générer un fichier copilot-instructions.md pour ce projet.

Si 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.

Pour plus d’informations, consultez « Ajout d’instructions personnalisées de référentiel pour GitHub Copilot ».

Référence des hooks

Les hooks sont des commandes externes, des webhooks HTTP ou (uniquement sur sessionStart) des chaînes d’invite qui s’exécutent à des étapes spécifiques du cycle de vie au cours d'une session, permettant l'automatisation personnalisée, les contrôles de sécurité et les intégrations. Les fichiers de configuration de "hook" sont chargés automatiquement depuis .github/hooks/*.json de votre référentiel.

Format de configuration des hooks

Les fichiers de configuration de hook utilisent le format JSON avec la version 1. Chaque entrée de hook est un hook de commande, un hook HTTP ou (sur sessionStart uniquement) un hook d’invite.

Crochets de commande

Les commandes hook exécutent des scripts shell et sont prises en charge pour tous les types de hook.

{
  "version": 1,
  "hooks": {
    "preToolUse": [
      {
        "type": "command",
        "bash": "your-bash-command",
        "powershell": "your-powershell-command",
        "cwd": "optional/working/directory",
        "env": { "VAR": "value" },
        "timeoutSec": 30
      }
    ]
  }
}

Champ	Type	Obligatoire	Description
`bash`	ficelle	L'un de `bash`/`powershell`	Commande Shell pour Unix.
`cwd`	ficelle	Non	Répertoire de travail pour la commande (relatif à la racine du référentiel ou absolu).
`env`	objet	Non	Variables d’environnement à définir (prend en charge l’expansion des variables).
`powershell`	ficelle	L'un de `bash`/`powershell`	Commande Shell pour Windows.
`timeoutSec`	nombre	Non	Délai d’expiration en secondes. Par défaut : `30`.
`type`	`"command"`	Oui	Doit être `"command"`.

Crochets d’invite

Les déclencheurs automatiques soumettent le texte comme si l'utilisateur l'avait tapé. Ils ne sont pris en charge que sur sessionStart et exécutés avant toute invite initiale passée via --prompt. Le texte peut être une invite en langage naturel ou une commande barre oblique.

{
  "version": 1,
  "hooks": {
    "sessionStart": [
      {
        "type": "prompt",
        "prompt": "Your prompt text or /slash-command"
      }
    ]
  }
}

Champ	Type	Obligatoire	Description
`prompt`	ficelle	Oui	Texte à soumettre : il peut s'agir d'un message en langage naturel ou d'une commande slash.
`type`	`"prompt"`	Oui	Doit être `"prompt"`.

Hooks HTTP

Les hooks HTTP envoient la charge utile de l'événement sous forme de JSON vers une URL configurée et analysent le corps de la réponse JSON. Ils sont pris en charge sur tous les types d’événements de hooks et sont utiles pour des intégrations de type webhook — services de politiques à distance, points de terminaison d’audit et flux de travail d’approbation — sans nécessiter d’exécutable local.

{
  "version": 1,
  "hooks": {
    "preToolUse": [
      {
        "type": "http",
        "url": "https://policy.example.com/preToolUse"
      }
    ]
  }
}

Champ	Type	Obligatoire	Description
`type`	`"http"`	Oui	Doit être `"http"`.
`url`	ficelle	Oui	URL du point de terminaison. Doit utiliser `http:` ou `https:`. Aucune substitution de var env dans l’URL elle-même.
`headers`	objet	Non	En-têtes de demande. Les valeurs soutiennent `$VAR` / `${VAR}` la substitution limitée aux noms répertoriés dans `allowedEnvVars`.
`allowedEnvVars`	chaîne de caractères[]	Non	Liste autorisée pour la modélisation des valeurs d'en-têtes. La définition d’un tableau non vide nécessite HTTPS.
`timeoutSec`	nombre	Non	Délai d’expiration par requête en secondes. Par défaut : `30`.

          `timeout` est accepté en tant qu’alias ; `timeoutSec` est prioritaire. |

| matcher | ficelle | Non | Filtre regex. Pris en charge uniquement sur preCompact, subagentStart, permissionRequest et notification. Ancré en tant que ^(?:pattern)$. |

Le corps de la réponse utilise le même schéma JSON que le stdout du hook de commande pour chaque événement. Répondez 204 No Content ou n’importe quel 2xx avec un corps vide quand aucune action n’est nécessaire.

Avertissement

Les hooks HTTP n’ont aucune sémantique de code de sortie. Une réponse non-2xx est un échec de raccordement, pas une décision de refus. Pour refuser un appel d’outil à partir d’un hook HTTP preToolUse , retournez 200 OK avec {"permissionDecision":"deny","permissionDecisionReason":"..."}. Pour refuser depuis un hook HTTP permissionRequest, retournez 200 OK avec {"behavior":"deny","message":"..."}.

Une entrée de crochet avec les champs bash et url est analysée selon la variante correspondant en premier ; le champ inutilisé est supprimé sans notification. Définissez explicitement toujours type et supprimez les champs de commande lors de l’utilisation de hooks HTTP.

Sécurité du raccordement HTTP

HTTPS est requis dans les cas suivants :

Lorsque allowedEnvVars est un tableau non vide, cela permet d'empêcher l'envoi d'informations d'identification en texte clair.
Par défaut, pour preToolUse et permissionRequest les crochets, pour protéger le canal de décision d’autorisation.

L'outil CLI applique une politique SSRF par défaut en mode refus : toute URL dont le nom d'hôte est résolu en une adresse de boucle, privée, locale de liaison, ou en une adresse de métadonnées cloud est rejetée avant la connexion. DNS est résolu avant et toutes les adresses retournées sont validées (défense de la liaison DNS).

Les variables d’environnement suivantes assouplint ces valeurs par défaut pour le développement et les tests uniquement.

Variable	Résultat	Usage prévu
`COPILOT_HOOK_ALLOW_LOCALHOST=1`	Autorise `http://` comme littéral `localhost`, `127.*`, ou `[::1]` (règles HTTPS), et tout nom d'hôte résolu entièrement en boucle locale (règle SSRF).	Développement local uniquement
`COPILOT_HOOK_ALLOW_HTTP_AUTH_HOOKS=1`	Autorise `http://` pour les hooks `preToolUse` et `permissionRequest` n'importe où.	Test uniquement

Les deux variables doivent être définies avant le lancement copilot. Ne les définissez pas globalement, dans CI ou dans des environnements partagés.

Sémantique d’échec du hook HTTP

Pathologie	Comportement
2xx + corps JSON valide	Corps analysé selon le schéma de sortie de l'événement.
2xx + corps vide ou non JSON	Aucune action.
Réponse non-2xx	Le crochet échoue. Erreur enregistrée. L’agent continue.
Redirection 3xx	Le hook échoue (« redirection retournée »). L’agent continue.
Délai d'expiration	Le crochet échoue. Erreur enregistrée. L’agent continue.
Erreur RÉSEAU, DNS ou TLS	Le crochet échoue. Erreur enregistrée. L’agent continue.
Erreur de validation de la configuration au chargement	Fichier de configuration entière rejeté ; aucun point d'attache de ce fichier ne s'enregistre.

Pour preToolUse et permissionRequest, une défaillance du hook HTTP échoue : l’agent passe au flux d’autorisation par défaut.

Événements de hook

Événement	Se déclenche quand	Sortie traitée
`sessionStart`	Une session nouvelle ou reprise commence.	Facultatif — peut retourner `additionalContext` pour injecter un contexte à l'échelle de la session qui précède chaque échange.
`sessionEnd`	La session se termine.	Non
`userPromptSubmitted`	L’utilisateur envoie une invite.	Non
`preToolUse`	Avant l’exécution de chaque outil.	Oui : peut autoriser, refuser ou modifier.
`postToolUse`	Après que chaque outil ait terminé avec succès.	Oui — autorise le remplacement du résultat en cas de succès (uniquement via les hooks programmatiques du SDK).
`postToolUseFailure`	Suite à l’échec d’un outil.	Oui : peut fournir des conseils de récupération via `additionalContext` (code `2` de sortie pour les hooks de commande).
`agentStop`	L’agent principal termine un tour.	Oui : peut bloquer et forcer la continuation.
`subagentStop`	Un sous-assistant termine son exécution.	Oui : peut bloquer et forcer la continuation.
`subagentStart`	Un sous-agent est initié (avant son exécution). Retourne `additionalContext` inséré au début de la requête du sous-agent. Prend en charge `matcher` pour filtrer par nom de l’agent.	Non : impossible de bloquer la création.
`preCompact`	Le compactage de contexte est sur le point de commencer (manuel ou automatique). Prend en charge `matcher` afin de filtrer selon le déclencheur (`"manual"`ou `"auto"`).	Non : notification uniquement.
`permissionRequest`	Avant d’afficher une boîte de dialogue d’autorisation à l’utilisateur, une fois que les vérifications basées sur des règles ne trouvent aucune règle d’autorisation ou de refus correspondante. Gère les expressions régulières `matcher` appliquées à `toolName`.	Oui : peut autoriser ou refuser par programme.
`errorOccurred`	Une erreur se produit pendant l’exécution.	Non
`notification`	S’active de manière asynchrone lorsque l’interface CLI émet une notification système (fin d’exécution de l’interpréteur de commande, achèvement ou inactivité de l’agent, demandes d’autorisation, boîtes de dialogue interactives). Fire-and-forget : ne bloque jamais la session. Gère les expressions régulières `matcher` appliquées à `notification_type`.	Facultatif — possibilité d'injecter `additionalContext` dans la session.

Charges utiles d’entrée associées aux événements de hook

Chaque événement de hook remet une charge utile JSON au gestionnaire de hooks. Deux formats de charge utile sont pris en charge, sélectionnés par le nom d’événement utilisé dans la configuration de hook :

Format camelCase : configurez le nom de l’événement dans camelCase (par exemple, sessionStart). Les champs respectent le format camelCase.

          VS Code format compatible** : configurez le nom de l’événement dans PascalCase (par exemple, `SessionStart`). Les champs utilisent snake_case pour correspondre au format d’extension VS CodeCopilot .

`sessionStart` / `SessionStart`

          **entrée camelCase :**

{
    sessionId: string;
    timestamp: number;      // Unix timestamp in milliseconds
    cwd: string;
    source: "startup" | "resume" | "new";
    initialPrompt?: string;
}

          **
          VS Code entrée compatible :**

{
    hook_event_name: "SessionStart";
    session_id: string;
    timestamp: string;      // ISO 8601 timestamp
    cwd: string;
    source: "startup" | "resume" | "new";
    initial_prompt?: string;
}

`sessionEnd` / `SessionEnd`

          **entrée camelCase :**

{
    sessionId: string;
    timestamp: number;
    cwd: string;
    reason: "complete" | "error" | "abort" | "timeout" | "user_exit";
}

          **
          VS Code entrée compatible :**

{
    hook_event_name: "SessionEnd";
    session_id: string;
    timestamp: string;      // ISO 8601 timestamp
    cwd: string;
    reason: "complete" | "error" | "abort" | "timeout" | "user_exit";
}

`userPromptSubmitted` / `UserPromptSubmit`

          **entrée camelCase :**

{
    sessionId: string;
    timestamp: number;
    cwd: string;
    prompt: string;
}

          **
          VS Code entrée compatible :**

{
    hook_event_name: "UserPromptSubmit";
    session_id: string;
    timestamp: string;      // ISO 8601 timestamp
    cwd: string;
    prompt: string;
}

`preToolUse` / `PreToolUse`

          **entrée camelCase :**

{
    sessionId: string;
    timestamp: number;
    cwd: string;
    toolName: string;
    toolArgs: unknown;
}

          **
          VS Code entrée compatible :**

Lorsqu’elle est configurée avec le nom PreToolUse de l’événement PascalCase, la charge utile utilise des noms de champs en snake_case afin de correspondre au format d’extension VS CodeCopilot :

{
    hook_event_name: "PreToolUse";
    session_id: string;
    timestamp: string;      // ISO 8601 timestamp
    cwd: string;
    tool_name: string;
    tool_input: unknown;    // Tool arguments (parsed from JSON string when possible)
}

`postToolUse` / `PostToolUse`

          **entrée camelCase :**

{
    sessionId: string;
    timestamp: number;
    cwd: string;
    toolName: string;
    toolArgs: unknown;
    toolResult: {
        resultType: "success";
        textResultForLlm: string;
    }
}

          **
          VS Code entrée compatible :**

{
    hook_event_name: "PostToolUse";
    session_id: string;
    timestamp: string;      // ISO 8601 timestamp
    cwd: string;
    tool_name: string;
    tool_input: unknown;
    tool_result: {
        result_type: "success" | "failure" | "denied" | "error";
        text_result_for_llm: string;
    }
}

`postToolUseFailure` / `PostToolUseFailure`

          **entrée camelCase :**

{
    sessionId: string;
    timestamp: number;
    cwd: string;
    toolName: string;
    toolArgs: unknown;
    error: string;
}

          **
          VS Code entrée compatible :**

{
    hook_event_name: "PostToolUseFailure";
    session_id: string;
    timestamp: string;      // ISO 8601 timestamp
    cwd: string;
    tool_name: string;
    tool_input: unknown;
    error: string;
}

`agentStop` / `Stop`

          **entrée camelCase :**

{
    sessionId: string;
    timestamp: number;
    cwd: string;
    transcriptPath: string;
    stopReason: "end_turn";
}

          **
          VS Code entrée compatible :**

{
    hook_event_name: "Stop";
    session_id: string;
    timestamp: string;      // ISO 8601 timestamp
    cwd: string;
    transcript_path: string;
    stop_reason: "end_turn";
}

`subagentStart`

          **Entrée :**

{
    sessionId: string;
    timestamp: number;
    cwd: string;
    transcriptPath: string;
    agentName: string;
    agentDisplayName?: string;
    agentDescription?: string;
}

`subagentStop` / `SubagentStop`

          **entrée camelCase :**

{
    sessionId: string;
    timestamp: number;
    cwd: string;
    transcriptPath: string;
    agentName: string;
    agentDisplayName?: string;
    stopReason: "end_turn";
}

          **
          VS Code entrée compatible :**

{
    hook_event_name: "SubagentStop";
    session_id: string;
    timestamp: string;      // ISO 8601 timestamp
    cwd: string;
    transcript_path: string;
    agent_name: string;
    agent_display_name?: string;
    stop_reason: "end_turn";
}

`errorOccurred` / `ErrorOccurred`

          **entrée camelCase :**

{
    sessionId: string;
    timestamp: number;
    cwd: string;
    error: {
        message: string;
        name: string;
        stack?: string;
    };
    errorContext: "model_call" | "tool_execution" | "system" | "user_input";
    recoverable: boolean;
}

          **
          VS Code entrée compatible :**

{
    hook_event_name: "ErrorOccurred";
    session_id: string;
    timestamp: string;      // ISO 8601 timestamp
    cwd: string;
    error: {
        message: string;
        name: string;
        stack?: string;
    };
    error_context: "model_call" | "tool_execution" | "system" | "user_input";
    recoverable: boolean;
}

`preCompact` / `PreCompact`

          **entrée camelCase :**

{
    sessionId: string;
    timestamp: number;
    cwd: string;
    transcriptPath: string;
    trigger: "manual" | "auto";
    customInstructions: string;
}

          **
          VS Code entrée compatible :**

{
    hook_event_name: "PreCompact";
    session_id: string;
    timestamp: string;      // ISO 8601 timestamp
    cwd: string;
    transcript_path: string;
    trigger: "manual" | "auto";
    custom_instructions: string;
}

          `preToolUse` contrôle de décision

Le preToolUse hook peut contrôler l’exécution de l’outil en écrivant un objet JSON dans stdout (crochets de commande) ou en le retournant dans le corps de la réponse (crochets HTTP).

Champ	Valeurs	Description
`permissionDecision`

          `"allow"`
          `"deny"`
          `"ask"`
         | Indique si l’outil s’exécute. La sortie vide utilise le comportement par défaut. |

| permissionDecisionReason | ficelle | Raison indiquée à l’agent. Recommandé lorsque la décision est "deny" ou "ask". | | modifiedArgs | unknown | Remplace la totalité de l’entrée de l’outil avant l’exécution. Valide uniquement quand permissionDecision n’est pas "deny" ou "ask". | | additionalContext | ficelle | Mis en file d’attente en tant que contexte pour le prochain tour du modèle. Valide uniquement quand permissionDecision n’est pas "deny" ou "ask". |

Remarque

L’alias VS Code (PreToolUse) accepte également les éléments imbriqués hookSpecificOutput.{permissionDecision, permissionDecisionReason, updatedInput, additionalContext}. updatedInput est normalisé à modifiedArgs. Les champs de niveau supérieur sont acceptés comme solution de repli.

          `agentStop`
           / 
          `subagentStop` contrôle de décision

Champ	Valeurs	Description
`decision`

          `"block"`, `"allow"` | 
          `"block"` oblige un autre agent à réagir en utilisant `reason` comme invite. |

| reason | ficelle | Invite pour le tour suivant lorsque decision est "block". |

          `permissionRequest` contrôle de décision

Le permissionRequest crochet se déclenche lorsqu’une boîte de dialogue d’autorisation au niveau de l’outil est sur le point d’être affichée. Elle se déclenche après que les vérifications de permissions basées sur des règles ne trouvent aucune règle d'autorisation ou de refus correspondante. Utilisez-le pour approuver ou refuser des appels d’outils par programmation, particulièrement utiles en mode canal (-p) et environnements CI où aucune invite interactive n’est disponible.

          **Matcher :** Expression régulière facultative testée par rapport à `toolName`. Lorsqu’il est défini, le hook se déclenche uniquement pour les noms d’outils correspondants.

Sortie json vers stdout pour contrôler la décision d’autorisation :

Champ	Valeurs	Description
`behavior`

          `"allow"`, `"deny"` | Spécifie s’il convient d’autoriser ou de refuser l’appel de l’outil. |

Retourne une sortie vide ou {} afin de revenir au comportement par défaut (affichage de la boîte de dialogue utilisateur ou refus en mode pipe). Pour les crochets de commande, le code 2 de sortie est traité comme un refus ; le code JSON stdout (le cas échéant) est fusionné {"behavior":"deny"}avec , et stderr est ignoré.

          `notification` crochet

Le notification hook se déclenche de façon asynchrone lorsque l’interface CLI émet une notification système. Ces hooks fonctionnent selon un modèle « fire-and-forget » : ils ne bloquent jamais la session, et toute erreur est journalisée puis ignorée.

          **Entrée :**

{
    sessionId: string;
    timestamp: number;
    cwd: string;
    hook_event_name: "Notification";
    message: string;           // Human-readable notification text
    title?: string;            // Short title (e.g., "Permission needed", "Shell completed")
    notification_type: string; // One of the types listed below
}

          **Types de notification :**

Type	Quand il se déclenche
`shell_completed`	Une commande d’interpréteur exécutée en arrière-plan (asynchrone) arrive à son terme.
`shell_detached_completed`	Une session shell détachée se termine
`agent_completed`	Une sous-valeur en arrière-plan se termine (terminée ou ayant échoué)
`agent_idle`	Un agent en arrière-plan conclut un cycle et passe en état inactif (en attente de `write_agent`).
`permission_prompt`	L’agent demande l’autorisation d’exécuter un outil
`elicitation_dialog`	L’agent demande des informations supplémentaires à l’utilisateur

          **Output:**

{
    additionalContext?: string; // Injected into the session as a user message
}

Si additionalContext est retourné, le texte est injecté dans la session en tant que message utilisateur préfixé. Cela peut déclencher un traitement supplémentaire de l'agent si la session est inutilisée. Renvoyer {} ou vider la sortie pour n’effectuer aucune action.

          **Matcher :** Regex facultatif sur `notification_type`. Le modèle est ancré comme `^(?:pattern)$`. Omettre `matcher` pour recevoir tous les types de notifications.

Noms d’outils pour la correspondance de hooks

Nom de l’outil	Description
`bash`	Exécuter des commandes shell (Unix).
`powershell`	Exécuter des commandes shell (Windows).
`view`	Lire le contenu du fichier.
`edit`	Modifiez le contenu du fichier.
`create`	Créez des fichiers.
`glob`	Recherchez des fichiers par modèle.
`grep`	Rechercher le contenu du fichier.
`web_fetch`	Récupérer des pages web.
`task`	Exécutez des tâches de sous-agent.

Si plusieurs hooks du même type sont configurés, ils s'exécutent dans l'ordre. Pour preToolUse, si un crochet retourne "deny", l’outil est bloqué. Les codes de sortie s’appliquent uniquement aux hooks de commande : pour les hooks HTTP, consultez la sémantique d’échec du hook HTTP. Pour les hooks de commande postToolUseFailure, une sortie avec le code 2 entraîne le renvoi de stderr comme indication de récupération pour l’assistant. Pour les crochets de commande permissionRequest, le code de sortie 2 est traité comme un refus ; le JSON stdout (le cas échéant) est fusionné avec {"behavior":"deny"}, et stderr est ignoré. Les échecs de hook (codes de sortie non nuls ou délais d’expiration) sont enregistrés et ignorés. Ils ne bloquent jamais l’exécution de l’agent.

Configuration du serveur MCP

Les 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.

          `copilot mcp` Sous-commande

Permet copilot mcp de gérer les configurations de serveur MCP à partir de la ligne de commande sans démarrer une session interactive.

Sous-commande	Description
`list [--json]`	Répertoriez tous les serveurs MCP configurés regroupés par source.
`get <name> [--json]`	Afficher la configuration et les outils d’un serveur spécifique.
`add <name>`	Ajoutez un serveur à la configuration utilisateur. Écrit dans `~/.copilot/mcp-config.json`.
`remove <name>`	Supprimez un serveur au niveau de l’utilisateur. Les serveurs d’espace de travail doivent être modifiés directement dans leurs fichiers de configuration.

          **
          `copilot mcp add` Options:**

Choix	Description
`-- <command> [args...]`	Commande et arguments pour les serveurs locaux (stdio).
`--url <url>`	URL des serveurs distants.
`--type <type>`	Type de transport : `local`, , stdio``httpou `sse`.
`--env KEY=VALUE`	Variable d’environnement (réutilisable).
`--header KEY=VALUE`	En-tête HTTP pour les serveurs distants (reproductible).
`--tools <tools>`	Filtre d’outil : `"*"` pour tous, une liste séparée par des virgules ou `""` pour aucun.
`--timeout <ms>`	Délai d’expiration en millisecondes.
`--json`	Afficher la configuration ajoutée au format JSON.
`--show-secrets`	Afficher les valeurs complètes de la variable d’environnement et de l’en-tête.
`--config-dir <path>`	Chemin d’accès au répertoire de configuration.

Attention

          `--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.

Types de transport

Type	Description	Champs obligatoires
`local` / `stdio`	Processus local de communication via stdin/stdout.

          `command`, `args` |

| http | Serveur distant utilisant le transport HTTP par diffusion en continu. | url | | sse | Un serveur distant utilisant le transport d'événements envoyés par le serveur. | url |

Champs de configuration de serveur local

Champ	Obligatoire	Description
`command`	Oui	Commande pour démarrer le serveur.
`args`	Oui	Arguments de commande (tableau).
`tools`	Oui	Outils à activer : `["*"]` pour tous ou une liste de noms d’outils spécifiques.
`env`	Non	Variables d'environnement. Prend en charge l’expansion de `$VAR`, `${VAR}` et de `${VAR:-default}`.
`cwd`	Non	Répertoire de travail du serveur.
`timeout`	Non	Délai d’expiration des appels de l’outil en millisecondes.
`type`	Non

          `"local"` ou `"stdio"`. Par défaut : `"local"`. |

Champs de configuration de serveur distant

Champ	Obligatoire	Description
`type`	Oui

          `"http"` ou `"sse"`. |

Réauthentification OAuth

Les 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 <server-name> 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.

Mappage de filtres

Contrô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.

Mode	Description
`none`	Aucun filtrage.
`markdown`	Formater la sortie en Markdown.
`hidden_characters`	Supprimez les caractères masqués ou de contrôle. Default.

Serveurs MCP intégrés

L’interface CLI inclut des serveurs MCP intégrés disponibles sans configuration supplémentaire.

Serveur	Description
`github-mcp-server`

          GitHub Intégration de l’API : problèmes, demandes d’extraction, validations, recherche de code et GitHub Actions. |

Permet --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.

Nommage du serveur MCP

Les 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.

Niveaux d’approbation du serveur MCP

Les serveurs MCP sont chargés à partir de plusieurs sources, chacun avec un niveau de confiance différent.

Origine	Niveau de confiance	Révision requise
Intégré	Élevé	Non
Référentiel (`.github/mcp.json`)	Moyenne	Recommandé
Espace de travail (`.mcp.json`)	Moyenne	Recommandé
Configuration utilisateur (`~/.copilot/mcp-config.json`)	User-defined	Responsabilité de l’utilisateur
Serveurs distants	Faible	Toujours

Tous 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.

Liste d'autorisation MCP d'entreprise

          GitHub 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.

Lorsqu’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 :

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.
Envoie les empreintes digitales au point de terminaison d'évaluation de la liste d'autorisation de l'entreprise.
Autorise uniquement les serveurs dont les empreintes digitales sont approuvées ; tous les autres sont bloqués avec un message nommant l’entreprise.

Cette 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.

Lorsqu’un serveur est bloqué par une liste d’autorisation d’entreprise, le CLI affiche :

MCP server "SERVER-NAME" was blocked by your enterprise "ENTERPRISE-NAME".
Contact your enterprise administrator to add this server to the allowlist.

Les serveurs par défaut intégrés sont toujours exemptés de l'application des règles de la liste de permis.

Migration à partir de `.vscode/mcp.json`

Si votre projet utilise .vscode/mcp.json (format de configuration MCP de VS Code), migrez vers .mcp.jsonCLI GitHub Copilot . La migration remapise la servers clé sur mcpServers.

          **Coquilles POSIX (bash, zsh, poisson, etc.) :**

jq '{mcpServers: .servers}' .vscode/mcp.json > .mcp.json

Nécessite jq.

          **PowerShell** :

pwsh -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))"

Sur Windows, remplacez pwsh par powershell si vous utilisez Windows PowerShell au lieu de PowerShell Core.

Informations de référence sur les compétences

Les 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.

Champs de frontmatter des compétences

Champ	Type	Obligatoire	Description
`name`	ficelle	Oui	Identificateur unique de la compétence. Lettres, chiffres et traits d’union uniquement. 64 caractères maximum.
`description`	ficelle	Oui	Que fait la compétence et quand l’utiliser. Nombre maximal de 1024 caractères.
`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.
`user-invocable`	booléen	Non	Indique si les utilisateurs peuvent appeler la compétence avec `/SKILL-NAME`. Par défaut : `true`.
`disable-model-invocation`	booléen	Non	Empêcher l'agent d'activer automatiquement cette fonctionnalité. Par défaut : `false`.

Emplacements des compétences

Les 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).

Lieu	Étendue	Description
`.github/skills/`	Projet	Compétences spécifiques au projet
`.agents/skills/`	Projet	Autre emplacement du projet.
`.claude/skills/`	Projet	Emplacement compatible avec Claude.
Parent `.github/skills/`	Inherited	Prise en charge du répertoire parent d’un monorepo.
`~/.copilot/skills/`	Personnel	Compétences personnelles pour tous les projets.
`~/.agents/skills/`	Personnel	Compétences de l’agent partagées entre tous les projets.
`~/.claude/skills/`	Personnel	Emplacement personnel compatible avec Claude.
Répertoires de plug-in	Plug-in	Compétences des plug-ins installés.
`COPILOT_SKILLS_DIRS`	Personnalisée	Répertoires supplémentaires (séparés par des virgules).
(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.

Commandes (autre format de compétence)

Les 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 description, allowed-tools et disable-model-invocation. Les commandes ont une priorité inférieure à celle des compétences portant le même nom.

Référence des assistants personnalisés

Les agents personnalisés sont des agents IA spécialisés définis dans les fichiers Markdown. Le nom de fichier (moins l’extension) devient l’ID de l’agent. Utilisez .agent.md ou .md comme extension de fichier.

Agents intégrés

Agent	Modèle par défaut	Description
`code-review`	claude-sonnet-4.5	Revue de code à fort rapport signal/bruit. Analyse les différences pour les bogues, les problèmes de sécurité et les erreurs logiques.
`configure-copilot`	varie	Sous-agent intégré pour la gestion Copilot pour CLI de la configuration via le langage naturel : ajout de serveurs MCP, installation d’agents et gestion des compétences. Disponible uniquement en mode expérimental.
`explore`	claude-haiku-4.5	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é.
`general-purpose`	claude-sonnet-4.5	Agent de capacité complète pour les tâches multi-étapes complexes. S’exécute dans une fenêtre contextuelle distincte.
`research`	claude-sonnet-4.6	Agent de recherche approfondie. Génère un rapport basé sur des informations dans votre base de code, dans des référentiels pertinents et sur le web.
`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. Lors de l’utilisation de Claude, il utilise un modèle GPT ; lors de l’utilisation de GPT, il utilise Claude Opus 4.7. N’apporte jamais de modifications directes au code. Disponible uniquement en mode expérimental.
`task`	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.

Champs frontmatter personnalisés d’assistant

Champ	Type	Obligatoire	Description
`description`	ficelle	Oui	Description affichée dans la liste des agents et l'outil `task`.
`infer`	booléen	Non	Autoriser la délégation automatique par l’agent principal. Par défaut : `true`.
`mcp-servers`	objet	Non	Serveurs MCP à connecter. Utilise le même schéma que `~/.copilot/mcp-config.json`.
`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.
`name`	ficelle	Non	Nom complet. La valeur par défaut est le nom de fichier.
`tools`	chaîne de caractères[]	Non	Outils disponibles pour l’agent. Valeur par défaut : `["*"]` (tous les outils).

Emplacements d’agent personnalisés

Étendue	Lieu
Projet

          `.github/agents/` ou `.claude/agents/` |

les agents de niveau Project sont prioritaires sur les agents au niveau de l’utilisateur. Les agents de plug-in ont la priorité la plus basse.

Limites des sous-agents

L'interface CLI impose des limites de profondeur et de concurrence pour empêcher la génération incontrôlée d’agents.

Limite	Par défaut	Variable d'environnement
Profondeur maximale	`6`	`COPILOT_SUBAGENT_MAX_DEPTH`
Nombre maximal simultané	`32`	`COPILOT_SUBAGENT_MAX_CONCURRENT`

          **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. 
          **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. Les valeurs sont limitées entre `1` et `256`.

Réponses d’approbation des autorisations

Lorsque l’interface CLI demande l’autorisation d’exécuter une opération, vous pouvez répondre avec les clés suivantes.

Clé	Résultat
`y`	Autorisez cette requête spécifique une seule fois.
`n`	Refuser cette demande spécifique une seule fois.
`!`	Autorisez toutes les demandes similaires pour le reste de la session.
`#`	Refuser toutes les demandes similaires pour le reste de la session.
`?`	Affichez des informations détaillées sur la demande.

Les approbations de session sont réinitialisées lorsque vous exécutez ou démarrez /clear une nouvelle session.

Supervision OpenTelemetry

          Copilot pour CLI peut exporter des traces et des métriques via [OpenTelemetry (OTel](https://opentelemetry.io/) ), 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](https://github.com/open-telemetry/semantic-conventions/blob/main/docs/gen-ai/).

OTel est désactivé par défaut avec une surcharge nulle. Elle s’active quand l’une des conditions suivantes est remplie :

COPILOT_OTEL_ENABLED=true
OTEL_EXPORTER_OTLP_ENDPOINT est défini
COPILOT_OTEL_FILE_EXPORTER_PATH est défini

Variables d’environnement OTel

Variable	Par défaut	Description
`COPILOT_OTEL_ENABLED`	`false`	Activez explicitement OTel. Non obligatoire si `OTEL_EXPORTER_OTLP_ENDPOINT` est défini.
`OTEL_EXPORTER_OTLP_ENDPOINT`	—	URL du point de terminaison OTLP. La définition de ce paramètre active automatiquement OTel.
`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.
`OTEL_SERVICE_NAME`	`github-copilot`	Nom du service dans les attributs de ressource.
`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.
`OTEL_INSTRUMENTATION_GENAI_CAPTURE_MESSAGE_CONTENT`	`false`	Capturez le contenu complet de l’invite et de la réponse. Voir capture de contenu.
`OTEL_LOG_LEVEL`	—	Niveau du journal de diagnostic OTel : `NONE`, ERROR``WARN``INFO``DEBUG``VERBOSE``ALL.
`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.
`COPILOT_OTEL_SOURCE_NAME`	`github.copilot`	Nom de l’étendue d’instrumentation pour le traceur et le compteur.
`OTEL_EXPORTER_OTLP_HEADERS`	—	En-têtes d’authentification pour l’exportateur OTLP (par exemple, `Authorization=Bearer token`).

Traces

Le 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.

          `invoke_agent` attributs d’étendue

Encapsule l'intégralité de l'appel de l'agent : appels LLM et exécutions d'outils pour chaque message utilisateur.

**Les sessions de niveau supérieur **utilisent le type d’étendue CLIENT (appel de service distant) avec server.address et server.port.
Les appels de sous-agents (par exemple, explore, task) utilisent le type d’étendue INTERNAL (en cours de traitement) sans attributs de serveur.

Caractéristique	Description	Type d’étendue
`gen_ai.operation.name`	`invoke_agent`	Les deux
`gen_ai.provider.name`	Fournisseur (par exemple, , github``anthropic)	Les deux
`gen_ai.agent.id`	Identificateur de session	Les deux
`gen_ai.agent.name`	Nom de l’agent (le cas échéant)	Les deux
`gen_ai.agent.description`	Description de l’agent (le cas échéant)	Les deux
`gen_ai.agent.version`	Version du runtime	Les deux
`gen_ai.conversation.id`	Identificateur de session	Les deux
`gen_ai.request.model`	Modèle demandé	Les deux
`gen_ai.response.finish_reasons`

          `["stop"]` ou `["error"]` | Les deux |

          `chat` attributs d’étendue

Un span par requête LLM. Catégorie d’étendue : CLIENT.

Caractéristique	Description
`gen_ai.operation.name`	`chat`
`gen_ai.provider.name`	Nom du fournisseur
`gen_ai.request.model`	Modèle demandé
`gen_ai.conversation.id`	Identificateur de session
`gen_ai.response.id`	ID de réponse
`gen_ai.response.model`	Modèle résolu
`gen_ai.response.finish_reasons`	Raisons d'arrêt
`gen_ai.usage.input_tokens`	Jetons d’entrée pour ce tour
`gen_ai.usage.output_tokens`	Jetons de sortie pour ce tour
`gen_ai.usage.cache_read.input_tokens`	Lecture des jetons mis en cache
`gen_ai.usage.cache_creation.input_tokens`	Jetons créés en cache
`github.copilot.cost`	Coût du tour
`github.copilot.aiu`	Unités d’IA consommées pour ce tour
`github.copilot.server_duration`	Durée côté serveur
`github.copilot.initiator`	Initiateur de demande
`github.copilot.turn_id`	Identifiant du tour
`github.copilot.interaction_id`	Identificateur d’interaction
`github.copilot.time_to_first_chunk`	Durée de la première diffusion en continu, en secondes (diffusion en continu uniquement)
`server.address`	Nom d’hôte du serveur
`server.port`	Port du serveur
`error.type`	Nom de la classe d’erreur (en cas d’erreur)
`gen_ai.input.messages`	Messages d’invite complets au format JSON (capture de contenu uniquement)
`gen_ai.output.messages`	Messages de réponse complets au format JSON (capture de contenu uniquement)
`gen_ai.system_instructions`	Contenu de commande système en tant que JSON (capture de contenu uniquement)

          `execute_tool` attributs d’étendue

Un span par appel d’outil. Catégorie d’étendue : INTERNAL.

Caractéristique	Description
`gen_ai.operation.name`	`execute_tool`
`gen_ai.provider.name`	Nom du fournisseur (le cas échéant)
`gen_ai.tool.name`	Nom de l’outil (par exemple, `readFile`)
`gen_ai.tool.type`	`function`
`gen_ai.tool.call.id`	Identificateur d’appel de l’outil
`gen_ai.tool.description`	Description de l’outil
`error.type`	Nom de la classe d’erreur (en cas d’erreur)
`gen_ai.tool.call.arguments`	Arguments d’entrée d’outil en tant que JSON (capture de contenu uniquement)
`gen_ai.tool.call.result`	Sortie de l’outil au format JSON (capture de contenu uniquement)

Metrics

Métriques de convention GenAI

Unité de mesure	Type	Unité	Description
`gen_ai.client.operation.duration`	Histogramme	s	Durée d’appel de l’API LLM et de l'invocation de l’agent
`gen_ai.client.token.usage`	Histogramme	tokens	Nombre de jetons par type (`input`/`output`)
`gen_ai.client.operation.time_to_first_chunk`	Histogramme	s	Temps de réception du premier segment de diffusion en continu
`gen_ai.client.operation.time_per_output_chunk`	Histogramme	s	Latence entre segments après le premier segment

Métriques spécifiques au fournisseur

Unité de mesure	Type	Unité	Description
`github.copilot.tool.call.count`	Compteur	calls	Appels d’outils par `gen_ai.tool.name` et `success`
`github.copilot.tool.call.duration`	Histogramme	s	Latence d’exécution des outils par `gen_ai.tool.name`
`github.copilot.agent.turn.count`	Histogramme	Tourne	Allers-retours LLM par invocation d’agent

Événements de span

Événements du cycle de vie enregistrés sur le span actif chat ou invoke_agent.

Événement	Description	Attributs clés
`github.copilot.hook.start`	Un hook a commencé à s’exécuter

          `github.copilot.hook.type`, `github.copilot.hook.invocation_id` |

| github.copilot.hook.end | Un hook a été exécuté avec succès | github.copilot.hook.type, github.copilot.hook.invocation_id | | github.copilot.hook.error | Échec d’un hook | github.copilot.hook.type github.copilot.hook.invocation_id github.copilot.hook.error_message | | github.copilot.session.truncation | L’historique des conversations a été tronqué | 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 | | github.copilot.session.compaction_start | Le compactage de l’histoire a commencé | Aucun | | github.copilot.session.compaction_complete | Compactage de l’historique terminé | 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) | | github.copilot.skill.invoked | Une fonctionnalité a été activée | github.copilot.skill.name github.copilot.skill.path github.copilot.skill.plugin_name github.copilot.skill.plugin_version | | github.copilot.session.shutdown | La session s’arrête | github.copilot.shutdown_type, github.copilot.total_premium_requests, , github.copilot.lines_added, github.copilot.lines_removed, github.copilot.files_modified_count | | github.copilot.session.abort | L’utilisateur a annulé l’opération actuelle | github.copilot.abort_reason | | exception | Erreur de session | github.copilot.error_type github.copilot.error_status_code github.copilot.error_provider_call_id |

Attributs des ressources

Tous les signaux portent ces attributs de ressource.

Caractéristique	Valeur
`service.name`

          `github-copilot` (configurable par `OTEL_SERVICE_NAME`) |

| service.version | Version du runtime |

Capture de contenu

Par 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.

Avertissement

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.

Lorsque la capture de contenu est activée, les attributs suivants sont renseignés.

Caractéristique	Contenu
`gen_ai.input.messages`	Messages d’invite complets (JSON)
`gen_ai.output.messages`	Messages de réponse complets (JSON)
`gen_ai.system_instructions`	Contenu de l’invite système (JSON)
`gen_ai.tool.definitions`	Schémas d’outil (JSON)
`gen_ai.tool.call.arguments`	Arguments d’entrée de l’outil
`gen_ai.tool.call.result`	Sortie de l’outil

Référence de commande CLI pour GitHub Copilot

Dans cet article