Tâches planifiées

Planifiez des tâches récurrentes qui s’exécutent en arrière-plan. Dans ChatGPT sur le Web et les appareils mobiles, les offres éligibles permettent également d’exécuter des tâches à partir d’événements d’application pris en charge. Consultez les tâches actives, en pause et terminées, ainsi que les exécutions récentes, dans Planifié. Vous pouvez combiner des tâches planifiées avec des skills pour les tâches plus complexes.

GPT-5.5 sera retiré de ChatGPT, ChatGPT Work et Codex pour toutes les offres le 14 octobre 2026. Passez en revue les tâches planifiées qui utilisent GPT-5.5 et choisissez un modèle de remplacement disponible avant cette date. Pour Codex avec connexion via ChatGPT, remplacez gpt-5.5 par gpt-5.6-sol (GPT-5.6 Sol). L’API OpenAI n’est pas concernée. Consultez Retrait de GPT-5.5.

Dans l’application de bureau ChatGPT, les tâches planifiées peuvent interagir avec des projets locaux et s’exécuter dans le répertoire du projet ou dans un worktree isolé. Laissez l’ordinateur allumé et l’application en cours d’exécution lorsqu’une tâche planifiée a besoin de fichiers locaux.

Lorsque les tâches planifiées sont activées pour votre espace de travail, créez-les depuis Chat ou ChatGPT Work sur le web et gérez leurs exécutions depuis Planifié. Les tâches web peuvent utiliser le contexte importé et les outils connectés, mais elles ne peuvent pas travailler directement dans un dossier de votre ordinateur.

Codex CLI ne fournit pas l’interface de gestion Planifié. Utilisez ChatGPT sur le web ou l’application de bureau pour créer et gérer les tâches planifiées. La CLI peut d’abord vous aider à préparer et tester un prompt, un skill ou un script.

L’extension IDE ne fournit pas l’interface de gestion Planifié. Utilisez ChatGPT sur le web ou l’application de bureau pour créer et gérer les tâches planifiées. L’extension IDE peut d’abord vous aider à préparer et tester un prompt, un skill ou une modification de l’espace de travail.

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

Ouvrez Planifié pour consulter l’état des tâches et les exécutions récentes. Utilisez une tâche planifiée autonome lorsque chaque exécution doit partir du prompt enregistré. Utilisez une tâche planifiée dans un chat lorsque vous souhaitez que ChatGPT revienne dans le même chat avec son contexte existant.

Les tâches planifiées sur le web peuvent utiliser les fichiers importés, les outils connectés, les skills et les plugins disponibles dans ce chat. Elles ne conservent pas de dossier local ni de worktree disponible entre les exécutions. Placez les instructions durables dans le prompt de la tâche ou dans un skill joint, et conservez les documents sources requis dans un projet accessible, un fichier importé ou un service connecté.

Avant de planifier une tâche, testez son prompt dans une conversation web classique. Examinez les premières exécutions, puis ajustez le prompt, les outils ou la fréquence si les résultats sont trop généraux ou nécessitent davantage de contexte.

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

Avec les offres éligibles, les tâches planifiées peuvent s’exécuter lorsqu’un événement Gmail, Slack ou GitHub pris en charge se produit. Les tâches déclenchées par un événement sont disponibles dans ChatGPT sur le web et les appareils mobiles. Elles ne sont pas disponibles dans l’application de bureau ChatGPT, Codex CLI ni l’extension IDE.

Demandez à ChatGPT de créer la tâche, puis décrivez l’événement à surveiller et l’action à effectuer lorsqu’il se produit. Le déclencheur détermine le moment où la tâche s’exécute ; le prompt enregistré détermine ce que fait chaque exécution. Une tâche peut utiliser plusieurs déclencheurs d’événements, mais elle ne peut pas combiner des déclencheurs d’événements avec une planification horaire.

Les déclencheurs d’événements pris en charge comprennent :

• Gmail : Nouveaux messages entrants, avec filtrage facultatif par expéditeur ou par objet.
• Slack : Nouveaux messages dans les canaux sélectionnés, avec filtrage facultatif par auteur et selon que les réponses aux fils de discussion sont incluses ou non. Les réactions, modifications, suppressions et messages directs ne sont pas pris en charge.
• GitHub : Activité des pull requests dans un dépôt. Filtrez par pull request, auteur, titre ou libellé, puis indiquez si les revues, les commentaires, les mises à jour de commits ou uniquement les fusions doivent déclencher la tâche.

Connectez et autorisez l’application avant de créer la tâche. Pour Slack, ajoutez @ChatGPT à chaque canal surveillé par la tâche. Pour GitHub, l’application connectée doit avoir accès au dépôt.

Lorsque plusieurs événements correspondants surviennent à peu d’intervalle, ChatGPT peut les regrouper en une seule exécution. Ouvrez Planifié pour consulter les événements en attente ou choisissez Exécuter maintenant pour les traiter.

La disponibilité dépend de votre offre 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 avec l’autorisation Autoriser les tâches planifiées déclenchées par des événements.

Vous pouvez, par exemple, planifier une tâche pour évaluer les erreurs de télémétrie et soumettre des correctifs, ou pour créer des rapports sur les modifications récentes de la base de code. Pour un travail continu qui doit conserver le même contexte, planifiez une tâche dans un chat existant.

Pour les tâches planifiées associées à un projet, laissez la machine allumée et l’application de bureau ChatGPT en cours d’exécution. Le projet sélectionné doit toujours être disponible sur le disque au moment où la tâche doit s’exécuter.

Dans les dépôts Git, vous pouvez choisir d’exécuter une tâche planifiée dans votre projet local ou dans un nouveau worktree. Les deux options s’exécutent en arrière-plan. Les worktrees séparent les modifications des tâches planifiées du travail local inachevé, tandis qu’une exécution dans votre projet local peut modifier des fichiers sur lesquels vous travaillez encore. Dans les projets sans contrôle de version, les tâches planifiées s’exécutent directement dans le répertoire du projet.

Vous pouvez également conserver les paramètres par défaut du modèle et de l’effort de raisonnement, ou les choisir explicitement si vous souhaitez contrôler plus précisément l’exécution de la tâche planifiée.

Si une tâche planifiée utilise gpt-5.4 ou gpt-5.4-mini avec connexion via ChatGPT, mettez-la à jour avant le retrait de ces modèles le 31 août 2026. Remplacez gpt-5.4 par gpt-5.6-terra et gpt-5.4-mini par gpt-5.6-luna.

Les tâches planifiées s’exécutent sans supervision avec vos paramètres de bac à sable par défaut. Commencez par les accès les plus restreints permettant à la tâche d’aboutir et n’accordez un accès au réseau ou un accès plus large aux fichiers que si nécessaire. Comprendre le fonctionnement des bacs à sable.

Gérer les tâches planifiées

Retrouvez toutes les tâches planifiées et leurs exécutions dans Planifié, dans la barre latérale de l’application de bureau ChatGPT.

La vue Tâches planifiées fait office de boîte de réception. Les exécutions de tâches planifiées qui produisent des résultats y apparaissent, et un indicateur de contenu non lu signale celles qui nécessitent votre attention.

Les tâches planifiées autonomes démarrent une nouvelle discussion à chaque exécution planifiée et présentent leurs résultats dans Tâches planifiées. Utilisez-les lorsque chaque exécution doit être indépendante ou lorsqu’une tâche planifiée doit s’exécuter sur un ou plusieurs projets. Si vous avez besoin d’une fréquence personnalisée, utilisez les commandes de planification personnalisée. Pour une planification avancée, modifiez sa règle de récurrence RFC 5545 (RRULE), par exemple RRULE:FREQ=MONTHLY;BYMONTHDAY=1;BYHOUR=9;BYMINUTE=0.

Pour les dépôts Git, chaque tâche planifiée peut s’exécuter soit dans votre projet local, soit dans un worktree dédié en arrière-plan. Utilisez les worktrees lorsque vous souhaitez isoler les modifications de la tâche planifiée du travail local inachevé. Utilisez le mode local lorsque vous souhaitez que la tâche planifiée agisse directement dans votre checkout principal, en gardant à l’esprit qu’elle peut modifier des fichiers que vous êtes en train d’éditer. Dans les projets sans contrôle de version, les tâches planifiées s’exécutent directement dans le répertoire du projet. Vous pouvez exécuter la 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 également utiliser des skills. Pour que les tâches planifiées restent faciles à maintenir et à partager entre les équipes, utilisez des skills afin de définir l’action et de fournir les outils et le contexte. Sélectionnez ou invoquez un skill précis dans le prompt de la tâche lorsque le workflow ne doit pas reposer sur la sélection automatique des outils.

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 ChatGPT ou Codex. Décrivez le travail à effectuer, le moment où il doit s’exécuter et indiquez si chaque exécution doit revenir dans la discussion actuelle ou en démarrer une nouvelle. ChatGPT peut rédiger le prompt, choisir la destination appropriée et mettre à jour la tâche lorsque sa portée ou sa fréquence change.

Vous pouvez, par exemple, demander à ChatGPT de planifier un suivi depuis le chat actuel pendant qu’un déploiement se termine, ou lui demander de créer une tâche planifiée autonome qui vérifie régulièrement un projet.

Les skills peuvent également créer ou mettre à jour des tâches planifiées. Par exemple, un skill chargé de surveiller une pull request pourrait configurer une tâche planifiée qui vérifie l’état de la PR avec le plugin GitHub et corrige les nouveaux retours de revue.

Planifier une tâche dans un chat

Planifiez une tâche dans un chat existant lorsque vous souhaitez que ChatGPT revienne dans ce chat selon une fréquence définie. La tâche planifiée utilise le contexte existant du chat au lieu de repartir d’un nouveau prompt à chaque fois.

Les tâches planifiées dans un chat peuvent utiliser des intervalles exprimés en minutes pour les boucles de suivi actives, ou des planifications quotidiennes et hebdomadaires lorsque vous avez besoin d’un point de contrôle à une heure précise.

Planifiez une tâche dans un chat pour :

• vérifier une opération de longue durée jusqu’à ce qu’elle se termine
• vérifier une source connectée à fréquence fixe lorsque vous avez besoin d’un instantané périodique plutôt que d’une réponse à un événement pris en charge dans une application
• rappeler à ChatGPT de poursuivre un cycle de révision à fréquence fixe
• exécuter un flux de travail piloté par un skill qui utilise des plugins, comme vérifier le statut d’une PR et traiter les nouveaux commentaires
• poursuivre une discussion de recherche ou de triage en cours sans perdre son contexte

Utilisez une tâche planifiée autonome lorsque chaque exécution doit être indépendante ou lorsque les résultats doivent apparaître sous forme d’exécutions distinctes dans Planifié.

Lorsque vous planifiez une tâche dans un chat, rendez le prompt durable. Il doit décrire ce que ChatGPT doit faire à chaque exécution planifiée, comment déterminer s’il existe un élément important à signaler et quand s’arrêter ou vous demander des précisions.

Tester les tâches planifiées

Avant de planifier une tâche, testez d’abord manuellement le prompt dans un chat standard. Cela vous permet de confirmer les points suivants :

• Le prompt est clair et son périmètre est correctement défini.
• Le modèle sélectionné ou par défaut, l’effort de raisonnement et les outils fonctionnent comme prévu.
• Le résultat produit peut être facilement examiné.

Lorsque vous commencez à planifier des exécutions, examinez les premiers résultats et ajustez le prompt ou la fréquence selon les besoins.

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

Nettoyage des worktrees pour les tâches planifiées

Si vous choisissez d’utiliser des worktrees pour les dépôts Git, des planifications fréquentes peuvent créer de nombreux worktrees au fil du temps. Archivez les exécutions planifiées dont vous n’avez plus besoin et évitez d’épingler des exécutions, sauf si vous souhaitez conserver leurs worktrees.

Modèle d’autorisations et de sécurité

Les tâches planifiées s’exécutent sans surveillance et utilisent vos paramètres de sandbox par défaut.

Pour une explication accessible de ces limites, consultez la présentation du sandboxing. Pour les règles relatives au système de fichiers et au réseau, consultez Autorisations.

• Si votre mode de sandbox est read-only, les appels d’outils échouent s’ils nécessitent de modifier des fichiers, d’accéder au réseau ou d’interagir avec des applications sur votre ordinateur. Envisagez de définir les paramètres du bac à sable sur workspace write.
• Si votre mode de sandbox est 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’interagir avec des applications sur votre ordinateur. Vous pouvez autoriser de manière sélective l’exécution de commandes en dehors du sandbox à l’aide de règles.
• Si votre mode de sandbox est full access, les tâches planifiées en arrière-plan présentent un risque accru, car ChatGPT peut modifier des fichiers, exécuter des commandes et accéder au réseau sans demander d’autorisation. Envisagez de définir les paramètres du bac à sable sur workspace write et d’utiliser des règles pour définir de manière sélective les commandes que l’agent peut exécuter avec un accès complet.

Si vous utilisez un environnement géré, les administrateurs peuvent limiter ces comportements au moyen d’exigences imposées par l’administration. Ils peuvent, par exemple, interdire approval_policy = "never" ou restreindre les modes de sandbox autorisés. Consultez Exigences imposées par l’administration (requirements.toml).

Les tâches planifiées utilisent approval_policy = "never" lorsque la politique de votre organisation l’autorise. Si les exigences de l’administrateur interdisent approval_policy = "never", les tâches planifiées adoptent le comportement d’approbation du mode d’autorisation sélectionné.

Exemples

Créer automatiquement de nouveaux skills

Scan all of the `~/.codex/sessions` files from the past day and if there have been any issues using particular skills, update the skills to be more helpful. Personal skills only, no repo skills.

If there’s anything we’ve been doing often and struggle with that we should save as a skill to speed up future work, let’s do it.

Definitely don't feel like you need to update any- only if there's a good reason!

Let me know if you make any.

Restez à jour sur votre projet

Look at the latest remote origin/master or origin/main . Then produce an exec briefing for the last 24 hours of commits that touch <DIRECTORY>

Formatting + structure:

- Use rich Markdown (H1 workstream sections, italics for the subtitle, horizontal rules as needed).
- Preamble can read something like “Here’s the last 24h brief for <directory>:”
- Subtitle should read: “Narrative walkthrough with owners; grouped by workstream.”
- Group by workstream rather than listing each commit. Workstream titles should be H1.
- Write a short narrative per workstream that explains the changes in plain language.
- Use bullet points and bolding when it makes things more readable
- Feel free to make bullets per person, but bold their name

Content requirements:

- Include PR links inline (e.g., [#123](...)) without a “PRs:” label.
- Do NOT include commit hashes or a “Key commits” section.
- It’s fine if multiple PRs appear under one workstream, but avoid per‑commit bullet lists.

Scope rules:

- Only include changes within the current cwd (or main checkout equivalent)
- Only include the last 24h of commits.
- Use `gh` to fetch PR titles and descriptions if it helps.
  Also feel free to pull PR reviews and comments

Combinez les tâches planifiées et les skills pour corriger vos propres bugs

Créez un nouveau skill qui tente de corriger un bug introduit par vos propres commits en créant un nouveau fichier $recent-code-bugfix, puis stockez-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.
---

# Recent Code Bugfix

## Overview

Find a bug introduced by the current author in the last week, implement a fix, and verify it when possible. Operate in the current working directory, assume the code is local, and ensure the root cause is tied directly to the author’s own edits.

## Workflow

### 1) Establish the recent-change scope

Use Git to identify the author and changed files from the last week.

- Determine the author from `git config user.name`/`user.email`. If unavailable, use the current user’s name from the environment or ask once.
- Use `git log --since=1.week --author=<author>` to list recent commits and files. Focus on files touched by those commits.
- If the user’s prompt is empty, proceed directly with this default scope.

### 2) Find a concrete failure tied to recent changes

Prioritize defects that are directly attributable to the author’s edits.

- Look for recent failures (tests, lint, runtime errors) if logs or CI outputs are available locally.
- If no failures are provided, run the smallest relevant verification (single test, file-level lint, or targeted repro) that touches the edited files.
- Confirm the root cause is directly connected to the author’s changes, not unrelated legacy issues. If only unrelated failures are found, stop and report that no qualifying bug was detected.

### 3) Implement the fix

Make a minimal fix that aligns with project conventions.

- Update only the files needed to resolve the issue.
- Avoid adding extra defensive checks or unrelated refactors.
- Keep changes consistent with local style and tests.

### 4) Verify

Attempt verification when possible.

- Prefer the smallest validation step (targeted test, focused lint, or direct repro command).
- If verification cannot be run, state what would be run and why it wasn’t executed.

### 5) Report

Summarize the root cause, the fix, and the verification performed. Make it explicit how the root cause ties to the author’s recent changes.

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

Check my commits from the last 24h and submit a $recent-code-bugfix.