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 supportés dans deux Copilot surfaces : 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 l’interface 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 raccordement 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 en ligne hooks dans les paramètres du dépôt : le champ hooks au niveau supérieur de .github/copilot/settings.json (Git validé) ou .github/copilot/settings.local.json (généralement ignoré par Git et spécifique à l’utilisateur) dans le dépôt. Les fichiers .claude/settings.json croisés et les outils .claude/settings.local.json dans le référentiel sont également lus.
  • Bloc inline hooks dans lahooks configuration au niveau de l’utilisateur : champ 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 configure 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 .github/hooks/*.json fichiers 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 http hook. | | 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 l'invite avec laquelle le travail a été invoqué. HOME est réglé sur /root, de sorte que tout script de hook qui écrit les chemins d'accès ~/... vers 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 de la commande (par rapport à 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.

Points d’accroche 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 slash.

{
  "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 de l’agent de cloud indique si l’événement se déclenche dans un agent de 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, qui compte toujours contre le délai d’expiration du travail. |

| errorOccurred | Une erreur se produit pendant l’exécution. | Non | Incendies. | | notification | Se déclenche de façon asynchrone lorsque l’interface CLI émet une notification système (complétion du shell, complétion de l’agent ou état inactif, invites d'autorisations, dialogues de sollicitation). Fire-and-forget : ne bloque jamais la session. Prend en charge matcher regex sur 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). Si la sortie du hook fusionnée retourne behavior: "allow" ou "deny", cette décision court-circuite le flux d’autorisation normal. Prend en charge matcher regex sur toolName. | Oui : peut autoriser ou refuser par programme. | Les appels d’outils sont pré-approuvés. Ce crochet ne se déclenche pas ou n’a donc 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. | Non | Incendies. | | postToolUseFailure | Une fois qu’un outil rencontre une défaillance. | 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 le filtrage matcher par 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. | Déclenche une fois par tâche, en tant que nouvelle session (et non une reprise). Consultez la note sur les hooks d'invitation ci-dessus pour connaître le comportement des entrées prompt sous l'agent cloud. | | subagentStart | Un sous-agent est lancé (avant qu'il ne s'exécute). Prend en charge matcher pour filtrer par nom de l’agent. | Facultatif : impossible de bloquer la création, mais additionalContext est ajouté avant l'invite du sous-agent. | Incendies. | | subagentStop | Un sous-agent s'achève. | Oui : peut bloquer et forcer la continuation. | Incendies. | | userPromptSubmitted | L’utilisateur envoie une invite. | Non | S'exécute au maximum une fois, pour l’invite spécifiée pour la tâche. Il n’existe aucune entrée utilisateur de suivi. |

Charges utiles d'entrée des événements 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 utilisent la convention de dénomination camelCase (commençant par une minuscule et chaque mot suivant avec une majuscule).
• 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 | Demander le tour suivant quand decision est "block". |

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. Le fait de ne retourner aucune valeur laisse place à la gestion normale des autorisations. 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 configurés permissionRequest s’exécutent pour chaque requête (sauf les types d’autorisations read``hook, qui court-circuitent avant les hooks). Les sorties de hook sont fusionnées avec les sorties de hook ultérieures substituant les sorties antérieures.

          **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"` | Indique s’il faut approuver ou refuser l’appel de l’outil. |

| message | string | Raison communiquée au LLM lors du refus. | | interrupt | booléen | En cas true de combinaison avec "deny", arrête entièrement l’agent. |

Retournez une sortie vide ou {} pour passer au flux de permissions normal. 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 Accroche

Le notification hook se déclenche de façon asynchrone lorsque l’interface CLI émet une notification système. Ces accroches sont automatiques : elles ne bloquent jamais la session, et toutes les erreurs sont enregistrées et ignorées.

          **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 shell asynchrone en arrière-plan se termine
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 termine un tour et entre dans l’é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 crochet qui filtre les appels pour lesquels le crochet se déclenche. Le modèle est ancré comme ^(?:matcher)$ et doit correspondre à la valeur complète. Les regex non valides entraînent l’ignorée de l’entrée de crochet.

| É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 raccordement. L’exécution se poursuit (échec d’ouverture). |

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 :

• Vous déboguez un problème et vous souhaitez confirmer qu'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.)
• Envoi d'un fichier de hooks dans la gestion de version, que les contributeurs peuvent désactiver localement en paramétrant 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 .github/hooks/*.json fichier , 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 dépôt, fichiers utilisateur, plug-ins et blocs de hook inline) est ignoré lors des sessions de ce dépôt. 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