Commandes pour les développeurs | Référence

Commandes de l’application de bureau ChatGPT

La page générale Commandes présente la navigation dans l’application, les raccourcis de conversation, la personnalisation du clavier et les liens profonds vers les conversations, les paramètres, les skills, les tâches planifiées, les plugins et les animaux de compagnie.

La page Commandes slash présente les commandes disponibles dans la zone de saisie de l’application, notamment /feedback, /goal, /init, /mcp, /plan, /review et /status.

Comment lire cette référence

Cette page répertorie toutes les commandes et options documentées de Codex CLI. Utilisez les tableaux interactifs pour effectuer une recherche par clé ou par description. Chaque section indique si l’option est stable ou expérimentale et signale les combinaisons risquées.

Options globales

Clé	Type / Valeurs	Détails
`--add-dir`	`path`	Accordez un accès en écriture à des répertoires supplémentaires en plus de l’espace de travail principal. Répétez l’option pour plusieurs chemins.
`--ask-for-approval, -a`	`untrusted \| on-request \| never`	Déterminez quand Codex doit attendre une approbation humaine avant d’exécuter une commande.
`--cd, -C`	`path`	Définissez le répertoire de travail de l’agent avant qu’il commence à traiter votre demande.
`--config, -c`	`key=value`	Remplacez des valeurs de configuration. Les valeurs sont analysées comme du TOML si possible ; sinon, la chaîne littérale est utilisée.
`--dangerously-bypass-approvals-and-sandbox, --yolo`	`boolean`	Exécutez toutes les commandes sans approbation ni bac à sable. À utiliser uniquement dans un environnement externe renforcé.
`--dangerously-bypass-hook-trust`	`boolean`	Exécutez les hooks activés sans exiger que leur niveau de confiance ait été enregistré pour cette exécution. Réservé aux automatisations qui vérifient déjà les sources des hooks.
`--disable`	`feature`	Forcez la désactivation d’un indicateur de fonctionnalité (équivaut à `-c features.<name>=false`). Option répétable.
`--enable`	`feature`	Forcez l’activation d’un indicateur de fonctionnalité (équivaut à `-c features.<name>=true`). Option répétable.
`--image, -i`	`path[,path...]`	Joignez un ou plusieurs fichiers image au prompt initial. Séparez plusieurs chemins par des virgules ou répétez l’option.
`--local-provider`	`lmstudio \| ollama`	Choisissez le fournisseur local utilisé avec `--oss`, en remplaçant `oss_provider` pour cette exécution.
`--model, -m`	`string`	Remplacez le modèle défini dans la configuration (par exemple `gpt-5.6-terra`).
`--no-alt-screen`	`boolean`	Désactivez le mode d’écran alternatif de la TUI (remplace `tui.alternate_screen` pour cette exécution).
`--oss`	`boolean`	Utilisez un fournisseur local de modèles open source. Codex utilise `--local-provider`, votre `oss_provider` configuré, ou vous invite à choisir entre LM Studio et Ollama.
`--profile, -p`	`string`	Superposez `$CODEX_HOME/profile-name.config.toml` à la configuration utilisateur de base.
`--remote`	`ws://host:port \| wss://host:port \| unix:// \| unix://PATH`	Connectez-vous à un point de terminaison app-server distant via WebSocket ou un socket Unix. Pris en charge pour `codex`, `codex resume`, `codex fork`, `codex archive`, `codex delete` et `codex unarchive` ; les autres sous-commandes refusent le mode distant.
`--remote-auth-token-env`	`ENV_VAR`	Lisez un jeton bearer depuis cette variable d’environnement et envoyez-le lors de la connexion avec `--remote`. Nécessite `--remote` ; les jetons ne sont envoyés que vers des URL `wss://` ou des URL `ws://` exclusivement locales.
`--sandbox, -s`	`read-only \| workspace-write \| danger-full-access`	Sélectionnez la politique de bac à sable pour les commandes shell générées par le modèle.
`--search`	`boolean`	Activez la recherche web en direct (définit `web_search = "live"` au lieu de la valeur par défaut `"cached"`).
`--strict-config`	`boolean`	Déclenchez une erreur lorsque `config.toml` contient des champs que cette version de Codex ne reconnaît pas. Pris en charge par des commandes d’exécution telles que `codex`, `exec`, `review`, `resume`, `fork`, `app-server`, `mcp-server` et `exec-server`.
`PROMPT`	`string`	Instruction textuelle facultative pour démarrer la session. Omettez-la pour lancer la TUI sans message prérempli.

Ces options s’appliquent à la commande codex de base. La plupart sont propagées aux commandes ; consultez les remarques ci-dessus ou l’aide de la commande concernée pour connaître les exceptions. Pour les options propagées, suivez l’aide de la commande concernée. Par exemple, codex exec --oss ... applique --oss à exec.

Vue d’ensemble des commandes

Clé	Maturité	Détails
`codex`	Stable	Lancez l’interface utilisateur du terminal. Accepte les options globales ci-dessus, ainsi qu’un prompt facultatif ou des images jointes.
`codex app`	Stable	Lancez l’application de bureau ChatGPT sur macOS ou Windows. Sous macOS, Codex peut ouvrir le chemin d’un espace de travail ; sous Windows, Codex affiche le chemin à ouvrir.
`codex app-server`	Expérimental	Lancez le serveur d’application Codex pour le développement local ou le débogage via stdio, WebSocket ou un socket Unix.
`codex apply`	Stable	Appliquez à votre worktree locale le dernier diff généré par une conversation Codex cloud. Alias : `codex a`.
`codex archive`	Stable	Archivez une session interactive enregistrée à l’aide de son ID ou de son nom.
`codex cloud`	Expérimental	Parcourez ou exécutez des conversations Codex cloud depuis le terminal sans ouvrir la TUI. Alias : `codex cloud-tasks`.
`codex completion`	Stable	Générez des scripts de complétion shell pour Bash, Zsh, Fish ou PowerShell.
`codex debug app-server send-message-v2`	Expérimental	Déboguez app-server en envoyant un seul message V2 au moyen du client de test intégré.
`codex debug models`	Expérimental	Affichez le catalogue brut des modèles vus par Codex, avec la possibilité de n’examiner que le catalogue intégré.
`codex debug prompt-input`	Expérimental	Générez au format JSON la liste des entrées de prompt visibles par le modèle, avec éventuellement un prompt et des images.
`codex delete`	Stable	Supprimez définitivement une session interactive enregistrée à l’aide de son ID ou de son nom.
`codex doctor`	Stable	Générez un rapport de diagnostic sur l’installation locale, la configuration, l’authentification, l’exécution, Git, le terminal, app-server et l’inventaire des threads.
`codex exec`	Stable	Exécutez Codex de manière non interactive. Alias : `codex e`. Diffusez les résultats vers stdout ou au format JSONL et reprenez éventuellement des sessions précédentes.
`codex execpolicy`	Expérimental	Évaluez des fichiers de règles execpolicy pour déterminer si une commande serait autorisée, soumise à confirmation ou bloquée.
`codex features`	Stable	Répertoriez les indicateurs de fonctionnalité et activez-les ou désactivez-les durablement dans `config.toml`.
`codex fork`	Stable	Créez une nouvelle conversation à partir d’une session interactive précédente tout en conservant la transcription d’origine.
`codex login`	Stable	Authentifiez Codex avec ChatGPT OAuth, l’authentification par appareil, une API key ou un jeton d’accès transmis via stdin.
`codex logout`	Stable	Supprimez les identifiants d’authentification enregistrés.
`codex mcp`	Stable	Gérez les serveurs Model Context Protocol (répertorier, ajouter, supprimer et authentifier).
`codex mcp-server`	Obsolète	Interface obsolète permettant d’exécuter Codex comme MCP server via stdio. Utilisez plutôt le serveur d’application Codex. Pour appeler Codex depuis Claude Code, utilisez le plugin Codex pour Claude Code.
`codex plugin`	Stable	Installez, répertoriez et supprimez des plugins depuis les sources de marketplace configurées.
`codex plugin marketplace`	Stable	Ajoutez, répertoriez, mettez à niveau ou supprimez des marketplaces de plugins provenant de Git ou de sources locales.
`codex remote-control`	Expérimental	Exécutez ou gérez le contrôle à distance de l’app-server local, ou créez un code d’association à courte durée de vie.
`codex resume`	Stable	Poursuivez une session interactive précédente à l’aide de son ID ou reprenez la conversation la plus récente.
`codex review`	Stable	Exécutez une revue non interactive des modifications non validées, du diff avec une branche de base, d’un commit ou d’instructions de revue personnalisées.
`codex sandbox`	Stable	Exécutez des commandes arbitraires dans les bacs à sable macOS, Linux ou Windows fournis par Codex.
`codex unarchive`	Stable	Restaurez une session interactive archivée à l’aide de son ID ou de son nom.
`codex update`	Stable	Recherchez et appliquez une mise à jour de Codex CLI lorsque la version installée prend en charge l’auto-mise à jour.

Détail des commandes

`codex` (mode interactif)

L’exécution de codex sans sous-commande lance l’interface utilisateur interactive du terminal (TUI). L’agent accepte les options globales ci-dessus ainsi que des images jointes. La recherche web utilise par défaut le mode mis en cache ; utilisez --search pour passer à la navigation en direct. Pour travailler localement avec peu de contraintes, utilisez --sandbox workspace-write --ask-for-approval on-request.

Utilisez --remote ws://host:port ou --remote wss://host:port pour connecter la TUI à un serveur d’application démarré avec codex app-server --listen ws://IP:PORT. Pour un socket Unix local, utilisez --remote unix:// pour le socket par défaut ou --remote unix://PATH pour un chemin explicite. Ajoutez --remote-auth-token-env <ENV_VAR> lorsque le serveur exige un jeton bearer pour l’authentification WebSocket.

`codex agents`

Ouvrez le centre de commandes pour parcourir les conversations et passer d’un agent à l’autre sur un serveur partagé. Utilisez --remote <URL> pour vous connecter à un serveur distant et --cd <DIR> pour définir le répertoire des nouvelles tâches distantes. codex agents ne prend pas en charge --no-daemon.

`codex queue`

Placez un message texte dans la file d’attente d’une session existante :

codex queue --thread <SESSION_ID> --message "Run the remaining checks"

--thread accepte un UUID ou un nom de session exact. Utilisez un UUID lorsque des sessions portent le même nom. La commande accepte également --remote et --remote-auth-token-env ; les images jointes ne sont pas prises en charge.

`codex app-server`

Lancez localement le serveur d’application Codex. Cette fonctionnalité est principalement destinée au développement et au débogage et peut changer sans préavis.

Clé	Type / Valeurs	Détails
`--analytics-default-enabled`	`boolean`	Active les analyses par défaut pour les clients app-server internes, sauf si l’utilisateur les désactive dans la configuration.
`--listen`	`stdio:// \| ws://IP:PORT \| unix:// \| unix://PATH \| off`	URL d’écoute du transport. Utilisez `stdio://` pour JSONL, `ws://IP:PORT` pour un point de terminaison WebSocket TCP, `unix://` pour le socket Unix par défaut, `unix://PATH` pour un socket Unix personnalisé ou `off` pour désactiver le transport local.
`--stdio`	`boolean`	Utilisez le transport stdio. Équivaut à `--listen stdio://` et est mutuellement exclusif avec `--listen`.
`--ws-audience`	`string`	Revendication `aud` attendue pour les jetons bearer signés. Nécessite `--ws-auth signed-bearer-token`.
`--ws-auth`	`capability-token \| signed-bearer-token`	Mode d’authentification des clients WebSocket d’app-server. S’il est omis, l’authentification WebSocket est désactivée ; les écouteurs non locaux affichent un avertissement au démarrage.
`--ws-issuer`	`string`	Revendication `iss` attendue pour les jetons bearer signés. Nécessite `--ws-auth signed-bearer-token`.
`--ws-max-clock-skew-seconds`	`number`	Tolérance de décalage d’horloge lors de la validation des revendications `exp` et `nbf` des jetons bearer signés. Nécessite `--ws-auth signed-bearer-token`.
`--ws-shared-secret-file`	`absolute path`	Fichier contenant le secret partagé HMAC utilisé pour valider les jetons bearer JWT signés. Requis avec `--ws-auth signed-bearer-token`.
`--ws-token-file`	`absolute path`	Fichier contenant le jeton de capacité partagé. Utilisez-le avec `--ws-auth capability-token`, sauf si vous fournissez plutôt `--ws-token-sha256`.
`--ws-token-sha256`	`hexadecimal SHA-256 digest`	Empreinte SHA-256 attendue pour l’authentification par jeton de capacité. Utilisez-la à la place de `--ws-token-file` lorsque le jeton client provient d’une autre source.

codex app-server --listen stdio:// conserve le comportement JSONL sur stdio par défaut, et codex app-server --stdio est un alias de ce transport. --listen ws://IP:PORT active le transport WebSocket pour les clients app-server. Le serveur accepte les URL d’écoute ws:// ; utilisez une terminaison TLS ou un proxy sécurisé lorsque les clients se connectent avec wss://. Utilisez --listen unix:// pour accepter les négociations WebSocket sur le socket Unix par défaut de Codex, ou --listen unix:///absolute/path.sock pour choisir un chemin de socket. Si vous générez des schémas pour les liaisons clientes, ajoutez --experimental afin d’inclure les champs et méthodes soumis à autorisation.

Ajoutez --code-mode-host wss://code-mode.example.com/host pour connecter app-server à un hôte Code Mode distant au lieu de démarrer un hôte local. Cette connexion sortante est distincte de --listen et partagée par tous les threads du processus app-server. Utilisez ws:// uniquement pour un hôte localhost ou transféré par SSH.

`codex remote-control`

Exécutez codex remote-control pour démarrer le contrôle à distance via le serveur géré en arrière-plan lorsque les conditions le permettent, avec une solution de repli au premier plan. Utilisez codex remote-control --no-daemon pour forcer l’exécution au premier plan. Utilisez codex remote-control start pour démarrer le démon app-server local avec le contrôle à distance activé, et codex remote-control stop pour l’arrêter. Les clients gérés de contrôle à distance et les workflows distants SSH utilisent ces commandes ; elles ne remplacent pas codex app-server --listen lorsque vous développez un client local pour le protocole.

Une fois le démon démarré, utilisez codex remote-control pair pour créer et afficher un code d’appairage manuel de courte durée. Ajoutez --json à toute commande de contrôle à distance pour obtenir une sortie exploitable par machine. Pour pair, la réponse JSON inclut pairingCode, manualPairingCode, environmentId et expiresAt. --no-daemon s’applique uniquement à la commande remote-control seule ; ne le combinez pas avec start, stop ou pair.

`codex app`

Lancez l’application de bureau ChatGPT depuis le terminal sous macOS ou Windows. Sous macOS, Codex peut ouvrir le chemin d’un espace de travail précis ; sous Windows, Codex affiche le chemin à ouvrir.

Clé	Type / Valeurs	Détails
`--download-url`	`url`	Remplacement avancé de l’URL du programme d’installation de l’application de bureau ChatGPT utilisée pendant l’installation.
`PATH`	`path`	Chemin de l’espace de travail pour l’application de bureau ChatGPT. Sous macOS, Codex ouvre ce chemin ; sous Windows, Codex l’affiche.

codex app ouvre l’application de bureau ChatGPT installée ou lance le programme d’installation si l’application est absente. Sous macOS, Codex ouvre le chemin d’espace de travail fourni ; sous Windows, il affiche le chemin à ouvrir après l’installation.

`codex debug app-server send-message-v2`

Envoyez un message via le flux thread/turn V2 d’app-server à l’aide du client de test app-server intégré.

Clé	Type / Valeurs	Détails
`USER_MESSAGE`	`string`	Texte du message envoyé à app-server via le flux du client de test V2 intégré.

Ce flux de débogage s’initialise avec experimentalApi: true, démarre un thread, envoie un tour et diffuse les notifications du serveur. Utilisez-le pour reproduire et examiner localement le comportement du protocole app-server.

`codex debug models`

Affichez au format JSON le catalogue brut des modèles vus par Codex.

Clé	Type / Valeurs	Détails
`--bundled`	`boolean`	Ignorez l’actualisation et affichez uniquement le catalogue des modèles intégré au binaire Codex actuel.

Utilisez --bundled lorsque vous souhaitez examiner uniquement le catalogue intégré au binaire actuel, sans l’actualiser depuis le point de terminaison distant des modèles.

`codex debug prompt-input`

Générez au format JSON la liste exacte des entrées de prompt visibles par le modèle. Utilisez cette commande pour déboguer la découverte des instructions, le contexte de session ou la construction du prompt.

Clé	Type / Valeurs	Détails
`--image, -i`	`path[,path...]`	Joignez une ou plusieurs images au prompt utilisateur. Séparez plusieurs chemins par des virgules ou répétez l’option.
`PROMPT`	`string`	Prompt utilisateur facultatif ajouté après le contexte de session.

`codex apply`

Appliquez à votre dépôt local le diff le plus récent d’une conversation Codex cloud. Vous devez être authentifié et avoir accès à la conversation.

Clé	Type / Valeurs	Détails
`TASK_ID`	`string`	Identifiant de la conversation Codex cloud dont le diff doit être appliqué.

Codex affiche les fichiers corrigés et renvoie un code de sortie non nul si git apply échoue (par exemple en raison de conflits).

`codex review`

Exécutez une revue de code de manière non interactive. Choisissez exactement une cible de revue ou transmettez des instructions de revue personnalisées sous forme de prompt.

Clé	Type / Valeurs	Détails
`--base`	`branch`	Examinez les modifications par rapport à la branche de base indiquée.
`--commit`	`SHA`	Examinez les modifications introduites par le commit indiqué.
`--strict-config`	`boolean`	Déclenchez une erreur lorsque `config.toml` contient des champs que cette version de Codex ne reconnaît pas.
`--title`	`string`	Définissez le titre du commit affiché dans le résumé de la revue. Nécessite `--commit`.
`--uncommitted`	`boolean`	Examinez les modifications indexées, non indexées et non suivies.
`PROMPT`	`string \| - (read stdin)`	Instructions de revue personnalisées. Utilisez `-` pour lire les instructions depuis stdin.

--uncommitted, --base, --commit et un PROMPT personnalisé sont incompatibles entre eux. Utilisez --title uniquement avec --commit.

`codex archive` et `codex unarchive`

Archivez ou restaurez une session interactive enregistrée à l’aide de son ID ou de son nom. Utilisez ces commandes pour alléger le sélecteur de sessions sans supprimer la transcription. Les ID de session sont prioritaires sur les noms de session.

codex archive <SESSION>
codex unarchive <SESSION>

Clé	Type / Valeurs	Détails
`--remote`	`ws://host:port \| wss://host:port \| unix:// \| unix://PATH`	Connectez-vous à un point de terminaison app-server distant avant de modifier l’état d’archivage.
`--remote-auth-token-env`	`ENV_VAR`	Lisez un jeton bearer depuis cette variable d’environnement lorsque `--remote` exige une authentification.
`SESSION`	`session ID \| session name`	Session enregistrée à archiver ou restaurer. Les ID de session sont prioritaires sur les noms de session.

`codex delete`

Supprimez définitivement une session interactive enregistrée à l’aide de son ID ou de son nom. Utilisez cette commande uniquement pour supprimer la transcription au lieu de la masquer dans les listes de sessions actives.

codex delete <SESSION>
codex delete <SESSION_UUID> --force

Clé	Type / Valeurs	Détails
`--force`	`boolean`	Supprimez sans demander de confirmation. L’argument de session doit être un UUID ; les noms nécessitent toujours une confirmation interactive.
`--remote`	`ws://host:port \| wss://host:port \| unix:// \| unix://PATH`	Connectez-vous à un point de terminaison app-server distant avant de supprimer la session.
`--remote-auth-token-env`	`ENV_VAR`	Lisez un jeton bearer depuis cette variable d’environnement lorsque `--remote` exige une authentification.
`SESSION`	`session ID \| session name`	Session enregistrée à supprimer. Les ID de session sont prioritaires sur les noms de session.

Utilisez --force uniquement avec un UUID de session. Les sessions nommées nécessitent toujours une confirmation afin que Codex ne supprime pas sans avertissement un nom répété ou ambigu.

`codex cloud`

Interagissez avec les conversations Codex cloud depuis le terminal. La commande par défaut ouvre un sélecteur interactif ; codex cloud exec envoie directement une tâche et codex cloud list renvoie les conversations récentes pour les scripts ou une consultation rapide.

Clé	Type / Valeurs	Détails
`--attempts`	`1-4`	Nombre de tentatives de l’assistant (meilleure parmi N) que Codex cloud doit exécuter.
`--env`	`ENV_ID`	Identifiant de l’environnement Codex cloud cible (obligatoire). Utilisez `codex cloud` pour afficher les choix disponibles.
`QUERY`	`string`	Prompt de la tâche. S’il est omis, Codex vous demande les détails de manière interactive.

L’authentification utilise les mêmes identifiants que la CLI principale. Codex renvoie un code de sortie non nul si l’envoi de la tâche échoue.

`codex cloud list`

Répertoriez les conversations cloud récentes avec filtrage et pagination facultatifs.

Clé	Type / Valeurs	Détails
`--cursor`	`string`	Curseur de pagination renvoyé par une requête précédente.
`--env`	`ENV_ID`	Filtrez les tâches par identifiant d’environnement.
`--json`	`boolean`	Produisez du JSON lisible par une machine au lieu de texte brut.
`--limit`	`1-20`	Nombre maximal de tâches à renvoyer.

La sortie en texte brut affiche l’URL d’une tâche, suivie des détails de son état. Utilisez --json pour l’automatisation. La charge utile JSON contient un tableau tasks et éventuellement une valeur cursor. Chaque tâche comprend id, url, title, status, updated_at, environment_id, environment_label, summary, is_review et attempt_total.

`codex completion`

Générez des scripts de complétion shell et redirigez la sortie vers l’emplacement approprié, par exemple codex completion zsh > "${fpath[1]}/_codex".

Clé	Type / Valeurs	Détails
`SHELL`	`bash \| zsh \| fish \| power-shell \| elvish`	Shell pour lequel générer les complétions. La sortie est écrite sur stdout.

`codex doctor`

Générez un rapport de diagnostic local avant de signaler un problème à l’assistance ou lorsque vous recherchez la cause d’une installation Codex défectueuse. Le rapport vérifie l’état de l’installation, de la configuration, de l’authentification, de l’exécution, de Git, du terminal, d’app-server et de l’inventaire des threads.

Clé	Type / Valeurs	Détails
`--all`	`boolean`	Développez les longues listes dans le rapport détaillé lisible par une personne.
`--ascii`	`boolean`	Utilisez des libellés d’état et des séparateurs ASCII dans la sortie lisible par une personne.
`--json`	`boolean`	Produisez un rapport d’assistance expurgé et lisible par une machine.
`--no-color`	`boolean`	Désactivez les couleurs ANSI dans la sortie lisible par une personne.
`--summary`	`boolean`	Affichez uniquement les lignes de vérification regroupées et le décompte récapitulatif final.

`codex features`

Gérez les indicateurs de fonctionnalité stockés dans $CODEX_HOME/config.toml. Les commandes enable et disable enregistrent durablement les modifications afin qu’elles s’appliquent aux sessions futures. La sous-commande features n’accepte pas --profile.

Clé	Type / Valeurs	Détails
`Disable subcommand`	`codex features disable <feature>`	Désactivez durablement un indicateur de fonctionnalité dans `$CODEX_HOME/config.toml`.
`Enable subcommand`	`codex features enable <feature>`	Activez durablement un indicateur de fonctionnalité dans `$CODEX_HOME/config.toml`.
`List subcommand`	`codex features list`	Affichez les indicateurs de fonctionnalité connus, leur niveau de maturité et leur état effectif.

`codex exec`

Utilisez codex exec (ou la forme courte codex e) pour les exécutions scriptées ou de type CI qui doivent s’achever sans intervention humaine.

Clé	Type / Valeurs	Détails
`--cd, -C`	`path`	Définissez la racine de l’espace de travail avant d’exécuter la tâche.
`--color`	`always \| never \| auto`	Contrôlez les couleurs ANSI dans stdout.
`--dangerously-bypass-approvals-and-sandbox, --yolo`	`boolean`	Contournez les demandes d’approbation et le bac à sable. Dangereux — à utiliser uniquement dans un exécuteur isolé.
`--dangerously-bypass-hook-trust`	`boolean`	Exécutez les hooks activés sans exiger que leur niveau de confiance ait été enregistré pour cette exécution. Réservé aux automatisations qui vérifient déjà les sources des hooks.
`--ephemeral`	`boolean`	Exécutez sans enregistrer les fichiers de déroulement de session sur le disque.
`--full-auto`	`boolean`	Option de compatibilité obsolète. Préférez `--sandbox workspace-write` ; Codex affiche un avertissement lorsque cette option est utilisée.
`--ignore-rules`	`boolean`	Ne chargez pas les fichiers execpolicy `.rules` de l’utilisateur ou du projet pour cette exécution.
`--ignore-user-config`	`boolean`	Ne chargez pas `$CODEX_HOME/config.toml`. L’authentification utilise toujours `CODEX_HOME`.
`--image, -i`	`path[,path...]`	Joignez des images au premier message. Option répétable ; prend en charge les listes séparées par des virgules.
`--json, --experimental-json`	`boolean`	Affichez des événements JSON délimités par des sauts de ligne au lieu de texte mis en forme.
`--local-provider`	`lmstudio \| ollama`	Choisissez le fournisseur local utilisé avec `--oss`, en remplaçant `oss_provider` pour cette exécution.
`--model, -m`	`string`	Remplacez le modèle configuré pour cette exécution.
`--oss`	`boolean`	Utilisez un fournisseur local open source. Codex utilise `--local-provider` ou votre `oss_provider` configuré, et se termine avec une erreur si aucun des deux n’est défini.
`--output-last-message, -o`	`path`	Écrivez le message final de l’assistant dans un fichier. Utile pour les scripts en aval.
`--output-schema`	`path`	Fichier JSON Schema décrivant la forme attendue de la réponse finale. Codex valide la sortie de l’outil par rapport à ce schéma.
`--profile, -p`	`string`	Superposez `$CODEX_HOME/profile-name.config.toml` à la configuration utilisateur de base.
`--sandbox, -s`	`read-only \| workspace-write \| danger-full-access`	Politique de bac à sable pour les commandes générées par le modèle. Utilise la configuration par défaut.
`--skip-git-repo-check`	`boolean`	Autorisez l’exécution en dehors d’un dépôt Git (utile pour les répertoires ponctuels).
`-c, --config`	`key=value`	Remplacement de configuration en ligne pour l’exécution non interactive (répétable).
`PROMPT`	`string \| - (read stdin)`	Instruction initiale de la tâche. Utilisez `-` pour transmettre le prompt depuis stdin.
`Resume subcommand`	`codex exec resume [SESSION_ID]`	Reprenez une session exec à l’aide de son ID ou ajoutez `--last` pour poursuivre la session la plus récente du répertoire de travail actuel. Ajoutez `--all` pour prendre en compte les sessions de tous les répertoires. Accepte un prompt de suivi facultatif.

Codex écrit par défaut une sortie mise en forme. Ajoutez --json pour recevoir des événements JSON délimités par des sauts de ligne (un par changement d’état). La sous-commande facultative resume permet de poursuivre des tâches non interactives. Utilisez --last pour sélectionner la session la plus récente du répertoire de travail actuel, ou ajoutez --all pour effectuer la recherche dans toutes les sessions :

Clé	Type / Valeurs	Détails
`--all`	`boolean`	Incluez les sessions extérieures au répertoire de travail actuel lors de la sélection de la session la plus récente.
`--image, -i`	`path[,path...]`	Joignez une ou plusieurs images au prompt de suivi. Séparez plusieurs chemins par des virgules ou répétez l’option.
`--last`	`boolean`	Reprenez la conversation la plus récente du répertoire de travail actuel.
`PROMPT`	`string \| - (read stdin)`	Instruction de suivi facultative envoyée immédiatement après la reprise.
`SESSION_ID`	`uuid \| session name`	Reprenez la session indiquée. Omettez cette option et utilisez `--last` pour poursuivre la session la plus récente.

Utilisez codex exec fork <SESSION_ID> [PROMPT] pour copier une session enregistrée dans une nouvelle session. L’argument de session accepte un UUID ou un nom. Sans prompt, Codex crée la copie sans démarrer de tour. Transmettez - comme prompt pour le lire depuis stdin, ou ajoutez --image pour joindre des images.

Un prompt est requis lorsque vous utilisez des images, --output-schema, --output-last-message ou --ephemeral.

Ajoutez --worktree à une nouvelle exécution ou à une exécution issue d’une duplication pour créer un worktree Git géré :

codex exec --worktree "implement the next step"
codex exec fork <SESSION_ID> --worktree "try an alternative approach"

--worktree nécessite une exécution locale. Ne le combinez pas avec resume, review, --ephemeral ou --ignore-user-config.

`codex execpolicy`

Vérifiez les fichiers de règles execpolicy avant de les enregistrer. codex execpolicy check accepte une ou plusieurs options --rules (par exemple, des fichiers sous ~/.codex/rules) et produit un JSON indiquant la décision la plus stricte ainsi que les règles correspondantes. Ajoutez --pretty pour mettre en forme la sortie. La commande execpolicy est actuellement en préversion.

Clé	Type / Valeurs	Détails
`--pretty`	`boolean`	Présentez le résultat JSON dans un format lisible.
`--rules, -r`	`path (repeatable)`	Chemin vers un fichier de règles execpolicy à évaluer. Fournissez plusieurs options pour combiner les règles de plusieurs fichiers.
`COMMAND...`	`var-args`	Commande à vérifier par rapport aux politiques indiquées.

`codex login`

Authentifiez la CLI avec un compte ChatGPT, une API key ou un jeton d’accès. Sans option, Codex ouvre un navigateur pour le flux ChatGPT OAuth.

Clé	Type / Valeurs	Détails
`--device-auth`	`boolean`	Utilisez le flux de code d’appareil OAuth au lieu d’ouvrir une fenêtre de navigateur.
`--with-access-token`	`boolean`	Lisez un jeton d’accès depuis stdin (par exemple `printenv CODEX_ACCESS_TOKEN \| codex login --with-access-token`).
`--with-api-key`	`boolean`	Lisez une API key depuis stdin (par exemple `printenv OPENAI_API_KEY \| codex login --with-api-key`).
`status subcommand`	`codex login status`	Affichez le mode d’authentification actif et quittez avec le code 0 lorsqu’une session est ouverte.

codex login status renvoie 0 lorsque des identifiants sont présents, ce qui est utile dans les scripts d’automatisation.

`codex logout`

Supprimez les identifiants enregistrés pour l’API key et l’authentification ChatGPT. Cette commande ne comporte aucune option.

`codex mcp`

Gérez les entrées de serveurs Model Context Protocol stockées dans ~/.codex/config.toml.

Clé	Type / Valeurs	Détails
`add <name>`	`-- <command...> \| --url <value>`	Enregistrez un serveur à l’aide d’une commande de lancement stdio ou d’une URL HTTP avec flux. Prend en charge `--env KEY=VALUE` pour les transports stdio.
`get <name>`	`--json`	Affichez la configuration d’un serveur précis. `--json` affiche l’entrée de configuration brute.
`list`	`--json`	Répertoriez les MCP servers configurés. Ajoutez `--json` pour obtenir une sortie lisible par une machine.
`login <name>`	`--scopes scope1,scope2`	Démarrez une connexion OAuth pour un serveur HTTP avec flux (uniquement pour les serveurs prenant en charge OAuth).
`logout <name>`		Supprimez les identifiants OAuth enregistrés pour un serveur HTTP avec flux.
`remove <name>`		Supprimez une définition de MCP server enregistrée.

La sous-commande add prend en charge les transports stdio et HTTP avec flux :

Clé	Type / Valeurs	Détails
`--bearer-token-env-var`	`ENV_VAR`	Variable d’environnement dont la valeur est envoyée comme jeton bearer lors de la connexion à un serveur HTTP avec flux.
`--env KEY=VALUE`	`repeatable`	Affectations de variables d’environnement appliquées lors du lancement d’un serveur stdio.
`--oauth-client-id`	`CLIENT_ID`	Identifiant client OAuth pour un MCP server HTTP avec flux. Nécessite `--url`.
`--oauth-resource`	`RESOURCE`	Paramètre de ressource OAuth à inclure pendant la connexion à un MCP server HTTP avec flux. Nécessite `--url`.
`--url`	`https://…`	Enregistrez un serveur HTTP avec flux plutôt qu’un serveur stdio. Mutuellement exclusif avec `COMMAND...`.
`COMMAND...`	`stdio transport`	Exécutable et arguments permettant de lancer le MCP server. Indiquez-les après `--`.

Les actions OAuth (login, logout) fonctionnent uniquement avec les serveurs HTTP avec flux (et seulement si le serveur prend en charge OAuth).

`codex plugin`

Installez, répertoriez et supprimez des plugins depuis les marketplaces configurées.

Clé	Type / Valeurs	Détails
`add <plugin[@marketplace]>`	`[--marketplace, -m NAME] [--json]`	Installez un plugin depuis une marketplace configurée. Utilisez `--marketplace` ou `-m` lorsque l’argument du plugin omet `@marketplace`.
`list`	`[--marketplace, -m NAME] [--available --json] [--json]`	Répertoriez les plugins installés. Avec `--json`, la sortie comporte les tableaux `installed` et `available` ; `--available` inclut les plugins non installés de la marketplace et nécessite `--json`.
`marketplace`		Gérez les sources de marketplace configurées. Consultez `codex plugin marketplace` ci-dessous.
`remove <plugin[@marketplace]>`	`[--marketplace, -m NAME] [--json]`	Supprimez un plugin installé de la configuration et du cache locaux. Utilisez `--json` pour une sortie adaptée à l’automatisation.

codex plugin add --json affiche pluginId, name, marketplaceName, version, installedPath et authPolicy. codex plugin list --json affiche les tableaux installed et available. Les entrées comprennent pluginId, name, marketplaceName, version, installed, enabled, source, installPolicy, authPolicy et, lorsqu’il est disponible, marketplaceSource avec le type et la valeur de la source de marketplace configurée. codex plugin remove --json affiche pluginId, name et marketplaceName.

`codex plugin marketplace`

Gérez les sources de marketplaces de plugins que Codex peut parcourir et depuis lesquelles il peut effectuer des installations.

Clé	Type / Valeurs	Détails
`add <source>`	`[--ref REF] [--sparse PATH] [--json]`	Installez une marketplace de plugins à partir d’une notation abrégée GitHub, d’une URL Git, d’une URL SSH ou du répertoire racine d’une marketplace locale. `--sparse` est uniquement pris en charge pour les sources Git et peut être répété.
`list`	`[--json]`	Affichez les marketplaces de plugins actuellement prises en compte par Codex ainsi que le chemin racine de chacune.
`remove <marketplace-name>`	`[--json]`	Supprimez une marketplace de plugins configurée.
`upgrade [marketplace-name]`	`[--json]`	Actualisez une marketplace Git configurée ou toutes les marketplaces Git configurées si aucun nom n’est fourni.

codex plugin marketplace add accepte une notation abrégée GitHub telle que owner/repo ou owner/repo@ref, des URL Git HTTP ou HTTPS, des URL Git SSH et des répertoires racines de marketplaces locales. Utilisez --ref pour épingler une référence Git et répétez --sparse PATH pour utiliser un checkout partiel avec les dépôts de marketplaces adossés à Git.

codex plugin marketplace list affiche les noms et racines des marketplaces dans le périmètre, y compris les marketplaces par défaut découvertes implicitement et les instantanés de marketplaces configurés.

Ajoutez --json aux commandes d’ajout, de liste, de mise à niveau ou de suppression de marketplaces pour obtenir une sortie adaptée à l’automatisation. Le JSON d’ajout d’une marketplace comprend marketplaceName, installedRoot et alreadyAdded ; le JSON de liste comprend un tableau marketplaces avec name, root et éventuellement marketplaceSource ; le JSON de mise à niveau comprend selectedMarketplaces, upgradedRoots et errors ; le JSON de suppression comprend marketplaceName et installedRoot.

`codex mcp-server`

`codex resume`

Poursuivez une session interactive à partir de son identifiant ou reprenez la conversation la plus récente. codex resume limite la portée de --last au répertoire de travail actuel, sauf si vous passez --all. Cette commande accepte les options de remplacement du modèle et du bac à sable, mais pas --worktree.

Si le répertoire de travail actuel diffère du répertoire enregistré de la session, Codex vous demande quel répertoire utiliser. Définissez tui.resume_cwd sur "current" ou "session" pour réutiliser ce choix sans demander de confirmation. Un remplacement explicite --cd (-C) prévaut sur tui.resume_cwd.

Clé	Type / Valeurs	Détails
`--all`	`boolean`	Incluez les sessions extérieures au répertoire de travail actuel lors de la sélection de la session la plus récente.
`--include-non-interactive`	`boolean`	Incluez les sessions non interactives dans le sélecteur et dans la sélection `--last`.
`--last`	`boolean`	Ignorez le sélecteur et reprenez la conversation la plus récente du répertoire de travail actuel.
`SESSION_ID`	`uuid \| session name`	Reprenez la session indiquée. Omettez cette option et utilisez `--last` pour poursuivre la session la plus récente.

`codex fork`

Créez une nouvelle conversation à partir d’une session interactive précédente. Par défaut, codex fork ouvre le sélecteur de sessions ; ajoutez --last pour créer plutôt une branche depuis votre session la plus récente.

Lorsque les répertoires de la session actuelle et de la session enregistrée diffèrent, codex fork utilise la même demande de répertoire de travail et le même paramètre tui.resume_cwd que codex resume.

Clé	Type / Valeurs	Détails
`--all`	`boolean`	Affichez dans le sélecteur les sessions extérieures au répertoire de travail actuel.
`--last`	`boolean`	Ignorez le sélecteur et créez automatiquement une branche depuis la conversation la plus récente.
`SESSION_ID`	`uuid`	Créez une branche depuis la session indiquée. Omettez cette option et utilisez `--last` pour créer une branche depuis la session la plus récente.

Pour créer une branche de la conversation dans un worktree Git géré, exécutez codex fork <SESSION_ID> --worktree. Cette opération nécessite un identifiant de session explicite et une exécution locale ; elle ne prend pas en charge --last ni le sélecteur de session.

`codex sandbox`

Utilisez l’utilitaire de bac à sable pour exécuter une commande avec les mêmes politiques que celles utilisées en interne par Codex.

macOS seatbelt

Clé	Type / Valeurs	Détails
`--allow-unix-socket`	`path`	Autorisez la commande exécutée dans le bac à sable à lier des sockets Unix situés sous ce chemin ou à s’y connecter. Répétez l’option pour autoriser plusieurs chemins.
`--cd, -C`	`DIR`	Répertoire de travail utilisé pour la résolution du profil et l’exécution de la commande. Nécessite `--permission-profile`.
`--config, -c`	`key=value`	Transmettez des remplacements de configuration à l’exécution dans le bac à sable (répétable).
`--include-managed-config`	`boolean`	Incluez les exigences gérées lors de la résolution d’un profil d’autorisations explicite. Nécessite `--permission-profile`.
`--log-denials`	`boolean`	Capturez avec `log stream` les refus du bac à sable macOS pendant l’exécution de la commande et affichez-les après sa fin.
`--permission-profile, -P`	`NAME`	Appliquez un profil d’autorisations nommé provenant de la pile de configuration active.
`--profile, -p`	`NAME`	Superposez `$CODEX_HOME/NAME.config.toml` à la configuration utilisateur de base.
`COMMAND...`	`var-args`	Commande shell à exécuter sous macOS Seatbelt. Tout ce qui suit `--` est transmis.

Bac à sable Linux

Clé	Type / Valeurs	Détails
`--cd, -C`	`DIR`	Répertoire de travail utilisé pour la résolution du profil et l’exécution de la commande. Nécessite `--permission-profile`.
`--config, -c`	`key=value`	Remplacements de configuration appliqués avant le lancement du bac à sable (répétables).
`--include-managed-config`	`boolean`	Incluez les exigences gérées lors de la résolution d’un profil d’autorisations explicite. Nécessite `--permission-profile`.
`--permission-profile, -P`	`NAME`	Appliquez un profil d’autorisations nommé provenant de la pile de configuration active.
`--profile, -p`	`NAME`	Superposez `$CODEX_HOME/NAME.config.toml` à la configuration utilisateur de base.
`COMMAND...`	`var-args`	Commande à exécuter sous Landlock + seccomp. Indiquez l’exécutable après `--`.

Windows

Clé	Type / Valeurs	Détails
`--cd, -C`	`DIR`	Répertoire de travail utilisé pour la résolution du profil et l’exécution de la commande. Nécessite `--permission-profile`.
`--config, -c`	`key=value`	Remplacements de configuration appliqués avant le lancement du bac à sable (répétables).
`--include-managed-config`	`boolean`	Incluez les exigences gérées lors de la résolution d’un profil d’autorisations explicite. Nécessite `--permission-profile`.
`--permission-profile, -P`	`NAME`	Appliquez un profil d’autorisations nommé provenant de la pile de configuration active.
`--profile, -p`	`NAME`	Superposez `$CODEX_HOME/NAME.config.toml` à la configuration utilisateur de base.
`COMMAND...`	`var-args`	Commande à exécuter dans le bac à sable Windows natif. Indiquez l’exécutable après `--`.

`codex update`

Recherchez et appliquez une mise à jour de Codex CLI lorsque la version installée prend en charge l’auto-mise à jour. Les builds de débogage affichent un message vous invitant à installer plutôt un build de version.

Combinaisons d’options et conseils de sécurité

Utilisez --sandbox workspace-write pour les tâches locales sans surveillance qui peuvent rester dans l’espace de travail, et évitez --dangerously-bypass-approvals-and-sandbox sauf si vous vous trouvez dans une VM dédiée faisant office de bac à sable.
Lorsque vous devez accorder à Codex un accès en écriture à d’autres répertoires, préférez --add-dir plutôt que de forcer --sandbox danger-full-access.
Associez --json à --output-last-message dans la CI pour capturer une progression lisible par une machine et un résumé final en langage naturel.

Raccourcis interactifs

Saisissez @ pour rechercher un fichier dans l’espace de travail et ajouter son chemin au prompt.
Appuyez sur Haut ou Bas pour rappeler les brouillons de l’historique.
Appuyez sur Ctrl+R pour rechercher dans l’historique des prompts, puis appuyez sur Entrée pour utiliser un résultat ou sur Échap pour annuler.
Appuyez sur Ctrl+O ou exécutez /copy pour copier la dernière réponse terminée de Codex.
Commencez une ligne par ! pour exécuter une commande shell locale avec les paramètres actuels d’approbation et de sandbox.
Appuyez sur Tab pendant que Codex travaille pour mettre en file d’attente un prompt de suivi, une commande slash ou une commande shell pour le prochain tour.
Appuyez sur Entrée pendant que Codex travaille pour ajouter de nouvelles instructions au tour en cours.
Appuyez deux fois sur Échap lorsque le champ de saisie est vide pour modifier le message utilisateur précédent et créer une branche de la conversation à partir de ce point.
Appuyez sur Ctrl+C ou exécutez /exit pour fermer la session.

Ressources connexes

Présentation de Codex CLI : installation, mises à niveau et conseils rapides.
Principes de base de la configuration : enregistrez des valeurs par défaut telles que le modèle et le fournisseur.
Configuration avancée : profils, fournisseurs, réglage du bac à sable et intégrations.
AGENTS.md : présentation conceptuelle des capacités des agents Codex et des bonnes pratiques.

Les commandes slash vous permettent de contrôler Codex rapidement et entièrement au clavier. Saisissez / dans la zone de saisie pour ouvrir le menu des commandes slash, choisissez une commande et Codex effectuera des actions telles que changer de modèle, ajuster les autorisations ou résumer de longues conversations sans quitter le terminal.

Ce guide vous montre comment :

Trouver la commande slash intégrée adaptée à une tâche
Piloter une session active avec des commandes comme /model, /fast, /permissions, /approve, /raw, /agents, /subagents et /status

Commandes slash intégrées

Codex est fourni avec les commandes suivantes. Ouvrez le menu des commandes slash et commencez à saisir le nom de la commande pour filtrer la liste.

Lorsqu’une conversation est déjà en cours, vous pouvez saisir une commande slash et appuyer sur Tab pour la mettre en file d’attente pour le tour suivant. Codex analyse les commandes slash en attente au moment de leur exécution ; les menus de commandes et les erreurs apparaissent donc une fois le tour en cours terminé. La complétion des commandes slash reste disponible avant leur mise en file d’attente.

Commande	Objectif	Quand l’utiliser
`/permissions`	Définir ce que Codex peut faire sans demander votre accord.	Assouplir ou renforcer les exigences d’approbation en cours de session, par exemple en passant d’Auto à Read Only.
`/ide`	Inclure les fichiers ouverts, la sélection actuelle et d’autres éléments de contexte de l’IDE.	Intégrer le contexte de l’éditeur à la prochaine invite sans réexpliquer ce qui est ouvert dans votre IDE.
`/keymap`	Réaffecter les raccourcis clavier de la TUI.	Consulter et enregistrer les raccourcis personnalisés dans `config.toml`.
`/vim`	Activer ou désactiver le mode Vim dans la zone de saisie.	Passer des modes normal et insertion de Vim au mode d’édition par défaut de la zone de saisie.
`/setup-default-sandbox`	Configurer le bac à sable de l’agent avec élévation de privilèges (Windows uniquement).	Remplacer le bac à sable Windows dégradé lorsque Codex propose la configuration avec élévation de privilèges.
`/agents`	Ouvrir le centre de commande des agents.	Parcourir les conversations et passer d’un agent à l’autre sur le serveur connecté.
`/subagents`	Changer le fil de sous-agent actif.	Examiner ou poursuivre le travail d’un sous-agent depuis la session actuelle.
`/apps`	Parcourir les applications (connecteurs) et les insérer dans votre invite.	Joindre une application sous la forme `$app-slug` avant de demander à Codex de l’utiliser.
`/plugins`	Parcourir les plugins installés et ceux disponibles à la découverte.	Consulter les outils des plugins, installer les plugins suggérés ou gérer leur disponibilité.
`/hooks`	Consulter et gérer les hooks de cycle de vie.	Examiner les hooks configurés, approuver les hooks nouveaux ou modifiés, ou désactiver les hooks non gérés avant leur exécution.
`/clear`	Effacer le terminal et démarrer une nouvelle conversation.	Réinitialiser à la fois l’interface visible et le contexte de la conversation pour repartir de zéro.
`/rename`	Renommer la conversation actuelle.	Donner un nom facilement reconnaissable à une session enregistrée sans quitter la TUI.
`/archive`	Archiver la session actuelle.	Retirer la session actuelle des listes de sessions actives sans supprimer sa transcription.
`/delete`	Supprimer définitivement la session actuelle.	Supprimer la transcription et les sessions descendantes lorsque l’archivage ne suffit pas.
`/compact`	Résumer la conversation visible pour libérer des tokens.	À utiliser après de longues exécutions pour que Codex conserve les points essentiels sans dépasser la fenêtre de contexte.
`/copy`	Copier la dernière sortie terminée de Codex.	Récupérer le texte de la dernière réponse ou du dernier plan terminé sans le sélectionner manuellement. Vous pouvez aussi appuyer sur `Ctrl+O`.
`/diff`	Afficher le diff Git, y compris les fichiers que Git ne suit pas encore.	Examiner les modifications de Codex avant de les committer ou de lancer des tests.
`/exit`	Quitter la CLI (comme `/quit`).	Autre nom de commande ; les deux commandes quittent la session.
`/experimental`	Activer ou désactiver les fonctionnalités expérimentales.	Activer des options telles que le proxy réseau ou l’empêchement de la mise en veille pendant l’exécution.
`/approve`	Autoriser une nouvelle tentative après un refus récent de la vérification automatique.	Réessayer une commande ou une action refusée par le système de vérification automatique.
`/memories`	Configurer l’utilisation et la génération des souvenirs.	Activer ou désactiver l’injection ou la génération de souvenirs sans quitter la TUI.
`/skills`	Parcourir et utiliser les skills.	Améliorer le comportement pour une tâche donnée en sélectionnant un skill local pertinent.
`/import`	Importer la configuration, les projets et les conversations de Claude Code ou de Cursor.	Migrer les éléments pris en charge d’agents externes vers la configuration de Codex et les fichiers locaux.
`/feedback`	Envoyer des journaux aux responsables de la maintenance de Codex.	Signaler des problèmes ou transmettre des diagnostics à l’assistance.
`/init`	Générer une structure de base pour `AGENTS.md` dans le répertoire actuel.	Consigner des instructions persistantes pour le dépôt ou le sous-répertoire dans lequel vous travaillez.
`/logout`	Se déconnecter de Codex.	Effacer les identifiants locaux lorsque vous utilisez un ordinateur partagé.
`/mcp`	Lister les outils Model Context Protocol (MCP) configurés.	Vérifier quels outils externes Codex peut appeler pendant la session ; ajouter `verbose` pour obtenir les détails des serveurs.
`/mention`	Joindre un fichier à la conversation.	Indiquer à Codex les fichiers ou dossiers précis que vous souhaitez lui faire examiner ensuite.
`/model`	Choisir le modèle actif (et l’effort de raisonnement, lorsqu’il est disponible).	Utiliser `gpt-6-luna` ou `gpt-6.1-sol` si ces options sont affichées.
`/fast`	Activer ou désactiver le niveau de service Fast lorsque le catalogue de modèles le propose.	Activer ou désactiver le niveau Fast du modèle actuel et enregistrer la sélection.
`/plan`	Passer en mode plan et, si vous le souhaitez, envoyer une invite.	Demander à Codex de proposer un plan d’exécution avant le début de la mise en œuvre.
`/goal`	Définir, modifier, suspendre, reprendre, consulter ou supprimer un objectif de tâche.	Donner à Codex un objectif persistant à suivre pendant l’exécution d’une tâche plus vaste.
`/ps`	Afficher les terminaux en arrière-plan et leurs sorties récentes.	Vérifier les commandes de longue durée sans quitter la transcription principale.
`/stop`	Arrêter tous les terminaux en arrière-plan.	Annuler le travail lancé dans les terminaux en arrière-plan par la session actuelle.
`/fork`	Créer une nouvelle conversation à partir de la conversation actuelle.	Créer une branche de la session active pour explorer une nouvelle approche sans perdre la transcription actuelle.
`/app`	Poursuivre la session actuelle dans l’application de bureau ChatGPT.	Passer de la TUI à l’application de bureau sur macOS ou Windows.
`/side`, `/btw`	Démarrer une conversation annexe éphémère.	Poser une question complémentaire ciblée sans perturber la transcription de la conversation principale.
`/raw`	Activer ou désactiver le mode d’historique brut du terminal.	Réduire la mise en forme lors de la sélection et de la copie dans le terminal pour consulter de longues sorties.
`/resume`	Reprendre une conversation enregistrée depuis votre liste de sessions.	Poursuivre le travail d’une session CLI précédente sans repartir de zéro.
`/new`	Démarrer une nouvelle conversation dans la même session CLI.	Réinitialiser le contexte de la conversation sans quitter la CLI pour saisir une nouvelle invite dans le même dépôt.
`/quit`	Quitter la CLI.	Quitter immédiatement la session.
`/review`	Demander à Codex d’examiner votre worktree.	À exécuter lorsque Codex a terminé son travail ou lorsque vous souhaitez un second regard sur les modifications locales.
`/status`	Afficher la configuration de la session et l’utilisation des tokens.	Confirmer le modèle actif, la politique d’approbation, les racines accessibles en écriture et la capacité de contexte restante.
`/usage`	Consulter l’utilisation des tokens du compte ou utiliser une réinitialisation des limites de débit.	Consulter l’activité quotidienne, hebdomadaire ou cumulée des tokens ChatGPT depuis la TUI.
`/debug-config`	Afficher les diagnostics des couches de configuration et des exigences.	Diagnostiquer les règles de priorité et les exigences de politique, y compris les contraintes réseau expérimentales.
`/statusline`	Configurer les champs de la ligne d’état de la TUI de manière interactive.	Choisir et réorganiser les éléments du pied de page (modèle/contexte/limites/git/tokens/session), puis les enregistrer dans config.toml.
`/title`	Configurer les champs du titre de la fenêtre ou de l’onglet du terminal de manière interactive.	Choisir et réorganiser les éléments du titre, comme le projet, l’état, le fil, la branche, le modèle et la progression de la tâche.
`/theme`	Choisir un thème de coloration syntaxique.	Prévisualiser et enregistrer un thème de coloration syntaxique pour le terminal.
`/pets`, `/pet`	Choisir ou masquer une mascotte de terminal.	Personnaliser la TUI avec une mascotte d’ambiance intégrée ou personnalisée.
`/tui`	Choisir le mode du terminal pour le prochain lancement.	Basculer entre l’historique de défilement du terminal et une transcription en plein écran.
`/export`	Exporter la conversation au format Markdown.	Enregistrer une transcription complète dans un fichier ou la copier dans le presse-papiers.
`/recap`	Générer un résumé de la conversation actuelle.	Prendre connaissance de la conversation sans compacter son contexte.
`/cd`	Changer le répertoire de travail de la session.	Poursuivre une conversation principale inactive dans un autre répertoire.
`/pwd`, `/cwd`	Afficher le répertoire de travail.	Vérifier le répertoire utilisé par la session active.
`/worktree`	Démarrer ou poursuivre une conversation dans un worktree Git géré.	Travailler dans une copie de travail distincte d’un dépôt local.
`/daemon`	Ouvrir les commandes du serveur en arrière-plan.	Examiner la connexion et gérer un serveur local appartenant à Codex.
`/warnings`	Afficher les avertissements et diagnostics conservés.	Consulter à nouveau les avertissements apparus pendant la session.

/quit et /exit quittent tous deux la CLI. Ne les utilisez qu’après avoir enregistré ou commité tout travail important.

Utilisez /permissions pour ajuster ce que Codex peut faire sans demander d’abord. Utilisez /approve uniquement lorsque vous devez réessayer une action récente que l’examen automatique a refusée.

Contrôler votre session avec les commandes slash

Les workflows suivants vous permettent de garder votre session sur la bonne voie sans redémarrer Codex.

Choisir le mode du terminal avec `/tui`

Saisissez /tui.
Choisissez le mode avec historique de défilement ou le mode plein écran, puis confirmez.
Redémarrez Codex pour appliquer votre choix.

Résultat attendu : le prochain lancement utilise le mode de terminal enregistré. Les options de remplacement au lancement telles que --no-alt-screen continuent de s’appliquer.

Exporter une conversation avec `/export`

Saisissez /export.
Choisissez Copier dans le presse-papiers ou Enregistrer dans un fichier.

Résultat attendu : Codex exporte l’intégralité de la conversation au format Markdown. Pour l’enregistrer directement dans un fichier, exécutez /export session.md. Attendez la fin du tour actuel avant de l’exporter.

Résumer la conversation avec `/recap`

Lorsque Codex est inactif, saisissez /recap.

Résultat attendu : Codex génère un résumé de la conversation, même si tui.auto_recap = false. Utilisez /compact lorsque vous souhaitez libérer de l’espace dans le contexte.

Changer de répertoire avec `/cd`

Saisissez /pwd (ou /cwd) pour vérifier le répertoire actuel.
Saisissez /cd <path> pour changer de répertoire, ou /cd pour utiliser votre répertoire personnel.

Résultat attendu : Codex poursuit la conversation dans le répertoire sélectionné. Le changement de répertoire nécessite une session principale inactive, sans saisie en attente ni terminaux en arrière-plan.

Poursuivre dans un worktree avec `/worktree`

Saisissez /worktree dans un dépôt Git local.
Choisissez de démarrer une nouvelle conversation ou de poursuivre la conversation actuelle dans un nouveau worktree.

Résultat attendu : Codex crée un worktree Git géré et y démarre la conversation sélectionnée. Choisissez Parcourir les worktrees pour trouver les worktrees existants et les conversations auxquelles ils appartiennent. Cette commande nécessite la prise en charge locale des worktrees et n’est pas disponible lorsqu’une tâche est en cours d’exécution.

Gérer le serveur en arrière-plan avec `/daemon`

Saisissez /daemon.
Examinez la connexion au serveur et les actions disponibles.

Résultat attendu : Codex propose d’installer la dernière version stable publique ou d’utiliser la version actuelle de la CLI pour le serveur local en arrière-plan. Confirmer une mise à jour ferme Codex et peut interrompre le travail en cours. Pour une connexion distante, gérez le serveur sur sa machine hôte.

Examiner les avertissements avec `/warnings`

Saisissez /warnings.

Résultat attendu : Codex affiche les avertissements conservés et leurs détails de diagnostic.

Définir le modèle actif avec `/model`

Le sélecteur affiche uniquement les modèles disponibles pour votre compte et votre espace de travail. Si GPT-6.1 Sol n’apparaît pas dans la liste, choisissez un autre modèle. Consultez la disponibilité de GPT-6.1 Sol par forfait.

Lancez Codex et ouvrez la zone de saisie.
Saisissez /model et appuyez sur Entrée.
Choisissez un modèle tel que gpt-6-luna ou gpt-6.1-sol dans la fenêtre contextuelle.

Résultat attendu : Codex confirme le nouveau modèle dans la transcription. Exécutez /status pour vérifier le changement.

Activer ou désactiver le mode Fast avec `/fast`

Saisissez /fast pour activer le niveau de service Fast du modèle actuel.
Saisissez de nouveau /fast pour le désactiver.

Résultat attendu : Codex change de niveau et enregistre la sélection. Dans le pied de page de la TUI, vous pouvez également afficher un élément de ligne d’état pour le mode Fast avec /statusline.

Les commandes du niveau Fast dépendent du catalogue. Si le modèle actuel n’annonce pas de niveau Fast, Codex n’affiche pas /fast.

Passer en mode plan avec `/plan`

Saisissez /plan et appuyez sur Entrée pour faire passer le chat actif en mode plan.
Facultatif : fournissez le texte d’une invite en ligne (par exemple, /plan Propose a migration plan for this service).
Vous pouvez coller du contenu ou joindre des images lorsque vous utilisez des arguments /plan en ligne.

Résultat attendu : Codex passe en mode plan et utilise votre éventuelle invite en ligne comme première demande de planification.

Lorsque Codex travaille déjà, /plan est temporairement indisponible.

Définir ou consulter un objectif de tâche avec `/goal`

Saisissez /goal <objective> pour définir l’objectif, par exemple /goal Finish the migration and keep tests green.
Saisissez /goal pour afficher l’objectif actuel.
Utilisez /goal edit pour réviser l’objectif. Utilisez /goal pause, /goal resume ou /goal clear pour le suspendre, le reprendre ou le supprimer.

Résultat attendu : Codex garde l’objectif associé au chat actif pendant la poursuite du travail.

Les objectifs doivent être non vides et comporter au maximum 4 000 caractères. Pour des instructions plus longues, placez les détails dans un fichier et faites pointer l’objectif vers ce fichier.

Activer ou désactiver les fonctionnalités expérimentales avec `/experimental`

Saisissez /experimental et appuyez sur Entrée.
Activez ou désactivez les fonctionnalités souhaitées (par exemple, Network proxy ou Prevent sleep while running), puis redémarrez Codex si l’invite vous le demande.

Résultat attendu : Codex enregistre vos choix de fonctionnalités dans la configuration et les applique au redémarrage.

Autoriser une action refusée par la vérification automatique avec `/approve`

Utilisez /approve lorsque l’outil d’examen automatique a refusé une action récente et que vous souhaitez que Codex la réessaie une fois.

Saisissez /approve.
Confirmez la nouvelle tentative lorsque Codex affiche l’action refusée concernée.

Résultat attendu : Codex réessaie une fois cette action refusée conformément à la politique de la session actuelle.

Configurer les souvenirs avec `/memories`

Saisissez /memories.
Choisissez si Codex doit utiliser les mémoires existantes, en générer de nouvelles ou laisser les fonctionnalités de mémoire désactivées.

Résultat attendu : Codex met à jour les paramètres de mémoire concernés pour les sessions futures.

Utiliser les skills avec `/skills`

Saisissez /skills.
Choisissez le skill que Codex doit appliquer.

Résultat attendu : Codex insère le contexte du skill sélectionné afin que la prochaine requête respecte ses instructions.

Importer la configuration de Claude Code ou de Cursor avec `/import`

Saisissez /import.
Choisissez Claude Code ou Cursor.
Sélectionnez la configuration, les fichiers de projet ou les chats récents à migrer.

Résultat attendu : Codex ouvre le sélecteur d’importation d’agent externe et importe les artefacts pris en charge sélectionnés dans la configuration de Codex et les fichiers locaux. La détection des sessions inclut jusqu’à 50 chats des 30 derniers jours.

Exécutez /import depuis une session TUI locale. Cette commande est indisponible pendant l’exécution d’une tâche, dans les sessions distantes et lorsque vous êtes connecté au démon app-server local.

Pour connaître le workflow de l’app de bureau et les types d’artefacts pris en charge, consultez Importer depuis un autre agent.

Effacer le terminal et démarrer une nouvelle conversation avec `/clear`

Saisissez /clear et appuyez sur Entrée.

Résultat attendu : Codex efface le terminal, réinitialise la transcription visible et démarre un nouveau chat dans la même session CLI.

Pour nommer le nouveau chat dès sa création, exécutez /clear release prep.

Contrairement à Ctrl+L, /clear démarre un nouveau chat.

Ctrl+L efface uniquement l’affichage du terminal et conserve le chat actuel. Codex désactive ces deux actions lorsqu’une tâche est en cours.

Archiver la session actuelle avec `/archive`

Saisissez /archive et appuyez sur Entrée.
Confirmez que vous souhaitez archiver la session actuelle.

Résultat attendu : Codex archive la session et revient au centre de commande lorsqu’il est connecté à un serveur local en arrière-plan ou à un serveur distant. Sans serveur partagé, Codex se ferme. Codex conserve la transcription ; restaurez-la ultérieurement avec codex unarchive <SESSION>.

Si un tour est en cours, la confirmation de /archive l’arrête avant l’archivage.

Supprimer la session actuelle avec `/delete`

Saisissez /delete et appuyez sur Entrée.
Confirmez que vous souhaitez supprimer la session actuelle.

Résultat attendu : Codex supprime définitivement la transcription et les sessions créées qui en descendent. Lorsqu’il est connecté à un serveur local en arrière-plan ou distant, Codex revient au centre de commande. Sans serveur partagé, Codex se ferme.

/delete est indisponible pendant l’exécution d’un chat ou dans un chat latéral.

Mettre à jour les autorisations avec `/permissions`

Saisissez /permissions et appuyez sur Entrée.
Sélectionnez le préréglage d’approbation correspondant à votre niveau de confort, par exemple Auto pour les exécutions autonomes ou Read Only pour examiner les modifications. Lorsque des profils d’autorisation nommés sont actifs, le sélecteur affiche également les profils personnalisés configurés et leur description.

Résultat attendu : Codex annonce la mise à jour de la politique. Les actions futures respectent le mode d’approbation mis à jour jusqu’à ce que vous le changiez de nouveau.

Inclure le contexte de l’IDE avec `/ide`

Saisissez /ide.
Ajoutez éventuellement du texte en ligne pour expliquer ce que Codex doit faire de la sélection actuelle ou des fichiers ouverts dans l’IDE.

Résultat attendu : Codex inclut le contexte disponible de l’IDE dans la prochaine invite.

Activer ou désactiver le mode Vim avec `/vim`

Saisissez /vim.
Continuez la modification dans la zone de saisie.

Résultat attendu : Codex active ou désactive le mode Vim de la zone de saisie pour la session actuelle. Pour faire du mode Vim le mode par défaut des nouvelles sessions, définissez tui.vim_mode_default = true dans config.toml.

Configurer le bac à sable Windows avec élévation de privilèges avec `/setup-default-sandbox`

Cette commande n’apparaît que sous Windows lorsque Codex utilise le bac à sable dégradé à jeton restreint.

Saisissez /setup-default-sandbox.
Suivez le processus de configuration administrateur.

Résultat attendu : Codex configure le bac à sable Windows avec privilèges élevés et sélectionne le préréglage d’approbation automatique correspondant.

Copier la dernière réponse avec `/copy`

Saisissez /copy et appuyez sur Entrée.

Résultat attendu : Codex copie la dernière sortie terminée de Codex dans votre presse-papiers.

Si un tour est encore en cours, /copy utilise la dernière sortie terminée plutôt que la réponse en cours. La commande est indisponible avant la première sortie terminée de Codex et juste après un retour en arrière.

Vous pouvez également appuyer sur Ctrl+O depuis la TUI principale pour copier la dernière réponse terminée sans ouvrir le menu des commandes slash.

Activer ou désactiver l’historique brut du terminal avec `/raw`

Saisissez /raw, /raw on ou /raw off.

Résultat attendu : Codex active ou désactive le mode de défilement brut, qui rend la sélection et la copie dans le terminal plus directes. Vous pouvez également utiliser le raccourci par défaut Alt+R ou conserver ce réglage par défaut avec tui.raw_output_mode = true.

Examiner la session avec `/status`

Dans n’importe quel chat, saisissez /status.
Examinez les informations relatives au modèle actif, à la politique d’approbation, aux racines accessibles en écriture et à l’utilisation actuelle des tokens. Lorsque la TUI se connecte à distance, la sortie affiche également l’adresse distante et la version du serveur.

Résultat attendu : Codex affiche un récapitulatif confirmant qu’il fonctionne à l’endroit prévu.

Consulter l’utilisation du compte avec `/usage`

Saisissez /usage pour ouvrir le menu d’utilisation.
Choisissez d’afficher l’activité des tokens ou d’utiliser une réinitialisation acquise disponible.
Pour ouvrir directement l’activité des tokens, saisissez /usage daily, /usage weekly ou /usage cumulative.

Résultat attendu : Codex ouvre les actions relatives à l’utilisation ou affiche l’activité des tokens du compte pour la vue sélectionnée. Si la session ne dispose pas d’une authentification de compte de service Codex, Codex affiche une demande de connexion.

Examiner les couches de configuration avec `/debug-config`

Saisissez /debug-config.
Examinez l’ordre des couches de configuration (de la priorité la plus faible à la plus élevée), leur état activé/désactivé et les sources des politiques.

Résultat attendu : Codex affiche les diagnostics des couches ainsi que des détails sur les politiques tels que allowed_approval_policies, allowed_sandbox_modes, mcp_servers, rules et experimental_network lorsqu’ils sont configurés.

Utilisez cette sortie pour déterminer pourquoi un paramètre effectif diffère de config.toml.

Configurer les éléments du pied de page avec `/statusline`

Saisissez /statusline.
Utilisez le sélecteur pour activer, désactiver et réorganiser les éléments, puis confirmez.

Résultat attendu : La ligne d’état du pied de page est immédiatement mise à jour et enregistrée dans tui.status_line au sein de config.toml.

Les éléments disponibles pour la ligne d’état comprennent le modèle, le modèle et le raisonnement, les statistiques de contexte, les limites de débit, la branche git, les compteurs de tokens, l’identifiant de session, le répertoire actuel ou la racine du projet, et la version de Codex.

Configurer les éléments du titre du terminal avec `/title`

Saisissez /title.
Utilisez le sélecteur pour activer, désactiver et réorganiser les éléments, puis confirmez.

Résultat attendu : Le titre de la fenêtre ou de l’onglet du terminal est immédiatement mis à jour et enregistré dans tui.terminal_title au sein de config.toml.

Les éléments disponibles pour le titre comprennent le nom de l’app, le projet, l’indicateur de chargement, l’état, le fil, la branche git, le modèle et la progression de la tâche.

Choisir un thème de coloration syntaxique avec `/theme`

Saisissez /theme.
Prévisualisez un thème depuis le sélecteur, puis confirmez.

Résultat attendu : Codex met à jour la coloration syntaxique et enregistre ce choix dans tui.theme au sein de config.toml.

Choisir une mascotte de terminal avec `/pets`

Saisissez /pets (ou /pet) pour ouvrir le sélecteur d’animaux.
Choisissez un animal intégré ou personnalisé, ou désactivez les animaux.

Résultat attendu : Codex affiche l’animal d’ambiance sélectionné dans les terminaux pris en charge et enregistre la sélection. Vous pouvez également saisir /pets off pour le masquer.

Réaffecter les raccourcis de la TUI avec `/keymap`

Utilisez /keymap pour examiner, mettre à jour et conserver les associations de raccourcis clavier de la TUI.

Saisissez /keymap.
Choisissez le contexte et l’action du raccourci à modifier.
Saisissez la nouvelle association ou supprimez l’association existante.

Résultat attendu : Codex met à jour le mappage de touches actif et écrit l’association personnalisée dans tui.keymap au sein de config.toml.

Les associations de touches utilisent des noms tels que ctrl-a, shift-enter et page-down. Les associations propres à un contexte remplacent tui.keymap.global ; une liste d’associations vide dissocie l’action.

Vérifier les terminaux en arrière-plan avec `/ps`

Saisissez /ps.
Examinez la liste des terminaux en arrière-plan et leur état.

Résultat attendu : Codex affiche la commande de chaque terminal en arrière-plan ainsi que jusqu’à trois lignes de sortie récentes et non vides, afin que vous puissiez évaluer la progression en un coup d’œil.

Les terminaux en arrière-plan apparaissent lorsque unified_exec est utilisé ; sinon, la liste peut être vide.

Arrêter les terminaux en arrière-plan avec `/stop`

Saisissez /stop.
Confirmez si Codex vous le demande avant d’arrêter les terminaux répertoriés.

Résultat attendu : Codex arrête tous les terminaux en arrière-plan de la session actuelle. /clean reste disponible comme alias de /stop.

Alléger les transcriptions avec `/compact`

Après un long échange, saisissez /compact.
Confirmez lorsque Codex propose de résumer le chat jusqu’à présent.

Résultat attendu : Codex remplace les tours précédents par un résumé concis, libérant du contexte tout en conservant les détails essentiels.

Examinez les modifications avec `/diff`

Saisissez /diff pour examiner le diff Git.
Faites défiler la sortie dans la CLI pour examiner les modifications et les fichiers ajoutés.

Résultat attendu : Codex affiche les modifications indexées, celles qui ne le sont pas encore et les fichiers que Git ne suit pas encore, afin que vous puissiez décider lesquels conserver.

Signalez des fichiers avec `/mention`

Saisissez /mention suivi d’un chemin, par exemple /mention src/lib/api.ts.
Sélectionnez le résultat correspondant dans la fenêtre contextuelle.

Résultat attendu : Codex ajoute le fichier au chat afin que les tours suivants y fassent directement référence.

Démarrez une nouvelle conversation avec `/new`

Saisissez /new et appuyez sur Entrée.
Si Codex vous propose de choisir une copie de travail, choisissez le répertoire actuel ou un nouveau worktree.

Résultat attendu : Codex démarre un nouveau chat dans la même session CLI, ce qui vous permet de changer de chat sans quitter votre terminal.

Pour nommer le nouveau chat dès sa création, exécutez /new bug bash.

Contrairement à /clear, /new n’efface pas d’abord l’affichage actuel du terminal.

Renommez la conversation en cours avec `/rename`

Saisissez /rename <name>, ou saisissez /rename pour ouvrir l’invite de nommage.
Saisissez un nom court qui vous aidera à retrouver le chat ultérieurement.

Résultat attendu : Codex met à jour le nom enregistré du chat sans modifier sa transcription.

Reprenez une conversation enregistrée avec `/resume`

Saisissez /resume et appuyez sur Entrée.
Choisissez la session souhaitée dans le sélecteur des sessions enregistrées.

Résultat attendu : Codex recharge la transcription du chat sélectionné afin que vous puissiez reprendre là où vous vous étiez arrêté, tout en conservant l’historique d’origine intact.

Créez une bifurcation de la conversation en cours avec `/fork`

Saisissez /fork et appuyez sur Entrée.
Si Codex vous propose de choisir une copie de travail, choisissez le répertoire actuel ou un nouveau worktree.

Résultat attendu : Codex clone le chat actuel dans un nouveau chat doté d’un nouvel ID, sans modifier la transcription d’origine, afin que vous puissiez explorer une autre approche en parallèle.

Si vous devez dupliquer une session enregistrée plutôt que la session actuelle, exécutez codex fork dans votre terminal pour ouvrir le sélecteur de sessions.

Continuez dans l’application de bureau avec `/app`

Sous macOS et Windows, saisissez /app pour ouvrir la session actuelle dans l’app de bureau ChatGPT. Si l’app n’est pas installée ou en cours d’exécution, Codex affiche une erreur vous demandant de l’installer ou de la lancer.

Résultat attendu : L’app de bureau ouvre le même chat enregistré pour que vous puissiez y poursuivre le travail.

Démarrez une conversation parallèle avec `/side`

Utilisez /side pour créer une branche éphémère à partir du chat actuel sans quitter le chat principal.

Saisissez /side pour ouvrir un chat latéral.
Ajoutez éventuellement du texte en ligne, par exemple /side Check whether this plan has an obvious risk.
Revenez au chat parent une fois la parenthèse ciblée terminée.

Résultat attendu : Codex ouvre un chat latéral dont la transcription est distincte de celle du chat parent. En mode latéral, la TUI continue d’afficher l’état du chat parent afin que vous puissiez voir si le chat principal est toujours en cours d’exécution.

/side est indisponible dans un autre chat latéral et en mode examen.

Générez `AGENTS.md` avec `/init`

Exécutez /init dans le répertoire où vous souhaitez que Codex recherche des instructions persistantes.
Examinez le fichier AGENTS.md généré, puis modifiez-le pour l’adapter aux conventions de votre dépôt.

Résultat attendu : Codex crée une structure AGENTS.md que vous pouvez affiner et commiter pour les sessions futures.

Demandez une revue du worktree avec `/review`

Saisissez /review.
Enchaînez avec /diff si vous souhaitez examiner les modifications exactes des fichiers.

Résultat attendu : Codex résume les problèmes détectés dans votre worktree, en se concentrant sur les changements de comportement et les tests manquants. Il utilise le modèle de la session actuelle, sauf si vous définissez review_model dans config.toml.

Affichez la liste des outils MCP avec `/mcp`

Saisissez /mcp.
Examinez la liste pour vérifier quels serveurs et outils MCP sont disponibles.

Résultat attendu : Vous voyez les outils Model Context Protocol (MCP) configurés que Codex peut appeler pendant cette session.

Utilisez /mcp verbose pour inclure des diagnostics détaillés du serveur. Utilisez /mcp login <name> pour vous connecter à un serveur MCP configuré depuis la session active.

Parcourez les applications avec `/apps`

Saisissez /apps.
Choisissez une app dans la liste.

Résultat attendu : Codex insère la mention de l’app dans la zone de saisie sous la forme $app-slug, afin que vous puissiez immédiatement demander à Codex de l’utiliser.

Parcourez les plugins avec `/plugins`

Saisissez /plugins.
Choisissez un onglet de la marketplace, puis sélectionnez un plugin pour examiner ses fonctionnalités ou les actions disponibles.

Résultat attendu : Codex ouvre le navigateur de plugins afin que vous puissiez examiner les plugins installés, les plugins détectables autorisés par votre configuration et l’état des plugins installés. Appuyez sur Espace sur un plugin installé pour modifier son état d’activation.

Consultez et gérez les hooks de cycle de vie avec `/hooks`

Saisissez /hooks.
Choisissez un événement de hook pour examiner les gestionnaires correspondants.
Approuvez, désactivez ou réactivez les hooks non gérés selon vos besoins.

Résultat attendu : Codex ouvre le navigateur de hooks afin que vous puissiez examiner les hooks de cycle de vie configurés. Les hooks gérés sont indiqués comme tels et ne peuvent pas être désactivés depuis le navigateur de hooks de l’utilisateur.

Gérer les conversations avec `/agents`

Saisissez /agents et appuyez sur Entrée.
Sélectionnez une conversation dans le centre de commande pour l’ouvrir.

Résultat attendu : Codex affiche une vue d’ensemble des conversations sur le serveur connecté. Vous pouvez consulter leur état et passer de l’une à l’autre. Pour ouvrir le centre de commande directement depuis votre terminal, exécutez codex agents. Le centre de commande nécessite un serveur partagé local ou distant.

Changer de fil d’agent avec `/subagents`

Saisissez /subagents et appuyez sur Entrée.
Sélectionnez le fil souhaité dans le sélecteur.

Résultat attendu : Codex change le fil actif afin que vous puissiez examiner ou poursuivre le travail de cet agent.

Envoyez vos commentaires avec `/feedback`

Saisissez /feedback et appuyez sur Entrée.
Suivez les invites pour inclure des journaux ou des diagnostics.

Résultat attendu : Codex collecte les diagnostics demandés et les envoie aux responsables.

Déconnectez-vous avec `/logout`

Saisissez /logout et appuyez sur Entrée.

Résultat attendu : Codex efface les identifiants locaux de la session utilisateur actuelle.

Quittez la CLI avec `/quit` ou `/exit`

Saisissez /quit (ou /exit) et appuyez sur Entrée.

Résultat attendu : Codex se ferme immédiatement. Enregistrez ou commitez d’abord tout travail important.

Utilisez ces commandes pour contrôler Codex depuis la palette de commandes de VS Code. Vous pouvez également leur attribuer des raccourcis clavier.

Attribuez un raccourci clavier

Pour attribuer ou modifier un raccourci clavier d’une commande Codex :

Ouvrez la palette de commandes (Cmd+Shift+P sous macOS ou Ctrl+Shift+P sous Windows/Linux).
Exécutez Preferences: Open Keyboard Shortcuts.
Recherchez Codex ou l’ID de la commande (par exemple, chatgpt.newChat).
Sélectionnez l’icône en forme de crayon, puis saisissez le raccourci souhaité.

Commandes de l’extension

Commande	Raccourci clavier par défaut	Description
`chatgpt.addToThread`	-	Ajouter la plage de texte sélectionnée comme contexte du chat actuel
`chatgpt.addFileToThread`	-	Ajouter le fichier entier comme contexte du chat actuel
`chatgpt.newChat`	macOS : `Cmd+N` Windows/Linux : `Ctrl+N`	Créer un nouveau chat
`chatgpt.newCodexPanel`	-	Créer un nouveau panneau Codex
`chatgpt.openCommandMenu`	-	Ouvrir le menu des commandes Codex
`chatgpt.openSidebar`	-	Ouvrir le panneau latéral de Codex

Les commandes slash vous permettent de contrôler Codex sans quitter la zone de saisie. Utilisez-les pour vérifier l’état, basculer entre les modes local et cloud ou envoyer des commentaires.

Utilisez une commande slash

Dans la zone de saisie de Codex, saisissez /.
Sélectionnez une commande dans la liste ou continuez à saisir du texte pour filtrer (par exemple, /status).
Appuyez sur Entrée.

Commandes slash disponibles

Commande slash	Description
`/approve`	Approuver une nouvelle tentative pour un refus récent de l’examen automatique, lorsque celui-ci est actif.
`/cloud`	Exécuter le chat dans le cloud, lorsque l’exécution dans le cloud est disponible.
`/cloud-environment`	Choisir l’environnement cloud du chat.
`/compact`	Compacter le contexte du chat actuel.
`/fast`	Activer ou désactiver un niveau de service Fast fourni par le catalogue, lorsqu’il est disponible.
`/feedback`	Ouvrir la boîte de dialogue de commentaires pour envoyer des commentaires et, éventuellement, inclure des journaux.
`/fork`	Copier un chat local dans un nouveau chat local.
`/goal`	Définir un objectif persistant vers lequel Codex doit travailler.
`/ide-context`	Activer ou désactiver le contexte IDE automatique.
`/init`	Générer une structure `AGENTS.md` pour le projet actuel.
`/local`	Exécuter le chat dans votre espace de travail local.
`/mcp`	Ouvrir l’état de MCP pour afficher les serveurs connectés.
`/memories`	Configurer si le chat peut utiliser ou générer des mémoires, lorsque Memories est disponible.
`/model`	Choisir le modèle du chat actuel.
`/personality`	Choisir la manière dont Codex répond, lorsque le modèle actuel prend en charge les personnalités.
`/plan`	Activer ou désactiver le mode plan pour la planification en plusieurs étapes.
`/project`	Choisir un projet pour les nouveaux chats.
`/reasoning`	Choisir l’effort de raisonnement du chat actuel.
`/review`	Démarrer le mode d’examen du code pour examiner les modifications non commitées ou effectuer une comparaison avec une branche de base.
`/side`	Démarrer un chat latéral temporaire sans interrompre le chat principal.
`/status`	Afficher l’ID du chat, l’utilisation du contexte et les limites de débit.
`/worktree`	Exécuter le chat dans un nouveau worktree Git.

Commandes de l’application de bureau ChatGPT

Comment lire cette référence

Options globales

Vue d’ensemble des commandes

Détail des commandes

codex (mode interactif)

codex agents

codex queue

codex app-server

codex remote-control

codex app

codex debug app-server send-message-v2

codex debug models

codex debug prompt-input

codex apply

codex review

codex archive et codex unarchive

codex delete

codex cloud

codex cloud list

codex completion

codex doctor

codex features

codex exec

codex execpolicy

codex login

codex logout

codex mcp

codex plugin

codex plugin marketplace

codex mcp-server

codex resume

codex fork

codex sandbox

macOS seatbelt

Bac à sable Linux

Windows

codex update

Combinaisons d’options et conseils de sécurité

Raccourcis interactifs

Ressources connexes

Commandes slash intégrées

Contrôler votre session avec les commandes slash

Choisir le mode du terminal avec /tui

Exporter une conversation avec /export

Résumer la conversation avec /recap

Changer de répertoire avec /cd

Poursuivre dans un worktree avec /worktree

Gérer le serveur en arrière-plan avec /daemon

Examiner les avertissements avec /warnings

Définir le modèle actif avec /model

Activer ou désactiver le mode Fast avec /fast

Passer en mode plan avec /plan

Définir ou consulter un objectif de tâche avec /goal

Activer ou désactiver les fonctionnalités expérimentales avec /experimental

Autoriser une action refusée par la vérification automatique avec /approve

Configurer les souvenirs avec /memories

Utiliser les skills avec /skills

Importer la configuration de Claude Code ou de Cursor avec /import

Effacer le terminal et démarrer une nouvelle conversation avec /clear

Archiver la session actuelle avec /archive

Supprimer la session actuelle avec /delete

Mettre à jour les autorisations avec /permissions

Inclure le contexte de l’IDE avec /ide

Activer ou désactiver le mode Vim avec /vim

Configurer le bac à sable Windows avec élévation de privilèges avec /setup-default-sandbox

Copier la dernière réponse avec /copy

Activer ou désactiver l’historique brut du terminal avec /raw

Examiner la session avec /status

Consulter l’utilisation du compte avec /usage

Examiner les couches de configuration avec /debug-config

Configurer les éléments du pied de page avec /statusline

Configurer les éléments du titre du terminal avec /title

Choisir un thème de coloration syntaxique avec /theme

Choisir une mascotte de terminal avec /pets

Réaffecter les raccourcis de la TUI avec /keymap

Vérifier les terminaux en arrière-plan avec /ps

Arrêter les terminaux en arrière-plan avec /stop

Alléger les transcriptions avec /compact

Examinez les modifications avec /diff

`codex` (mode interactif)

`codex agents`

`codex queue`

`codex app-server`

`codex remote-control`

`codex app`

`codex debug app-server send-message-v2`

`codex debug models`

`codex debug prompt-input`

`codex apply`

`codex review`

`codex archive` et `codex unarchive`

`codex delete`

`codex cloud`

`codex cloud list`

`codex completion`

`codex doctor`

`codex features`

`codex exec`

`codex execpolicy`

`codex login`

`codex logout`

`codex mcp`

`codex plugin`

`codex plugin marketplace`

`codex mcp-server`

`codex resume`

`codex fork`

`codex sandbox`

`codex update`

Choisir le mode du terminal avec `/tui`

Exporter une conversation avec `/export`

Résumer la conversation avec `/recap`

Changer de répertoire avec `/cd`

Poursuivre dans un worktree avec `/worktree`

Gérer le serveur en arrière-plan avec `/daemon`

Examiner les avertissements avec `/warnings`

Définir le modèle actif avec `/model`

Activer ou désactiver le mode Fast avec `/fast`

Passer en mode plan avec `/plan`

Définir ou consulter un objectif de tâche avec `/goal`

Activer ou désactiver les fonctionnalités expérimentales avec `/experimental`

Autoriser une action refusée par la vérification automatique avec `/approve`

Configurer les souvenirs avec `/memories`

Utiliser les skills avec `/skills`

Importer la configuration de Claude Code ou de Cursor avec `/import`

Effacer le terminal et démarrer une nouvelle conversation avec `/clear`

Archiver la session actuelle avec `/archive`

Supprimer la session actuelle avec `/delete`

Mettre à jour les autorisations avec `/permissions`

Inclure le contexte de l’IDE avec `/ide`

Activer ou désactiver le mode Vim avec `/vim`

Configurer le bac à sable Windows avec élévation de privilèges avec `/setup-default-sandbox`

Copier la dernière réponse avec `/copy`

Activer ou désactiver l’historique brut du terminal avec `/raw`

Examiner la session avec `/status`

Consulter l’utilisation du compte avec `/usage`

Examiner les couches de configuration avec `/debug-config`

Configurer les éléments du pied de page avec `/statusline`

Configurer les éléments du titre du terminal avec `/title`

Choisir un thème de coloration syntaxique avec `/theme`

Choisir une mascotte de terminal avec `/pets`

Réaffecter les raccourcis de la TUI avec `/keymap`

Vérifier les terminaux en arrière-plan avec `/ps`

Arrêter les terminaux en arrière-plan avec `/stop`

Alléger les transcriptions avec `/compact`

Examinez les modifications avec `/diff`

Signalez des fichiers avec `/mention`

Démarrez une nouvelle conversation avec `/new`

Renommez la conversation en cours avec `/rename`

Reprenez une conversation enregistrée avec `/resume`

Créez une bifurcation de la conversation en cours avec `/fork`

Continuez dans l’application de bureau avec `/app`

Démarrez une conversation parallèle avec `/side`

Générez `AGENTS.md` avec `/init`

Demandez une revue du worktree avec `/review`

Affichez la liste des outils MCP avec `/mcp`

Parcourez les applications avec `/apps`

Parcourez les plugins avec `/plugins`

Consultez et gérez les hooks de cycle de vie avec `/hooks`