Références sur les hooks GitHub Copilot

Présentation

Les hooks sont des commandes externes qui s’exécutent à des points de cycle de vie spécifiques pendant une session, ce qui permet l’automatisation personnalisée, les contrôles de sécurité et les intégrations.

Les hooks sont pris en charge dans deux surfaces Copilot : Copilot pour CLI et Agent cloud Copilot. La plupart des charges utiles du format de configuration et des événements sont identiques, mais l’environnement d’exécution et l’ensemble d’événements pouvant être déclenchés diffèrent.

Tout au long de cet article, le comportement qui diffère entre les deux surfaces est indiqué dans les notes « CLI uniquement » et « Agent Cloud uniquement ». Tout ce qui n’est pas marqué s’applique aux deux.

Emplacements de crochets

Les emplacements où les hooks s’exécutent et où vous pouvez stocker les fichiers de configuration de hooks dépendent de la surface :

• Copilot pour CLI — les hooks s’exécutent sur l’ordinateur local du développeur dans le même interpréteur de commandes que l’interface CLI. Tous les événements de hook décrits dans cet article sont pris en charge par la CLI.

  Les hooks sont chargés à partir des sources suivantes dans l’ordre (utilisateur, projet, plug-ins) et combinés. Lorsque le même événement apparaît dans plusieurs sources, toutes les entrées de hook de toutes les sources sont exécutées.

  •           **Fichiers de hook au niveau du référentiel** , `.github/hooks/*.json` dans la racine du référentiel.
    

  • Fichiers de hook au niveau de l’utilisateur : *.json fichiers dans le répertoire des hooks au niveau de l’utilisateur. Par défaut, il s’agit de ~/.copilot/hooks/ sur macOS et Linux, ou %USERPROFILE%\.copilot\hooks\ sur Windows. Si COPILOT_HOME est définie, c’est $COPILOT_HOME/hooks/.

  •           **Bloc inline `hooks` dans les paramètres du référentiel** : le champ `hooks` au niveau supérieur de `.github/copilot/settings.json` (validé dans Git) ou `.github/copilot/settings.local.json` (généralement ignoré par Git et spécifique à l’utilisateur) dans le référentiel. Les fichiers croisés `.claude/settings.json` et `.claude/settings.local.json` dans le référentiel sont également lus.
    

  •           **Bloc inline `hooks` dans la configuration** au niveau de l’utilisateur : le champ `hooks` au niveau supérieur de `~/.copilot/settings.json`.
    

  • Crochets contribués par les plug-ins installés : déclarés par chaque plug-in dans son propre hooks.json (ou sous hooks/hooks.json) à l’intérieur du répertoire d’installation du plug-in.

•           **              Agent cloud Copilot              ** — les hooks s’exécutent à l’intérieur du bac à sable Linux éphémère que l’agent cloud provisionne pour chaque tâche. Le bac à sable est non interactif, a un réseau contraint et est détruit lorsque le travail se termine. Un sous-ensemble d’événements se déclenche, et seules les entrées `bash` (ou `command`) sont prises en compte.
  

  La configuration du hook est chargée depuis des fichiers .github/hooks/*.json dans le référentiel cloné.

Environnement d’exécution de l’agent cloud

Cette section s’applique à Agent cloud Copilot uniquement. Il décrit les contraintes qui affectent la façon dont vous écrivez des scripts de hook et configurez des entrées de hook pour les travaux de l’agent cloud.

Propriété	Valeur
Système d'exploitation	Linux. Seul le bash champ des crochets de commande est respecté ; les entrées powershell sont ignorées. Le champ multiplateforme command est utilisé comme solution de repli.
Répertoire de travail
/workspace lorsqu’un référentiel est cloné ; sinon /root. Utilisez ce chemin lors de la définition cwd d’une entrée de hook ou lors du référencement de fichiers à partir d’un script.
Filesystem	Éphémère. Les fichiers écrits par des hooks (journaux, CSV, transcriptions) sont supprimés lorsque le travail se termine. Pour conserver la sortie du hook, envoyez-la via une entrée de hook http.
Réseau sortant	Restreint par le pare-feu de l’agent cloud. Par défaut, seuls les noms d’hôte GitHub et Copilot sont accessibles ; l’accès à tout autre hôte (par exemple, https://hooks.example.com) nécessite une règle d’autorisation de pare-feu configurée par l’administrateur.
Variables d’environnement disponibles
GITHUB_COPILOT_API_TOKEN et GITHUB_COPILOT_GIT_TOKEN sont configurés dans le bac à sable. COPILOT_AGENT_PROMPT contient la requête avec laquelle la tâche a été invoquée. HOME est défini sur /root, de sorte que tout script de hook qui résout des chemins ~/... écrit dans le bac à sable éphémère.
GITHUB_TOKEN n’est pas défini.
Interactivité	Entièrement non interactif. L’agent s’exécute avec toutes les autorisations d’outil pré-accordées, donc aucune boîte de dialogue d’autorisation n’est affichée et aucune notification n’est exposée à un utilisateur.
Découverte de la configuration	Dans une tâche d’agent cloud, la seule configuration de hook qui existe par défaut se trouve .github/hooks/*.json à l’intérieur du référentiel cloné. Le bac à sable n’est pas fourni avec des fichiers de hook de niveau utilisateur, settings.json, config.json, ou des extensions installées.

Format de configuration des hooks

Les fichiers de configuration de hook utilisent le format JSON avec la version 1.

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	string	Valeurs possibles : bash, powershell ou command	Commande Shell pour Unix.
command	string	Valeurs possibles : bash, powershell ou command	Utilisé en tant que solution de secours multiplateforme lorsque ni bash ni powershell ne sont définis pour la plateforme actuelle.
cwd	string	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	string	Valeurs possibles : bash, powershell ou command	Commande Shell pour Windows.
timeoutSec	Numéro	Non	Délai d’expiration en secondes. Valeur par défaut : 30.
type	"command"	Oui	Doit être "command".

Hooks HTTP

Les hooks HTTP envoient la charge utile d’entrée en tant que JSON POST à une URL.

{
  "version": 1,
  "hooks": {
    "postToolUse": [
      {
        "type": "http",
        "url": "https://hooks.example.com/copilot",
        "headers": { "X-Source": "copilot-cli" },
        "allowedEnvVars": ["GITHUB_TOKEN"],
        "timeoutSec": 30
      }
    ]
  }
}

Champ	Type	Obligatoire	Description
allowedEnvVars	chaîne de caractères[]	Non	Noms de variables d’environnement qui peuvent être développés à l’intérieur des headers valeurs. Quand elle est définie, url doit utiliser https://.
headers	Objet	Non	En-têtes de demande à inclure.
timeoutSec	Numéro	Non	Délai d’expiration en secondes. Valeur par défaut : 30.
type	"http"	Oui	Doit être "http".
url	string	Oui	URL cible. Doit utiliser http: ou https:. Pour preToolUse et permissionRequest, doit utiliser https:// , car la réponse peut accorder des autorisations d’outil.

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. 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
type	"prompt"	Oui	Doit être "prompt".
prompt	string	Oui	Texte à soumettre : il peut s'agir d'un message en langage naturel ou d'une commande slash.

Événements de hook

Le tableau ci-dessous répertorie chaque événement pris en charge. La colonne Agent Cloud indique si l’événement se déclenche sous un agent cloud et note les différences de comportement.

Événement	Se déclenche quand	Sortie traitée	Agent de cloud
agentStop	L’agent principal termine un tour.	Oui : peut bloquer et forcer la continuation.	Incendies. decision: "block" force un autre tour d’exécution, qui est toujours comptabilisé dans le délai d’expiration de la tâche.
errorOccurred	Une erreur se produit pendant l’exécution.	Non	Incendies.
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.
Ne se déclenche pas. L’agent cloud n’affiche pas les notifications à un utilisateur (consultez la ligne Interactivité dans le tableau d’environnement d’exécution de l’agent cloud ci-dessus).
permissionRequest	Se déclenche avant que le service d’autorisation ne s'exécute (moteur de règles, approbations de session, autorisation automatique/refus automatique et invitation de l'utilisateur). Lorsque la sortie agrégée du hook retourne behavior: "allow" ou "deny", cette décision interrompt le flux standard de gestion des permissions. Gère les expressions régulières matcher appliquées à toolName.	Oui : peut autoriser ou refuser par programme.	Les appels d’outils sont pré-approuvés, donc ce hook ne s’exécute pas ou n’a aucun effet. Utilisez preToolUse pour prendre des décisions d’autorisation au lieu de cela.
postToolUse	Après que chaque outil ait terminé avec succès.	Oui : peut modifier le résultat de l’outil ou injecter un contexte supplémentaire pour le modèle.	Incendies.
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).	Incendies.
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.	Se déclenche uniquement avec trigger: "auto". Il n’existe aucun utilisateur pour demander un compactage manuel.
preToolUse	Avant l’exécution de chaque outil.	Oui : peut autoriser, refuser ou modifier.	Incendies. La décision "ask" est traitée comme "deny" car aucun utilisateur n’est disponible pour répondre.
sessionEnd	La session se termine.	Non	Se déclenche une fois par tâche.
reason est généralement "complete", "error" ou "timeout"; "abort" et "user_exit" ne sont pas attendus, car il n'y a pas d'utilisateur.
sessionStart	Une session nouvelle ou reprise commence.	Facultatif — possibilité d'injecter additionalContext dans la session.	Se déclenche une fois par tâche, en tant que nouvelle session (et non une reprise). Consultez la note sur les hooks de requête ci-dessus pour connaître le comportement des entrées prompt sous l’agent cloud.
subagentStart	Un sous-agent est initié (avant son exécution). Prend en charge matcher pour filtrer par nom de l’agent.	Facultatif : impossible de bloquer la création, mais additionalContext est ajouté avant la requête du sous-agent.	Incendies.
subagentStop	Un sous-assistant termine son exécution.	Oui : peut bloquer et forcer la continuation.	Incendies.
userPromptSubmitted	L’utilisateur envoie une invite.	Non	S’exécute au maximum une fois, pour la requête spécifiée pour la tâche. Il n’existe aucune entrée utilisateur de suivi.

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";
        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.

Champ	Valeurs	Description
permissionDecision
"allow", "deny", "ask"	Indique si l’outil s’exécute. La sortie vide utilise le comportement par défaut. Sous l'agent cloud, "ask" est traité comme "deny" parce qu'aucun utilisateur n'est disponible pour répondre.
permissionDecisionReason	string	Raison indiquée à l’agent. Obligatoire lorsque la décision est "deny".
modifiedArgs	Objet	Remplacez les arguments de l’outil à utiliser au lieu des arguments d’origine.

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	string	Invite pour le tour suivant lorsque decision est "block".

postToolUse sortie

Le postToolUse hook peut modifier le résultat de l’outil ou injecter un contexte supplémentaire pour le modèle en écrivant un objet JSON dans stdout.

{
    modifiedResult?: {
        resultType: "success";
        textResultForLlm: string;
    };
    additionalContext?: string;
}

Champ	Type	Description
modifiedResult	Objet	Résultat de l’outil de remplacement. Doit comporter resultType: "success". S’il est renvoyé avec resultType: "failure", la route d’échec en aval est alors empruntée et postToolUseFailure se déclenche ensuite.
additionalContext	string	Des instructions supplémentaires sont ajoutées à textResultForLlm afin que le modèle le voie après la sortie de l’outil dans le même tour. Lorsque plusieurs hooks renvoient additionalContext, les résultats sont concaténés avec deux sauts de ligne et plafonnés à 10 Ko.

Renvoyer {} ou vider la sortie pour conserver le résultat d’origine réussi.

permissionRequest contrôle de décision

Le permissionRequest hook se déclenche avant l'exécution du service de permission : avant les vérifications de règles, les approbations de session, l'acceptation automatique/le refus automatique, et l'interpellation de l'utilisateur. Si les hooks retournent behavior: "allow" ou "deny", cette décision court-circuite le flux de permis normal. L’absence de retour équivaut à suivre le mécanisme habituel de gestion des permissions. Utilisez-le pour approuver ou refuser des appels d’outils par programmation, particulièrement utiles en mode canal CLI (-p) et d’autres utilisations CI CLI où aucune invite interactive n’est disponible. Elle ne s’applique pas à l’agent cloud.

Tous les hooks permissionRequest configurés sont exécutés pour chaque requête, à l’exception des types d’autorisation read et hook, qui sont interceptés avant l’exécution des hooks. Les sorties des hooks sont combinées, celles des hooks exécutés ultérieurement remplaçant les précédentes.

Matcher : Expression régulière facultative testée par rapport à toolName. Ancré comme ^(?:pattern)$; doit correspondre au nom complet de l’outil. 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.
message	string	Motif transmis au GML en cas de refus.
interrupt	booléen	Lorsque true est combiné à "deny", l’agent est entièrement arrêté.

Retournez une sortie vide ou {} afin de rétablir le flux normal de gestion des permissions 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	Un sous-agent en arrière-plan se termine (avec succès ou échec)
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.

Filtrage de correspondance

Plusieurs événements acceptent une expression régulière facultative matcher sur chaque entrée de hook qui filtre les appels pour lesquels le hook se déclenche. Le modèle est ancré comme ^(?:matcher)$ et doit correspondre à la valeur complète. Les expressions régulières invalides entraînent l’ignorance de l’entrée de hook.

| Événement | matcher est mis en correspondance avec | |-------|------------------------------| | notification | notification_type | | permissionRequest | toolName | | preCompact | trigger ("manual" ou "auto") | | preToolUse | toolName | | subagentStart | agentName |

Noms d’outils pour la correspondance de hooks

Nom de l’outil	Description
ask_user	Posez à l’utilisateur une question de clarification. Sous l’agent cloud, il n’y a pas d’utilisateur, donc ask_user ne produit pas de résultat utile.
bash	Exécuter des commandes shell (Unix).
create	Créez des fichiers.
edit	Modifiez le contenu du fichier.
glob	Recherchez des fichiers par modèle.
grep	Rechercher le contenu du fichier.
powershell	Exécuter des commandes shell (Windows). N’apparaît pas sous agent cloud (bac à sable Linux).
task	Exécutez des tâches de sous-agent.
view	Lire le contenu du fichier.
web_fetch	Récupérer des pages web.

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 échecs de hook (codes de sortie non nuls autres que 2, ou en raison de délais d’attente) sont enregistrés et ignorés. Ils ne bloquent jamais l’exécution de l’agent.

Codes de sortie pour les hooks de commande

Code de sortie	Sens
0	Opération réussie.
stdout est analysé comme le JSON de sortie du hook s'il est présent.
2	Traité comme un avertissement par défaut.
stderr est présenté à l’utilisateur, mais l’exécution continue. Pour permissionRequest, la sortie 2 est traitée comme {"behavior":"deny"} et tout stdout JSON est fusionné. Pour postToolUseFailure, la sortie 2 est traitée comme additionalContext et stdout est ajoutée à l’échec indiqué à l’agent.
Les autres valeurs non nulles	Journalisé en tant qu’échec de hook. L’exécution continue (fail-open).

Désactiver tous les hooks

Utilisez disableAllHooks quand vous souhaitez conserver votre configuration de hook sur le disque, mais l’empêcher de s’exécuter, par exemple :

• Déboguer un problème et vérifier si un hook en est la cause sans supprimer votre configuration.
• Suspension de l’automatisation pendant une tâche sensible (révision de code, branche de mise en production, utilisation de secrets) sans perdre la configuration. (Copilot pour CLI uniquement.)
• Publication d’un fichier de hooks dans le contrôle de source que les contributeurs peuvent désactiver localement en configurant l’option dans leur référentiel settings.json. (Copilot pour CLI uniquement.)
• Silençage temporaire des hooks lents ou bruyants pendant une session interactive. (Copilot pour CLI uniquement.)

Définissez disableAllHooks sur true au niveau supérieur pour ignorer chaque point d'ancrage dans le fichier sans le supprimer.

{
  "version": 1,
  "disableAllHooks": false,
  "hooks": {
    "preToolUse": [ /* hook entries */ ]
  }
}

Le comportement dépend de l’emplacement où vous définissez l’indicateur :

•           **Dans un seul fichier `.github/hooks/*.json`**, seuls les hooks déclarés dans ce fichier sont ignorés. Honoré par les deux Copilot pour CLI et Agent cloud Copilot.
  

• Au niveau supérieur du référentiel settings.json — Copilot pour CLI seulement. Chaque hook de chaque source (fichiers du référentiel, fichiers utilisateur, plug-ins et blocs de hook inline) est ignoré lors des sessions de ce référentiel. L’agent cloud ne charge settings.jsonpas .

Lectures complémentaires

• Utilisation de crochets avec CLI GitHub Copilot
• Références sur les hooks GitHub Copilot
• Référence de commande CLI pour GitHub Copilot
• Concepts de l’agent cloud GitHub Copilot