Tâches planifiées

À compter du 14 octobre 2026 à midi, heure du Pacifique (19 h 00 UTC), GPT-5.5 ne sera plus disponible dans Codex pour les utilisateurs qui se connectent avec ChatGPT. Vérifiez les tâches planifiées qui utilisent GPT-5.5 dans Codex et choisissez gpt-6.1-sol (GPT-6.1 Sol) si votre forfait et votre espace de travail vous y donnent accès. Ce retrait ne concerne ni l’API OpenAI ni les sessions Codex authentifiées avec une clé API. Consultez la section Retrait de GPT-5.5 pour connaître les modèles de remplacement proposés avec votre forfait.

Dans l’application de bureau ChatGPT, les tâches planifiées peuvent travailler sur des projets locaux et s’exécuter dans le répertoire du projet ou dans un arbre de travail isolé. Lorsqu’une tâche planifiée a besoin de fichiers locaux, laissez l’ordinateur allumé et l’application ouverte.

Si les tâches planifiées sont activées dans votre espace de travail, créez-les depuis Chat ou ChatGPT Work sur le Web, puis gérez leurs exécutions dans Tâches planifiées. Sur le Web, les tâches peuvent utiliser les éléments de contexte que vous avez importés et les outils connectés, mais elles ne peuvent pas travailler directement dans un dossier de votre ordinateur.

Codex CLI ne propose pas l’interface de gestion des tâches planifiées. Utilisez ChatGPT sur le Web ou l’application de bureau pour créer et gérer ces tâches. La CLI peut vous aider à préparer et à tester au préalable un prompt, un skill ou un script.

L’extension IDE ne propose pas l’interface de gestion des tâches planifiées. Utilisez ChatGPT sur le Web ou l’application de bureau pour créer et gérer ces tâches. L’extension IDE peut vous aider à préparer et à tester au préalable un prompt, un skill ou une modification de l’espace de travail.

Gérer les tâches planifiées sur le Web

Ouvrez Tâches planifiées pour consulter l’état des tâches et leurs exécutions récentes. Utilisez une tâche planifiée autonome si chaque exécution doit partir du prompt enregistré. Planifiez la tâche dans une discussion si vous souhaitez que ChatGPT y revienne et en conserve le contexte.

Sur le Web, les tâches planifiées peuvent utiliser les fichiers importés, les outils connectés, les skills et les plugins disponibles dans la discussion. Elles ne conservent pas l’accès à un dossier local ou à un arbre de travail entre deux exécutions. Placez les consignes qui s’appliquent à chaque exécution dans le prompt de la tâche ou dans un skill associé. Conservez les sources nécessaires dans un projet accessible, un fichier importé ou un service connecté.

Avant de planifier une tâche, testez son prompt dans une discussion ordinaire sur le Web. Examinez les résultats des premières exécutions, puis ajustez le prompt, les outils ou la fréquence si les résultats sont trop généraux ou si la tâche a besoin de davantage de contexte.

Déclencher des tâches à partir d’événements d’application

Avec certains forfaits, une tâche planifiée peut s’exécuter lorsqu’un événement pris en charge survient dans Gmail, Slack ou GitHub. Les tâches déclenchées par un événement sont disponibles dans ChatGPT sur le Web et sur mobile. Elles ne sont disponibles ni dans l’application de bureau ChatGPT, ni dans Codex CLI, ni dans l’extension IDE.

Demandez à ChatGPT de créer la tâche, puis décrivez l’événement à surveiller et l’action à effectuer lorsqu’il survient. Le déclencheur détermine quand la tâche s’exécute. Le prompt enregistré définit ce qu’elle fait à chaque exécution. Une même tâche peut avoir plusieurs déclencheurs d’événements, mais elle ne peut pas les combiner avec une exécution à heures fixes ou à intervalles réguliers.

Les événements suivants peuvent déclencher une tâche :

• Gmail : réception de nouveaux messages. Vous pouvez les filtrer par expéditeur ou par objet.
• Slack : publication de nouveaux messages dans les canaux sélectionnés. Vous pouvez les filtrer par auteur et choisir d’inclure ou non les réponses dans les fils de discussion. Les réactions, les modifications, les suppressions et les messages directs ne sont pas pris en charge.
• GitHub : activité liée aux pull requests d’un dépôt. Filtrez les événements par pull request, auteur, titre ou étiquette, puis choisissez ce qui doit déclencher la tâche : les revues de code, les commentaires, les mises à jour des commits ou uniquement les fusions.

Avant de créer la tâche, connectez l’application et accordez-lui les autorisations nécessaires. Pour Slack, ajoutez @ChatGPT à chaque canal que la tâche surveille. Pour GitHub, l’application connectée doit avoir accès au dépôt.

Lorsque plusieurs événements répondant aux critères surviennent à peu d’intervalle, ChatGPT peut les regrouper en une seule exécution. Ouvrez Tâches planifiées pour consulter les événements en attente ou sélectionnez Exécuter maintenant pour les traiter.

La disponibilité dépend de votre forfait et des paramètres de votre espace de travail. Dans les espaces de travail gérés, les administrateurs peuvent contrôler l’accès à cette fonctionnalité avec l’autorisation Autoriser les tâches planifiées déclenchées par un événement.

Par exemple, planifiez une tâche pour analyser les erreurs relevées par la télémétrie et soumettre des correctifs, ou pour produire des rapports sur les modifications récentes du code source. Pour un travail de suivi qui nécessite de conserver le contexte, planifiez une tâche dans une discussion existante.

Pour les tâches planifiées associées à un projet, laissez l’ordinateur allumé et l’application de bureau ChatGPT ouverte. Le projet sélectionné doit être accessible sur le disque au moment prévu pour l’exécution.

Dans un dépôt Git, vous pouvez choisir d’exécuter une tâche planifiée dans votre projet local ou dans un nouvel arbre de travail. Dans les deux cas, la tâche s’exécute en arrière-plan. Un arbre de travail isole les modifications apportées par la tâche de vos modifications locales en cours. Si la tâche s’exécute dans votre projet local, elle peut modifier des fichiers sur lesquels vous travaillez encore. Dans les projets sans gestion de versions, les tâches planifiées s’exécutent directement dans le répertoire du projet.

Vous pouvez conserver le modèle et l’effort de raisonnement par défaut, ou les choisir vous-même pour mieux contrôler l’exécution de la tâche planifiée.

Si une tâche planifiée utilise un modèle qui a été retiré, modifiez-la pour utiliser un modèle de remplacement disponible. Consultez le guide de migration des modèles.

Les tâches planifiées s’exécutent sans supervision avec les paramètres par défaut de votre bac à sable. Commencez par accorder le minimum d’autorisations nécessaire à la tâche. Accordez-lui l’accès au réseau ou à davantage de fichiers uniquement si elle en a besoin. Comprendre le fonctionnement du bac à sable.

Gérer les tâches planifiées

Dans la barre latérale de l’application de bureau ChatGPT, ouvrez Tâches planifiées pour retrouver toutes les tâches planifiées et leurs exécutions.

La vue Tâches planifiées fait office de boîte de réception. Les exécutions qui ont des résultats à signaler y apparaissent. Un indicateur de résultat non lu vous signale les exécutions qui nécessitent votre attention.

Les tâches planifiées autonomes ouvrent une nouvelle discussion à chaque exécution prévue et affichent leurs résultats dans Tâches planifiées. Utilisez-les si chaque exécution doit être indépendante ou si vous souhaitez exécuter une même tâche sur un ou plusieurs projets. Pour définir une fréquence personnalisée, utilisez les options de planification personnalisée. Pour définir un calendrier plus complexe, modifiez sa règle de récurrence (RRULE) au format RFC 5545, par exemple RRULE:FREQ=MONTHLY;BYMONTHDAY=1;BYHOUR=9;BYMINUTE=0.

Dans un dépôt Git, chaque tâche planifiée peut s’exécuter dans votre projet local ou en arrière-plan dans un arbre de travail dédié. Utilisez un arbre de travail pour isoler les modifications apportées par la tâche de vos modifications locales en cours. Choisissez le mode local si la tâche doit intervenir directement dans votre copie de travail principale. Elle pourra alors modifier des fichiers que vous êtes en train d’éditer. Dans les projets sans gestion de versions, les tâches planifiées s’exécutent directement dans le répertoire du projet. Vous pouvez exécuter une même tâche planifiée sur plusieurs projets.

Les tâches planifiées créées avec ChatGPT Work sur le Web, ou avec ChatGPT Work ou Codex dans l’application de bureau, peuvent utiliser des plugins. Les tâches planifiées peuvent aussi utiliser des skills. Pour faciliter la maintenance des tâches et leur partage entre équipes, utilisez des skills pour définir l’action à effectuer et fournir les outils et le contexte nécessaires. Si le workflow ne doit pas dépendre de la sélection automatique des outils, sélectionnez ou appelez un skill précis dans le prompt de la tâche.

Demander à ChatGPT de créer ou de mettre à jour des tâches planifiées

Vous pouvez créer et mettre à jour des tâches planifiées depuis une discussion dans ChatGPT ou Codex. Décrivez le travail à effectuer, précisez quand la tâche doit s’exécuter et indiquez si chaque exécution doit reprendre la discussion en cours ou en ouvrir une nouvelle. ChatGPT peut rédiger le prompt, choisir la discussion appropriée et mettre à jour la tâche si son périmètre ou sa fréquence change.

Par exemple, demandez à ChatGPT de planifier un suivi dans la discussion en cours en attendant la fin d’un déploiement, ou de créer une tâche planifiée autonome qui vérifie régulièrement un projet.

Les skills peuvent aussi créer ou mettre à jour des tâches planifiées. Par exemple, un skill de suivi des pull requests peut créer une tâche planifiée qui vérifie l’état de la PR avec le plugin GitHub et apporte les corrections demandées lors de la revue de code.

Planifier une tâche dans une discussion

Planifiez une tâche dans une discussion existante si vous souhaitez que ChatGPT y revienne à intervalles réguliers. La tâche réutilise le contexte de la discussion au lieu de repartir d’un nouveau prompt à chaque exécution.

Pour suivre de près une opération, vous pouvez planifier une tâche dans une discussion à des intervalles définis en minutes. Pour faire le point à une heure précise, choisissez une fréquence quotidienne ou hebdomadaire.

Planifiez une tâche dans une discussion pour :

• surveiller une opération de longue durée jusqu’à ce qu’elle se termine ;
• consulter une source connectée à intervalles réguliers lorsque vous avez besoin d’un état des lieux périodique plutôt que d’une réponse à un événement d’application pris en charge ;
• rappeler à ChatGPT de poursuivre une revue à intervalles réguliers ;
• exécuter un workflow défini par un skill et utilisant des plugins, par exemple pour vérifier l’état d’une PR et traiter les nouveaux commentaires ;
• poursuivre une discussion consacrée à des recherches ou au tri de problèmes sans en perdre le contexte.

Utilisez une tâche planifiée autonome si chaque exécution doit être indépendante ou si les résultats doivent apparaître dans des exécutions distinctes dans Tâches planifiées.

Lorsque vous planifiez une tâche dans une discussion, rédigez un prompt qui reste valable au fil des exécutions. Précisez ce que ChatGPT doit faire à chaque exécution, comment déterminer si un résultat mérite d’être signalé et quand s’arrêter ou vous demander des précisions.

Tester les tâches planifiées

Avant de planifier une tâche, testez manuellement son prompt dans une discussion ordinaire. Vérifiez ainsi les points suivants :

• Le prompt est clair et définit bien le périmètre de la tâche.
• Le modèle, l’effort de raisonnement et les outils, qu’ils soient choisis par vous ou définis par défaut, donnent les résultats attendus.
• Vous pouvez examiner le résultat obtenu.

Une fois la tâche planifiée, examinez les résultats des premières exécutions et ajustez le prompt ou la fréquence si nécessaire.

Dans l’application de bureau ChatGPT, vous pouvez appeler explicitement un skill en indiquant $skill-name dans le prompt d’une tâche planifiée.

Nettoyer les arbres de travail des tâches planifiées

Si vous utilisez des arbres de travail pour vos dépôts Git, ils peuvent s’accumuler lorsque les tâches s’exécutent fréquemment. Archivez les exécutions dont vous n’avez plus besoin et n’épinglez que celles dont vous souhaitez conserver l’arbre de travail.

Autorisations et modèle de sécurité

Les tâches planifiées s’exécutent sans supervision et utilisent les paramètres par défaut de votre bac à sable.

Pour comprendre simplement les limites de chaque mode, consultez la présentation du bac à sable. Pour connaître les règles d’accès au système de fichiers et au réseau, consultez la section Autorisations.

• Si votre bac à sable est en lecture seule, les appels d’outils échouent s’ils nécessitent de modifier des fichiers, d’accéder au réseau ou d’utiliser des applications sur votre ordinateur. Envisagez de configurer le bac à sable pour autoriser l’écriture dans l’espace de travail.
• Si votre bac à sable est en mode workspace-write, les appels d’outils échouent s’ils nécessitent de modifier des fichiers en dehors de l’espace de travail, d’accéder au réseau ou d’utiliser des applications sur votre ordinateur. Vous pouvez définir des règles pour autoriser certaines commandes à s’exécuter en dehors du bac à sable.
• Si votre bac à sable est en mode accès complet, les tâches planifiées en arrière-plan présentent un risque accru : ChatGPT peut modifier des fichiers, exécuter des commandes et accéder au réseau sans vous demander d’autorisation. Envisagez de limiter l’écriture à l’espace de travail dans les paramètres du bac à sable, puis de définir des règles pour préciser quelles commandes l’agent peut exécuter avec un accès complet.

Dans un environnement géré, les administrateurs peuvent imposer des exigences pour restreindre ces comportements. Ils peuvent par exemple interdire approval_policy = "never" ou limiter les modes de bac à sable autorisés. Consultez la section Exigences imposées par les administrateurs (requirements.toml).

Les tâches planifiées utilisent approval_policy = "never" lorsque la politique de votre organisation le permet. Si les exigences imposées par les administrateurs interdisent approval_policy = "never", les tâches planifiées appliquent les règles d’approbation du mode d’autorisation que vous avez sélectionné.

Exemples

Créer automatiquement des skills

Parcourez tous les fichiers de `~/.codex/sessions` des dernières 24 heures. Si l’utilisation de certains skills a posé problème, mettez-les à jour pour les rendre plus utiles. Limitez-vous aux skills personnels et excluez ceux des dépôts.

Si une tâche nous pose régulièrement des difficultés et qu’un skill nous ferait gagner du temps la prochaine fois, créez-le.

Ne mettez un skill à jour que si vous avez une bonne raison de le faire.

Indiquez-moi les skills que vous avez créés ou modifiés, le cas échéant.

Suivre l’évolution de votre projet

Consultez le dernier état de la branche distante origin/master ou origin/main. Rédigez ensuite, à l’intention de la direction, une synthèse des commits des dernières 24 heures qui ont modifié <DIRECTORY>.

Mise en forme et structure :

- Utilisez la mise en forme Markdown : un titre de niveau 1 par axe de travail, un sous-titre en italique et des séparateurs horizontaux si nécessaire.
- Vous pouvez commencer par une phrase comme « Voici le bilan des dernières 24 heures pour <directory> : ».
- Utilisez ce sous-titre : « Les changements et leurs responsables, axe de travail par axe de travail. »
- Regroupez les changements par axe de travail sans énumérer chaque commit. Utilisez un titre de niveau 1 pour chaque axe.
- Pour chaque axe, expliquez brièvement en termes simples ce qui a changé.
- Utilisez des listes à puces et du gras lorsqu’ils facilitent la lecture.
- Vous pouvez consacrer une puce à chaque personne. Dans ce cas, mettez son nom en gras.

Contenu :

- Intégrez les liens vers les PR directement dans le texte, par exemple [#123](...), sans les faire précéder de la mention « PR : ».
- N’incluez ni les empreintes des commits ni de section « Commits clés ».
- Un axe de travail peut regrouper plusieurs PR, mais évitez les listes comportant une puce par commit.

Périmètre :

- Incluez uniquement les modifications apportées dans le répertoire de travail courant (ou le répertoire équivalent dans la copie de travail principale).
- Limitez-vous aux commits des dernières 24 heures.
- Si nécessaire, utilisez `gh` pour récupérer les titres et les descriptions des PR.
  Vous pouvez également récupérer les revues de code et les commentaires des PR.

Associer des tâches planifiées à des skills pour corriger vos propres bugs

Créez un skill nommé $recent-code-bugfix qui tente de corriger un bug introduit par l’un de vos commits, puis enregistrez-le dans vos skills personnels.

---
name: recent-code-bugfix
description: Find and fix a bug introduced by the current author within the last week in the current working directory. Use when a user wants a proactive bugfix from their recent changes, when the prompt is empty, or when asked to triage/fix issues caused by their recent commits. Root cause must map directly to the author’s own changes.
---

# Corriger un bug introduit récemment

## Présentation

Repérez un bug introduit par l’auteur actuel au cours des sept derniers jours, corrigez-le et vérifiez le correctif si possible. Travaillez dans le répertoire de travail courant en partant du principe que le code est disponible localement. Assurez-vous que le bug provient directement d’une modification de l’auteur.

## Procédure

### 1) Délimiter les modifications récentes à examiner

Utilisez Git pour identifier l’auteur et les fichiers qu’il a modifiés au cours des sept derniers jours.

- Identifiez l’auteur à l’aide de `git config user.name`/`user.email`. Si ces informations sont indisponibles, utilisez le nom de l’utilisateur actuel fourni par l’environnement ou demandez-le une seule fois.
- Utilisez `git log --since=1.week --author=<author>` pour lister les commits récents et les fichiers concernés. Concentrez-vous sur les fichiers modifiés par ces commits.
- Si le prompt de l’utilisateur est vide, utilisez directement ce périmètre par défaut.

### 2) Repérer un dysfonctionnement précis lié aux modifications récentes

Traitez en priorité les bugs directement imputables aux modifications de l’auteur.

- Si des journaux ou des résultats de CI sont disponibles localement, recherchez-y les échecs récents de tests ou de lint, ainsi que les erreurs d’exécution.
- Si aucun échec n’est signalé, effectuez la vérification la plus ciblée possible sur les fichiers modifiés : exécutez un seul test, lancez le lint sur un fichier ou reproduisez le problème de manière ciblée.
- Vérifiez qu’une modification de l’auteur est directement à l’origine du problème. Si vous ne trouvez que des échecs sans rapport avec ses modifications, arrêtez-vous et indiquez qu’aucun bug répondant aux critères n’a été détecté.

### 3) Apporter le correctif

Apportez un correctif minimal qui respecte les conventions du projet.

- Modifiez uniquement les fichiers nécessaires à la résolution du problème.
- Évitez d’ajouter des contrôles défensifs superflus ou de remanier du code sans rapport avec le problème.
- Veillez à ce que vos modifications soient cohérentes avec le style et les tests existants.

### 4) Vérifier le correctif

Essayez de vérifier le correctif lorsque c’est possible.

- Privilégiez la vérification la plus ciblée : un test précis, une analyse lint limitée au code concerné ou une commande qui reproduit directement le problème.
- Si vous ne pouvez pas effectuer la vérification, indiquez ce que vous auriez exécuté et ce qui vous en a empêché.

### 5) Rendre compte des résultats

Résumez la cause du bug, le correctif et la vérification effectuée. Expliquez précisément quelle modification récente de l’auteur a causé le bug.

Créez ensuite une tâche planifiée :

Examinez mes commits des dernières 24 heures et soumettez un correctif à l’aide de $recent-code-bugfix.