{"meta":{"title":"Références sur les hooks GitHub Copilot","intro":"Rechercher des événements de hook, des formats de configuration et des charges utiles d’entrée pour les hooks dans Copilot pour CLI et Agent cloud Copilot.","product":"GitHub Copilot","breadcrumbs":[{"href":"/fr/copilot","title":"GitHub Copilot"},{"href":"/fr/copilot/reference","title":"Informations de référence"},{"href":"/fr/copilot/reference/hooks-reference","title":"Informations de référence sur les hooks"}],"documentType":"article"},"body":"# Références sur les hooks GitHub Copilot\n\nRechercher des événements de hook, des formats de configuration et des charges utiles d’entrée pour les hooks dans Copilot pour CLI et Agent cloud Copilot.\n\n## Présentation\n\nLes 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.\n\nLes 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.\n\nTout 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.\n\n## Emplacements de crochets\n\nLes emplacements où les hooks s’exécutent et où vous pouvez stocker les fichiers de configuration de hooks dépendent de la surface :\n\n* \\*\\*Copilot pour CLI\n  \\*\\* — 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.\n\n  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.\n\n  * **Fichiers de raccordement au niveau du référentiel** , `.github/hooks/*.json` dans la racine du référentiel.\n  * **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/`.\n  * **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.\n  * **Bloc inline `hooks` dans la**`hooks` configuration au niveau de l’utilisateur : champ au niveau supérieur de `~/.copilot/settings.json`.\n  * **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.\n\n* \\*\\*Agent cloud Copilot\n  \\*\\* — 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.\n\n  La configuration du hook est chargée depuis des `.github/hooks/*.json` fichiers dans le référentiel cloné.\n\n## Environnement d’exécution de l’agent cloud\n\nCette 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.\n\n| Propriété              | Valeur                                                                                                                                                                              |\n| ---------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |\n| 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. |\n| Répertoire de travail  |                                                                                                                                                                                     |\n\n```\n          `/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. |\n```\n\n\\| 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. |\n\\| 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. |\n\\| Variables d’environnement disponibles |\n`GITHUB_COPILOT_API_TOKEN` et `GITHUB_COPILOT_GIT_TOKEN` sont configurés dans le bac à sable.\n`COPILOT_AGENT_PROMPT` contient l'invite avec laquelle le travail a été invoqué.\n`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.\n`GITHUB_TOKEN` n’est pas défini. |\n\\| 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. |\n\\| 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. |\n\n## Format de configuration des hooks\n\nLes fichiers de configuration de hook utilisent le format JSON avec la version `1`.\n\n### Crochets de commande\n\nLes commandes hook exécutent des scripts shell et sont prises en charge pour tous les types de hook.\n\n> \\[!NOTE]\n> **Agent cloud uniquement.** L'agent cloud exécute des hooks dans un environnement sandbox Linux. Seul le `bash` champ est respecté ; `powershell` les entrées sont ignorées. Le champ multiplateforme `command` est honoré comme une solution de repli.\n\n```json\n{\n  \"version\": 1,\n  \"hooks\": {\n    \"preToolUse\": [\n      {\n        \"type\": \"command\",\n        \"bash\": \"your-bash-command\",\n        \"powershell\": \"your-powershell-command\",\n        \"cwd\": \"optional/working/directory\",\n        \"env\": { \"VAR\": \"value\" },\n        \"timeoutSec\": 30\n      }\n    ]\n  }\n}\n```\n\n| Champ        | Type        | Obligatoire                                           | Description                                                                                                                            |\n| ------------ | ----------- | ----------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------- |\n| `bash`       | string      | Valeurs possibles : `bash`, `powershell` ou `command` | Commande Shell pour Unix.                                                                                                              |\n| `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. |\n| `cwd`        | string      | Non                                                   | Répertoire de travail de la commande (par rapport à la racine du référentiel ou absolu).                                               |\n| `env`        | Objet       | Non                                                   | Variables d’environnement à définir (prend en charge l’expansion des variables).                                                       |\n| `powershell` | string      | Valeurs possibles : `bash`, `powershell` ou `command` | Commande Shell pour Windows.                                                                                                           |\n| `timeoutSec` | Numéro      | Non                                                   | Délai d’expiration en secondes. Valeur par défaut : `30`.                                                                              |\n| `type`       | `\"command\"` | Oui                                                   | Doit être `\"command\"`.                                                                                                                 |\n\n### Hooks HTTP\n\nLes hooks HTTP envoient la charge utile d’entrée en tant que JSON `POST` à une URL.\n\n> \\[!NOTE]\n> **Agent cloud uniquement.** Le réseau sortant depuis le bac à sable est limité par le pare-feu de l'agent cloud, donc `url` doit cibler un hôte autorisé.\n\n```json\n{\n  \"version\": 1,\n  \"hooks\": {\n    \"postToolUse\": [\n      {\n        \"type\": \"http\",\n        \"url\": \"https://hooks.example.com/copilot\",\n        \"headers\": { \"X-Source\": \"copilot-cli\" },\n        \"allowedEnvVars\": [\"GITHUB_TOKEN\"],\n        \"timeoutSec\": 30\n      }\n    ]\n  }\n}\n```\n\n| Champ            | Type                    | Obligatoire | Description                                                                                                                                                                |\n| ---------------- | ----------------------- | ----------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |\n| `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://`.                 |\n| `headers`        | Objet                   | Non         | En-têtes de demande à inclure.                                                                                                                                             |\n| `timeoutSec`     | Numéro                  | Non         | Délai d’expiration en secondes. Valeur par défaut : `30`.                                                                                                                  |\n| `type`           | `\"http\"`                | Oui         | Doit être `\"http\"`.                                                                                                                                                        |\n| `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. |\n\n### Points d’accroche d’invite\n\nLes 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.\n\n> \\[!NOTE]\n> \\*\\*\n> Copilot pour CLI Seulement.\\*\\* Les crochets d’invite se déclenchent uniquement pour les **nouvelles sessions interactives**. Ils ne se déclenchent pas lors de la reprise et ne se déclenchent pas en mode d’invite non interactif (`-p`).\n\n> \\[!NOTE]\n> **Cloud Agent.** Les travaux d’agent cloud s’exécutent de manière non interactive (similaire à `-p`), il est possible que `prompt` les appels de hook ne soient pas déclenchés. Confirmez le comportement dans votre environnement avant de vous y fier.\n\n```json\n{\n  \"version\": 1,\n  \"hooks\": {\n    \"sessionStart\": [\n      {\n        \"type\": \"prompt\",\n        \"prompt\": \"Your prompt text or /slash-command\"\n      }\n    ]\n  }\n}\n```\n\n| Champ    | Type       | Obligatoire | Description                                                                                 |\n| -------- | ---------- | ----------- | ------------------------------------------------------------------------------------------- |\n| `type`   | `\"prompt\"` | Oui         | Doit être `\"prompt\"`.                                                                       |\n| `prompt` | string     | Oui         | Texte à soumettre : il peut s'agir d'un message en langage naturel ou d'une commande slash. |\n\n## Événements de hook\n\nLe 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.\n\n| Événement   | Se déclenche quand                 | Sortie traitée                                | Agent de cloud |\n| ----------- | ---------------------------------- | --------------------------------------------- | -------------- |\n| `agentStop` | L’agent principal termine un tour. | Oui : peut bloquer et forcer la continuation. | Incendies.     |\n\n```\n          `decision: \"block\"` force un autre tour, qui compte toujours contre le délai d’expiration du travail. |\n```\n\n\\| `errorOccurred` | Une erreur se produit pendant l’exécution. | Non | Incendies. |\n\\| `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. |\n**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). |\n\\| `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. |\n\\| `postToolUse` | Après que chaque outil ait terminé avec succès. | Non | Incendies. |\n\\| `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. |\n\\| `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. |\n\\| `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. |\n\\| `sessionEnd` | La session se termine. | Non | Se déclenche une fois par tâche.\n`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. |\n\\| `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. |\n\\| `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. |\n\\| `subagentStop` | Un sous-agent s'achève. | Oui : peut bloquer et forcer la continuation. | Incendies. |\n\\| `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. |\n\n## Charges utiles d'entrée des événements hook\n\nChaque é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 :\n\n* **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).\n* **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 .\n\n### `sessionStart` / `SessionStart`\n\n```\n          **entrée camelCase :**\n```\n\n```typescript\n{\n    sessionId: string;\n    timestamp: number;      // Unix timestamp in milliseconds\n    cwd: string;\n    source: \"startup\" | \"resume\" | \"new\";\n    initialPrompt?: string;\n}\n```\n\n```\n          **\n          VS Code entrée compatible :**\n```\n\n```typescript\n{\n    hook_event_name: \"SessionStart\";\n    session_id: string;\n    timestamp: string;      // ISO 8601 timestamp\n    cwd: string;\n    source: \"startup\" | \"resume\" | \"new\";\n    initial_prompt?: string;\n}\n```\n\n### `sessionEnd` / `SessionEnd`\n\n```\n          **entrée camelCase :**\n```\n\n```typescript\n{\n    sessionId: string;\n    timestamp: number;\n    cwd: string;\n    reason: \"complete\" | \"error\" | \"abort\" | \"timeout\" | \"user_exit\";\n}\n```\n\n```\n          **\n          VS Code entrée compatible :**\n```\n\n```typescript\n{\n    hook_event_name: \"SessionEnd\";\n    session_id: string;\n    timestamp: string;      // ISO 8601 timestamp\n    cwd: string;\n    reason: \"complete\" | \"error\" | \"abort\" | \"timeout\" | \"user_exit\";\n}\n```\n\n### `userPromptSubmitted` / `UserPromptSubmit`\n\n```\n          **entrée camelCase :**\n```\n\n```typescript\n{\n    sessionId: string;\n    timestamp: number;\n    cwd: string;\n    prompt: string;\n}\n```\n\n```\n          **\n          VS Code entrée compatible :**\n```\n\n```typescript\n{\n    hook_event_name: \"UserPromptSubmit\";\n    session_id: string;\n    timestamp: string;      // ISO 8601 timestamp\n    cwd: string;\n    prompt: string;\n}\n```\n\n### `preToolUse` / `PreToolUse`\n\n```\n          **entrée camelCase :**\n```\n\n```typescript\n{\n    sessionId: string;\n    timestamp: number;\n    cwd: string;\n    toolName: string;\n    toolArgs: unknown;\n}\n```\n\n```\n          **\n          VS Code entrée compatible :**\n```\n\nLorsqu’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 :\n\n```typescript\n{\n    hook_event_name: \"PreToolUse\";\n    session_id: string;\n    timestamp: string;      // ISO 8601 timestamp\n    cwd: string;\n    tool_name: string;\n    tool_input: unknown;    // Tool arguments (parsed from JSON string when possible)\n}\n```\n\n### `postToolUse` / `PostToolUse`\n\n```\n          **entrée camelCase :**\n```\n\n```typescript\n{\n    sessionId: string;\n    timestamp: number;\n    cwd: string;\n    toolName: string;\n    toolArgs: unknown;\n    toolResult: {\n        resultType: \"success\";\n        textResultForLlm: string;\n    }\n}\n```\n\n```\n          **\n          VS Code entrée compatible :**\n```\n\n```typescript\n{\n    hook_event_name: \"PostToolUse\";\n    session_id: string;\n    timestamp: string;      // ISO 8601 timestamp\n    cwd: string;\n    tool_name: string;\n    tool_input: unknown;\n    tool_result: {\n        result_type: \"success\";\n        text_result_for_llm: string;\n    }\n}\n```\n\n### `postToolUseFailure` / `PostToolUseFailure`\n\n```\n          **entrée camelCase :**\n```\n\n```typescript\n{\n    sessionId: string;\n    timestamp: number;\n    cwd: string;\n    toolName: string;\n    toolArgs: unknown;\n    error: string;\n}\n```\n\n```\n          **\n          VS Code entrée compatible :**\n```\n\n```typescript\n{\n    hook_event_name: \"PostToolUseFailure\";\n    session_id: string;\n    timestamp: string;      // ISO 8601 timestamp\n    cwd: string;\n    tool_name: string;\n    tool_input: unknown;\n    error: string;\n}\n```\n\n### `agentStop` / `Stop`\n\n```\n          **entrée camelCase :**\n```\n\n```typescript\n{\n    sessionId: string;\n    timestamp: number;\n    cwd: string;\n    transcriptPath: string;\n    stopReason: \"end_turn\";\n}\n```\n\n```\n          **\n          VS Code entrée compatible :**\n```\n\n```typescript\n{\n    hook_event_name: \"Stop\";\n    session_id: string;\n    timestamp: string;      // ISO 8601 timestamp\n    cwd: string;\n    transcript_path: string;\n    stop_reason: \"end_turn\";\n}\n```\n\n### `subagentStart`\n\n```\n          **Entrée :**\n```\n\n```typescript\n{\n    sessionId: string;\n    timestamp: number;\n    cwd: string;\n    transcriptPath: string;\n    agentName: string;\n    agentDisplayName?: string;\n    agentDescription?: string;\n}\n```\n\n### `subagentStop` / `SubagentStop`\n\n```\n          **entrée camelCase :**\n```\n\n```typescript\n{\n    sessionId: string;\n    timestamp: number;\n    cwd: string;\n    transcriptPath: string;\n    agentName: string;\n    agentDisplayName?: string;\n    stopReason: \"end_turn\";\n}\n```\n\n```\n          **\n          VS Code entrée compatible :**\n```\n\n```typescript\n{\n    hook_event_name: \"SubagentStop\";\n    session_id: string;\n    timestamp: string;      // ISO 8601 timestamp\n    cwd: string;\n    transcript_path: string;\n    agent_name: string;\n    agent_display_name?: string;\n    stop_reason: \"end_turn\";\n}\n```\n\n### `errorOccurred` / `ErrorOccurred`\n\n```\n          **entrée camelCase :**\n```\n\n```typescript\n{\n    sessionId: string;\n    timestamp: number;\n    cwd: string;\n    error: {\n        message: string;\n        name: string;\n        stack?: string;\n    };\n    errorContext: \"model_call\" | \"tool_execution\" | \"system\" | \"user_input\";\n    recoverable: boolean;\n}\n```\n\n```\n          **\n          VS Code entrée compatible :**\n```\n\n```typescript\n{\n    hook_event_name: \"ErrorOccurred\";\n    session_id: string;\n    timestamp: string;      // ISO 8601 timestamp\n    cwd: string;\n    error: {\n        message: string;\n        name: string;\n        stack?: string;\n    };\n    error_context: \"model_call\" | \"tool_execution\" | \"system\" | \"user_input\";\n    recoverable: boolean;\n}\n```\n\n### `preCompact` / `PreCompact`\n\n```\n          **entrée camelCase :**\n```\n\n```typescript\n{\n    sessionId: string;\n    timestamp: number;\n    cwd: string;\n    transcriptPath: string;\n    trigger: \"manual\" | \"auto\";\n    customInstructions: string;\n}\n```\n\n```\n          **\n          VS Code entrée compatible :**\n```\n\n```typescript\n{\n    hook_event_name: \"PreCompact\";\n    session_id: string;\n    timestamp: string;      // ISO 8601 timestamp\n    cwd: string;\n    transcript_path: string;\n    trigger: \"manual\" | \"auto\";\n    custom_instructions: string;\n}\n```\n\n## `preToolUse` contrôle de décision\n\nLe `preToolUse` hook peut contrôler l’exécution de l’outil en écrivant un objet JSON dans stdout.\n\n| Champ                | Valeurs | Description |\n| -------------------- | ------- | ----------- |\n| `permissionDecision` |         |             |\n\n```\n          `\"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. |\n```\n\n\\| `permissionDecisionReason` | string | Raison indiquée à l’agent. Obligatoire lorsque la décision est `\"deny\"`. |\n\\| `modifiedArgs` | Objet | Remplacez les arguments de l’outil à utiliser au lieu des arguments d’origine. |\n\n## `agentStop`\n\n```\n           / \n          `subagentStop` contrôle de décision\n```\n\n| Champ      | Valeurs | Description |\n| ---------- | ------- | ----------- |\n| `decision` |         |             |\n\n```\n          `\"block\"`, `\"allow\"` | \n          `\"block\"` oblige un autre agent à réagir en utilisant `reason` comme invite. |\n```\n\n\\| `reason` | string | Demander le tour suivant quand `decision` est `\"block\"`. |\n\n## `permissionRequest` contrôle de décision\n\n> \\[!NOTE]\n> \\*\\*\n> Copilot pour CLI Seulement.\\*\\* Le `permissionRequest` hook ne s’applique pas sous Agent cloud Copilot: les appels d’outil sont pré-approuvés (voir la ligne **Interactivity** dans la table d’environnement d’exécution de l’agent cloud). Utilisez `preToolUse` pour prendre des décisions d’autorisation dans l’agent cloud.\n\nLe `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.\n\nTous 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.\n\n```\n          **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.\n```\n\nSortie json vers stdout pour contrôler la décision d’autorisation :\n\n| Champ      | Valeurs | Description |\n| ---------- | ------- | ----------- |\n| `behavior` |         |             |\n\n```\n          `\"allow\"`, `\"deny\"` | Indique s’il faut approuver ou refuser l’appel de l’outil. |\n```\n\n\\| `message` | string | Raison communiquée au LLM lors du refus. |\n\\| `interrupt` | booléen | En cas `true` de combinaison avec `\"deny\"`, arrête entièrement l’agent. |\n\nRetournez 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é.\n\n## `notification` Accroche\n\n> \\[!NOTE]\n> \\*\\*\n> Copilot pour CLI Seulement.\\*\\* Le `notification` hook ne se déclenche pas sous Agent cloud Copilot.\n\nLe `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.\n\n```\n          **Entrée :**\n```\n\n```typescript\n{\n    sessionId: string;\n    timestamp: number;\n    cwd: string;\n    hook_event_name: \"Notification\";\n    message: string;           // Human-readable notification text\n    title?: string;            // Short title (e.g., \"Permission needed\", \"Shell completed\")\n    notification_type: string; // One of the types listed below\n}\n```\n\n```\n          **Types de notification :**\n```\n\n| Type                       | Quand il se déclenche                                                                               |\n| -------------------------- | --------------------------------------------------------------------------------------------------- |\n| `shell_completed`          | Une commande shell asynchrone en arrière-plan se termine                                            |\n| `shell_detached_completed` | Une session shell détachée se termine                                                               |\n| `agent_completed`          | Une sous-valeur en arrière-plan se termine (terminée ou ayant échoué)                               |\n| `agent_idle`               | Un agent en arrière-plan termine un tour et entre dans l’état inactif (en attente de `write_agent`) |\n| `permission_prompt`        | L’agent demande l’autorisation d’exécuter un outil                                                  |\n| `elicitation_dialog`       | L’agent demande des informations supplémentaires à l’utilisateur                                    |\n\n```\n          **Output:**\n```\n\n```typescript\n{\n    additionalContext?: string; // Injected into the session as a user message\n}\n```\n\nSi `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.\n\n```\n          **Matcher :** Regex facultatif sur `notification_type`. Le modèle est ancré comme `^(?:pattern)$`. Omettre `matcher` pour recevoir tous les types de notifications.\n```\n\n## Filtrage de correspondance\n\nPlusieurs é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.\n\n\\| Événement |\n`matcher` est mis en correspondance avec |\n\\|-------|------------------------------|\n\\| `notification` | `notification_type` |\n\\| `permissionRequest` | `toolName` |\n\\| `preCompact` |\n`trigger` (`\"manual\"` ou `\"auto\"`) |\n\\| `preToolUse` | `toolName` |\n\\| `subagentStart` | `agentName` |\n\n## Noms d’outils pour la correspondance de hooks\n\n| Nom de l’outil | Description                                                                                                                                            |\n| -------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------ |\n| `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. |\n| `bash`         | Exécuter des commandes shell (Unix).                                                                                                                   |\n| `create`       | Créez des fichiers.                                                                                                                                    |\n| `edit`         | Modifiez le contenu du fichier.                                                                                                                        |\n| `glob`         | Recherchez des fichiers par modèle.                                                                                                                    |\n| `grep`         | Rechercher le contenu du fichier.                                                                                                                      |\n| `powershell`   | Exécuter des commandes shell (Windows). N’apparaît pas sous agent cloud (bac à sable Linux).                                                           |\n| `task`         | Exécutez des tâches de sous-agent.                                                                                                                     |\n| `view`         | Lire le contenu du fichier.                                                                                                                            |\n| `web_fetch`    | Récupérer des pages web.                                                                                                                               |\n\nSi 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.\n\n## Codes de sortie pour les hooks de commande\n\n| Code de sortie | Sens               |\n| -------------- | ------------------ |\n| `0`            | Opération réussie. |\n\n```\n          `stdout` est analysé comme le JSON de sortie du hook s'il est présent. |\n```\n\n\\| `2` | Traité comme un avertissement par défaut.\n`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. |\n\\| Les autres valeurs non nulles | Journalisé en tant qu’échec de raccordement. L’exécution se poursuit (échec d’ouverture). |\n\n## Désactiver tous les hooks\n\nUtilisez `disableAllHooks` quand vous souhaitez conserver votre configuration de hook sur le disque, mais l’empêcher de s’exécuter, par exemple :\n\n* Vous déboguez un problème et vous souhaitez confirmer qu'un hook en est la cause sans supprimer votre configuration.\n* 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.**)\n* 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.**)\n* Silençage temporaire des hooks lents ou bruyants pendant une session interactive. (**Copilot pour CLI uniquement.**)\n\nDéfinissez `disableAllHooks` sur `true` au niveau supérieur pour ignorer chaque point d'ancrage dans le fichier sans le supprimer.\n\n```json\n{\n  \"version\": 1,\n  \"disableAllHooks\": false,\n  \"hooks\": {\n    \"preToolUse\": [ /* hook entries */ ]\n  }\n}\n```\n\nLe comportement dépend de l’emplacement où vous définissez l’indicateur :\n\n* **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.\n* **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.json`pas .\n\n## Lectures complémentaires\n\n* [Utilisation de crochets avec CLI GitHub Copilot](/fr/copilot/how-tos/copilot-cli/use-hooks)\n* [Références sur les hooks GitHub Copilot](/fr/copilot/reference/hooks-configuration)\n* [Référence de commande CLI pour GitHub Copilot](/fr/copilot/reference/copilot-cli-reference/cli-command-reference)\n* [Concepts de l’agent cloud GitHub Copilot](/fr/copilot/concepts/agents/cloud-agent)"}