OpenAI Codex 0.159.0 fait du pilotage en cours d’exécution l’événement principal

OpenAI Codex 0.159.0 introduit un moyen facultatif de rediriger un agent actif avant que sa réponse en cours ou une commande de longue durée ne se termine. Cela peut sembler être un changement d’interface limité. En réalité, il cible l’un des problèmes les plus difficiles du codage agentique : corriger une mauvaise direction sans abandonner un travail utile.

La version est arrivée le 29 septembre 2026, avec six groupes de fonctionnalités et un large ensemble de correctifs. Son ajout phare, instant_interrupt, permet à une nouvelle entrée de préempter les réponses du modèle et de faire céder la main plus tôt à certains appels en mode code. Le mode code est le chemin d’exécution de Codex pour lancer des commandes et attendre des processus en cours.

Cela place Codex dans une course à l’interaction directe avec GitHub Copilot CLI et d’autres agents de codage. La compétition ne se limite plus au modèle qui produit le correctif le plus solide. Elle porte de plus en plus sur l’agent qui reste compréhensible, pilotable et récupérable pendant que le travail réel est en cours.

Ce que change réellement OpenAI Codex 0.159.0

La version traite le contrôle de l’agent comme une interaction continue, et non comme une succession de prompts isolés.

La version complète de Codex s’articule autour de instant_interrupt, même si ce drapeau reste désactivé par défaut. Lorsqu’il est activé, une nouvelle entrée utilisateur peut orienter Codex pendant une réponse du modèle. Elle peut également affecter les appels exec et wait de longue durée en mode code.

Auparavant, une entrée envoyée pendant l’un de ces appels pouvait rester en attente jusqu’au retour de l’appel. Ce comportement est prévisible, mais il engendre un délai coûteux lorsque l’utilisateur repère une mauvaise hypothèse. L’agent pouvait continuer à tester, produire des résultats ou suivre la mauvaise voie d’implémentation avant de lire la correction.

Le nouveau mécanisme surveille les entrées en attente pendant chaque requête d’échantillonnage. Il transmet ensuite un signal de préemption partagé aux appels d’outils éligibles. Une cellule en cours peut céder son identifiant sans être arrêtée, ce qui permet à Codex de traiter la nouvelle instruction.

Cette distinction compte. Céder la main n’équivaut pas à tuer la commande. Le travail sous-jacent peut se poursuivre, tandis qu’un appel wait ultérieur récupère ses résultats. Codex a ainsi l’occasion de réévaluer son action suivante sans détruire automatiquement un état d’exécution utile.

La modification associée des réponses du modèle boucle le processus. Une nouvelle entrée peut préempter la réponse en cours de génération, au lieu d’attendre derrière elle. La version préserve également les messages et résultats d’outils en attente tout au long du chemin d’interruption.

Imaginons un développeur qui demande à Codex de refactoriser un service d’authentification. Pendant que l’agent exécute les tests, le développeur remarque qu’un ancien client dépend encore du format actuel des jetons. Avec l’interruption instantanée activée, cette contrainte peut parvenir à Codex avant qu’il n’achève le plan initial.

La version comprend plusieurs changements d’interface plus modestes qui soutiennent le même objectif. Les nouvelles sessions affichent un écran d’accueil plus compact et utilisent des en-têtes cohérents, sans bordures. Des conseils peuvent s’afficher pendant le travail actif et après la fin d’un tour.

La visionneuse d’avertissements écarte désormais les avertissements que l’utilisateur a consultés avant de la fermer. Appuyer sur k conserve un avertissement sélectionné pour plus tard. La visionneuse devient ainsi une légère file de triage plutôt qu’une liste exigeant des inspections répétées.

Les utilisateurs peuvent également faire défiler la transcription alors qu’une boîte de dialogue de mise en œuvre du plan reste ouverte. Cela permet un schéma de vérification simple mais important : relire les éléments probants avant d’autoriser les changements proposés.

Ensemble, ces fonctionnalités de Codex 0.159.0 réduisent les frictions d’interface entourant les longues sessions d’agents. La version n’annonce pas un nouveau modèle de codage. Elle modifie la rapidité avec laquelle un humain peut influencer le modèle déjà au travail.

L’interruption instantanée modifie le coût d’une correction

Le pilotage en cours d’exécution compte, car une correction précoce coûte généralement moins cher que l’examen d’une erreur achevée.

Un agent de codage ne passe pas directement du prompt au correctif final. Il examine des fichiers, élabore un plan, appelle des outils, lit les résultats, modifie le code et valide ces changements. Une hypothèse erronée peut se propager à chacune de ces étapes.

Les interfaces de chat traditionnelles placent les nouveaux messages derrière la réponse en cours. Cet ordre fonctionne pour les questions aux réponses courtes. Il devient contraignant lorsqu’un agent exécute des commandes qui prennent plusieurs minutes ou attend des processus dont le délai de fin est incertain.

L’implémentation de cession de contrôle d’OpenAI répond à ce délai sans supposer que chaque nouveau message doit annuler le travail actuel. La cellule active cède le contrôle, mais continue de s’exécuter. Codex peut alors intégrer la nouvelle instruction et décider de la suite.

Cela crée un juste milieu entre attendre et interrompre. Attendre préserve le travail mais retarde la correction. Interrompre répond immédiatement, mais peut gaspiller les progrès d’exécution ou laisser l’utilisateur incertain de ce qui s’est arrêté.

La conception de l’interruption instantanée de Codex vise à préserver à la fois la réactivité et la continuité. C’est le mécanisme central de cette version, et il est plus déterminant qu’un nouveau raccourci ou une actualisation visuelle.

La fonctionnalité a également des implications pour les travaux sensibles aux autorisations. Un utilisateur peut ajouter une contrainte lorsque la direction émergente de l’agent devient visible. Par exemple, l’utilisateur peut interdire une dépendance, limiter les modifications à un seul paquet ou exiger une rétrocompatibilité.

Cette intervention dépend toutefois du moment. Un message ne peut pas inverser un effet secondaire externe qui s’est déjà produit. Elle ne remplace pas non plus des contrôles d’approbation rigoureux pour les commandes aux conséquences importantes.

L’interruption instantanée réduit plutôt le délai entre l’identification d’un problème et l’influence exercée sur l’agent. Cette fenêtre plus étroite devient précieuse à mesure que les tâches de codage s’allongent et comprennent davantage d’appels d’outils.

Le statut facultatif mérite attention. OpenAI ne présente pas ce comportement comme une valeur par défaut universelle. La préemption modifie l’ordre des messages, le calendrier d’exécution et les attentes des utilisateurs ; un déploiement prudent est donc raisonnable.

Les utilisateurs doivent également comprendre ce que signifie « interruption » dans ce contexte. La cellule active en mode code peut continuer après avoir cédé la main. Une personne qui s’attend à un arrêt d’urgence pourrait mal interpréter ce comportement, à moins que l’interface ne communique clairement l’état de la cellule.

La modification de préemption des réponses couvre une autre partie de l’expérience. Une entrée reçue peut arrêter la réponse actuelle du modèle et orienter le tour en cours. Le système tient également compte des messages qui arrivent pendant la compaction du contexte.

La compaction résume le contexte antérieur de la session lorsque la conversation devient volumineuse. Les entrées arrivant pendant ce processus doivent être différées et préservées, plutôt que perdues ou appliquées dans un ordre incohérent.

Ces détails révèlent la difficulté derrière une fonctionnalité apparemment simple. Une zone de texte réactive ne suffit pas. Le pilotage doit coordonner la génération du modèle, les entrées en attente, l’exécution en arrière-plan, les résultats d’outils et l’historique de la conversation.

OpenAI Codex 0.159.0 représente donc davantage une mise à jour d’orchestration qu’une mise à jour d’intelligence. Il rend la boucle de l’agent plus interruptible tout en cherchant à conserver le travail qui reste utile.

Les agents de codage rivalisent sur le contrôle, pas seulement sur les résultats

La compétition principale passe de l’exécution autonome à une collaboration utile pendant l’exécution.

GitHub documente une distinction similaire entre pilotage et mise en file d’attente dans ses produits d’agents de codage. Un message de pilotage modifie le travail en cours, tandis qu’un message mis en attente attend le tour suivant.

Dans les sessions d’agents cloud GitHub Copilot, le pilotage de suivi est appliqué une fois l’appel d’outil en cours terminé. Les contrôles de session de GitHub exposent également l’avancement en direct, les journaux de session, l’arrêt et l’archivage.

GitHub Copilot CLI va plus loin dans son interface locale. Un simple message saisi pendant que l’agent réfléchit devient par défaut une entrée de pilotage. Les utilisateurs peuvent séparément mettre du travail en file d’attente pour un tour ultérieur.

L’implémentation d’OpenAI diffère sur un point important. Son chemin facultatif permet aux appels éligibles de longue durée en mode code de céder la main avant la fin de leur processus sous-jacent. Cela peut réduire le délai entre l’intervention de l’utilisateur et la réévaluation par le modèle.

Cela ne démontre pas qu’un produit est catégoriquement plus rapide ou plus sûr. La version ne contient aucune comparaison indépendante de latence, aucun benchmark d’achèvement ni aucune mesure de réduction du travail gaspillé. Toute conclusion plus large sur les performances serait prématurée.

Elle montre toutefois la direction prise par la concurrence entre agents de codage. La qualité du modèle reste importante, mais la différenciation pratique vient de plus en plus du contrôle d’un travail déjà en mouvement.

Un agent puissant peut tout de même devenir frustrant s’il masque son état, retarde les corrections ou impose une annulation tout ou rien. Un modèle plus faible peut également consommer beaucoup de temps si l’utilisateur ne peut pas le rediriger avant qu’une erreur ne s’étende.

L’interaction recherchée ressemble davantage à la programmation en binôme qu’à une file de tâches. Un participant entame une approche, tandis que l’autre peut ajouter des contraintes à mesure que les éléments probants apparaissent. Aucun des participants ne doit recommencer toute la tâche après chaque correction.

Ce schéma affecte aussi l’évaluation en entreprise. Les équipes doivent savoir si les développeurs peuvent inspecter le travail actif, comprendre les opérations en attente et intervenir avant qu’un agent ne franchisse une limite du projet.

L’auditabilité devient une partie du produit. Il en va de même pour la distinction entre l’ajout de contexte, le changement de direction, la mise en file d’attente d’une autre tâche et l’arrêt de l’exécution. Ces actions ne devraient pas sembler identiques, car leurs conséquences diffèrent.

Les changements liés aux avertissements, à l’accès à la transcription et à la présentation des sessions soutiennent cette exigence. Ils donnent aux utilisateurs davantage d’informations alors qu’une décision reste ouverte, au lieu de ne présenter qu’un résultat terminé.

Ce modèle d’interaction récompense également un bon contexte de projet. Le pilotage fonctionne au mieux lorsque l’utilisateur peut fournir une contrainte précise étayée par la documentation existante. Une base de connaissances consultable peut aider les équipes à retrouver ces contraintes avant d’approuver le plan d’un agent.

OpenAI Codex 0.159.0 ne clôt pas la compétition sur le contrôle. Il établit une direction produit plus claire : un agent doit rester réactif même lorsque ses outils sont occupés.

Les fonctionnalités plus modestes facilitent la lecture des longues sessions

Les changements d’interface réduisent la charge cognitive aux moments où les utilisateurs doivent examiner, approuver ou préserver des informations.

Le nouvel écran de session est plus compact, et les en-têtes de session suivent désormais une conception cohérente sans bordures. Ces changements ne modifient pas la génération de code, mais ils réduisent les variations visuelles dans l’interface du terminal.

Des conseils occasionnels s’affichent désormais pendant que Codex travaille et après la fin des tours. Cela peut révéler des contrôles utiles lorsque les utilisateurs en ont besoin, même si les indications récurrentes doivent éviter de devenir une autre source de bruit.

Le flux de travail des avertissements bénéficie d’un changement plus fonctionnel. Fermer la visionneuse écarte les avertissements que l’utilisateur a déjà examinés. Une action conserver-et-suivant, déclenchée avec k, préserve un avertissement important et avance la sélection.

Cette conception associe les avertissements à un modèle de boîte de réception familier. Les éléments examinés quittent la file active, tandis que les exceptions restent disponibles. Ce changement devrait réduire les analyses répétées lors des sessions qui produisent plusieurs notifications.

Le transcript peut désormais rester défilable tandis qu’une boîte de dialogue modale demande si Codex doit mettre en œuvre un plan. Auparavant, une fenêtre modale pouvait limiter la capacité de l’utilisateur à revenir sur les échanges précédents au moment précis où leur examen importait le plus.

L’approbation d’un plan n’est pas un simple clic cérémoniel. Une décision pertinente peut nécessiter de vérifier la demande initiale, les sorties d’outils précédentes, les risques identifiés et les hypothèses formulées par l’agent. L’accès au transcript facilite cette comparaison.

La copie de contenu depuis le transcript est également plus fiable. Les sélections conservent les tableaux Markdown, la mise en forme et les espaces significatifs, tandis que des environnements de terminal supplémentaires prennent en charge la copie automatique lors de la sélection.

Cette correction est importante lorsque les utilisateurs transfèrent les sorties générées vers des outils de suivi des tickets, des revues de code, de la documentation ou des registres d’incidents. La perte de mise en forme peut modifier le sens des journaux, des tableaux et du texte adjacent au code.

Le rendu Mermaid natif bénéficie d’une prise en charge syntaxique plus étendue. Mermaid est un langage de diagrammes textuel qui décrit des flux et des relations au moyen d’un texte source concis.

Le moteur de rendu mis à jour préserve la ponctuation et les points-virgules dans les libellés. Il reconnaît également davantage de relations dans les organigrammes, d’étiquettes d’arêtes, de marqueurs de direction et de structures de nœuds groupés.

Les diagrammes d’architecture générés par les agents deviennent ainsi des artefacts de terminal plus utiles. Un développeur peut demander à Codex d’expliquer le flux d’un service, examiner le résultat rendu et conserver la source Mermaid sous-jacente.

La mise à jour de Mermaid souligne également un défi récurrent des interfaces. Les diagrammes générés ne sont utiles que si le moteur de rendu accepte la syntaxe que les modèles produisent couramment.

Les clients app-server acquièrent une capacité de plus bas niveau grâce à la pagination des fils ancrée sur un élément. Un client peut demander l’historique d’un fil relativement à un élément particulier plutôt que de naviguer uniquement parmi des pages plus larges.

Cela devrait aider les applications à charger la portion pertinente d’une longue conversation. Cela donne aussi aux développeurs clients davantage de contrôle sur les chronologies reprenables et les vues d’historique incrémentales.

Aucun de ces ajouts n’a le poids conceptuel de l’interruption instantanée. Collectivement, toutefois, ils facilitent l’accès aux sessions prolongées, leur inspection, leur navigation et leur réutilisation.

Cela compte, car l’utilisabilité des agents se dégrade à mesure que les conversations s’allongent. De meilleurs modèles ne résolvent pas à eux seuls la navigation dans les transcripts, la fatigue face aux avertissements, les échecs de diagrammes ou la perte de mise en forme.

Les correctifs Windows et Sandbox portent l’essentiel de la charge opérationnelle

La version comble également des lacunes de plateforme et de sécurité qui peuvent compter davantage que les améliorations visibles de l’interface.

Sous Windows, Codex supprime désormais les fenêtres de console indésirables lors du lancement de plusieurs types de processus enfants. Les chemins concernés comprennent les serveurs locaux Model Context Protocol, les hôtes en mode code et les commandes connectées par des pipes.

MCP est un protocole qui relie les modèles à des outils et sources de données externes. Un serveur MCP local peut fonctionner comme processus enfant en arrière-plan ; une fenêtre de console inattendue peut donc perturber l’expérience sur ordinateur.

Les lanceurs Windows restrictifs peuvent désormais basculer vers un mode embarqué. Cela fournit une autre voie d’exécution lorsque les règles de création de processus empêchent l’architecture privilégiée de fonctionner.

La version améliore également le comportement de lancement des démons en présence d’une appartenance résiduelle à une tâche Windows. Un autre correctif empêche les handles d’entrée et de sortie du lanceur de rester attachés alors qu’ils ne devraient pas l’être.

Ces changements concernent la fiabilité plutôt que le comportement du modèle. Ils sont particulièrement pertinents pour les machines administrées, les intégrations de bureau et les flux de travail de terminal qui créent plusieurs sous-processus.

Les frontières de sécurité font l’objet d’une attention distincte. Les commandes approuvées conservent désormais les refus explicites d’accès au système de fichiers, au lieu de perdre ces restrictions lors de la préparation de la commande.

Codex protège également par défaut les répertoires .aws lorsqu’ils apparaissent sous des racines accessibles en écriture. Ces répertoires peuvent contenir une configuration cloud ou des identifiants, ce qui rend cette frontière par défaut importante.

La version ne prétend pas que ces changements éliminent les risques liés au sandbox. Elle indique toutefois qu’OpenAI resserre le passage entre l’approbation d’un utilisateur et les autorisations appliquées lors de l’exécution.

Cette frontière mérite un examen attentif, car une commande approuvée n’équivaut pas à un accès illimité au système de fichiers. Si la préparation de la commande écarte un refus explicite, l’exécution ne reflète plus la décision examinée par l’utilisateur.

Les sandboxes macOS avec accès réseau bénéficient d’un correctif de confiance TLS. La mise à jour autorise l’évaluation de confiance du système sous les profils Seatbelt concernés, qui sont des politiques de sandbox macOS limitant les capacités des processus.

Les environnements distants nécessitant un proxy bénéficient aussi d’un comportement d’exécution corrigé. Ces correctifs traitent des écarts fréquents entre l’accès réseau théorique d’un outil de développement et les règles de la machine qui l’héberge.

L’authentification devient également moins fragile. Les flux app-server locaux devraient ouvrir plus fiablement le navigateur pour la connexion à ChatGPT. L’intégration propose désormais un raccourci pour copier l’URL de connexion lorsque l’ouverture automatique ne convient pas.

Les sessions vides conservent leurs brouillons lorsque les utilisateurs changent de tâche. Les fils peuvent être archivés et listés avant de contenir un premier tour terminé, ce qui rend la gestion des sessions moins dépendante de l’état de la conversation.

Ces correctifs renforcent l’orientation générale de la version. Les agents de longue durée ont besoin d’un état durable et d’un comportement de processus prévisible, pas seulement de réponses impressionnantes.

Un agent de programmation qui ouvre des fenêtres indésirables, perd des brouillons, gère mal les refus ou échoue derrière un proxy impose des coûts opérationnels. Ces défaillances peuvent freiner l’adoption même lorsque le code généré est acceptable.

Le pilotage opt-in doit encore être éprouvé dans le monde réel

La valeur de la fonctionnalité dépend d’un timing prévisible, d’indicateurs d’état clairs et d’un comportement correct sous pression.

La première incertitude concerne la latence. La version explique que les appels éligibles peuvent céder la main lorsqu’une nouvelle entrée arrive, mais elle ne publie aucune mesure de délai. Les utilisateurs doivent encore observer la rapidité avec laquelle le pilotage prend effet.

La deuxième incertitude concerne la sémantique. « Interrompre », « préempter », « céder la main » et « arrêter » décrivent des opérations différentes. Un processus en cours peut survivre après que Codex a rendu le contrôle, alors qu’un utilisateur peut supposer que le travail s’est terminé.

Une interface claire devrait indiquer si un processus reste actif, si sa sortie continue d’arriver et si l’agent prévoit de consulter cette sortie. L’ambiguïté peut ici créer des commandes dupliquées ou des modifications conflictuelles.

Le troisième enjeu est l’adoption. Comme instant_interrupt est désactivé par défaut, son impact initial sera limité aux utilisateurs qui découvrent et activent le drapeau.

Un déploiement opt-in laisse place aux tests, mais il réduit aussi le retour disponible. Les utilisateurs expérimentés peuvent exercer la fonctionnalité différemment des développeurs qui découvrent pour la première fois la programmation agentique.

Le quatrième enjeu concerne les conditions de course. Une nouvelle entrée peut arriver pendant la génération du modèle, l’exécution, l’attente ou la compaction du contexte. Chaque chemin doit préserver l’ordre des messages et empêcher les résultats d’outils de s’attacher à la mauvaise étape de raisonnement.

OpenAI indique que ses tests couvrent les comportements activé et désactivé, le pilotage répété, les entrées différées pendant la compaction et les appels ultérieurs au sein de la même réponse. Les tests vérifient également que les messages en file d’attente et les résultats directs d’outils restent préservés.

Ces cas sont nécessaires, mais les sessions de production génèrent des combinaisons moins ordonnées. Un développeur peut piloter à répétition, modifier le périmètre de fichiers demandé, refuser une autorisation et recevoir une sortie de processus tardive au cours d’un même tour.

Le cinquième enjeu est la sécurité. Un pilotage plus rapide peut aider à arrêter une erreur en cours d’apparition, mais il ne remplace ni l’approbation des commandes, ni les restrictions de sandbox, ni la revue du dépôt.

Une commande nuisible peut se terminer avant que la correction n’arrive. Un service externe peut aussi traiter une requête même après que l’agent local a changé de cap. Les utilisateurs ne devraient pas considérer l’interruption conversationnelle comme un rollback transactionnel.

Il existe également un risque de surpilotage. Des corrections fréquentes peuvent produire un objectif fragmenté, surtout lorsque l’agent conserve le contexte précédent et que plusieurs instructions se disputent la priorité.

Les équipes auront besoin de conventions d’interaction. Un message de pilotage devrait indiquer clairement ce qui a changé, quelle instruction précédente il remplace et si l’exécution en cours doit continuer.

La suppression des suggestions automatiques de prompts de suivi est pertinente ici. Codex 0.159.0 supprime à la fois ces suggestions et le paramètre associé. OpenAI semble réduire l’échafaudage de prompts non sollicité tout en ajoutant davantage de contrôle direct pour l’utilisateur.

La version supprime également la skill plugin-creator incluse. Ce changement de packaging ne doit pas être confondu avec la fonctionnalité de pilotage, mais les utilisateurs qui dépendent de capacités intégrées devraient examiner leur configuration locale après la mise à niveau.

La lecture sceptique est simple. OpenAI a ajouté le mécanisme permettant une intervention plus rapide, mais la version ne fournit aucune preuve qu’il améliore les taux de réussite des tâches.

Cela ne rend pas la fonctionnalité sans importance. Cela définit la prochaine question d’évaluation : le pilotage en cours d’exécution évite-t-il suffisamment de travail perdu pour justifier la complexité d’exécution supplémentaire ?

Trois signaux à surveiller après Codex 0.159.0

Le prochain test consiste à déterminer si l’interruption instantanée passe d’un contrôle expérimental à un élément fiable de la programmation quotidienne.

Le premier signal est son statut par défaut. Si OpenAI active instant_interrupt par défaut dans une version ultérieure, cela indiquerait une confiance dans l’ordonnancement, la préservation et la clarté de l’interface.

Le maintenir opt-in pendant plusieurs versions suggérerait que des cas limites nécessitent encore de l’attention. Cela pourrait aussi signifier qu’OpenAI souhaite un consentement explicite pour un comportement qui modifie les attentes établies en matière de mise en file d’attente.

Le deuxième signal est l’activité des issues et des versions autour du pilotage répété. Des signalements de messages perdus, de commandes dupliquées, de processus orphelins ou de sortie tardive affaibliraient l’argument en faveur d’une interruption immédiate.

Des correctifs élargissant les chemins d’outils pris en charge le renforceraient. La conception actuelle traite spécifiquement les réponses du modèle et les appels exec ou wait de longue durée en mode code, et non toutes les opérations externes possibles.

Le troisième signal est le comportement des concurrents. GitHub documente déjà le pilotage immédiat et les suivis mis en file d’attente à travers ses produits et SDK. D’autres fournisseurs d’agents de programmation subissent la même pression pour exposer des contrôles clairs en cours d’exécution.

La comparaison importante ne portera pas sur la présence d’une fonctionnalité appelée pilotage. Elle portera sur la rapidité avec laquelle une correction prend effet et la précision avec laquelle le système explique l’état d’exécution restant.

Les développeurs devraient tester OpenAI Codex 0.159.0 sur des tâches limitées et réversibles avant de s’appuyer sur l’interruption lors de travaux sensibles. Un essai utile pourrait inclure une longue exécution de tests, une correction de périmètre et l’inspection du processus survivant.

Vérifiez que Codex reçoit rapidement la nouvelle instruction. Confirmez si le processus initial reste actif. Vérifiez ensuite que la sortie ultérieure est rattachée au bon tour et ne ranime pas l’approche abandonnée.

La version porte un jugement produit convaincant : les utilisateurs ont besoin d’un moyen d’intervenir avant qu’un agent n’achève de se tromper. L’implémentation doit maintenant prouver qu’une intervention plus rapide reste compréhensible sous de véritables charges de travail.

Si vous activez OpenAI Codex 0.159.0, commencez par une question pratique. Pouvez-vous rediriger une tâche longue sans perdre les progrès utiles ni devenir incertain de ce qui continue à s’exécuter ? Ce résultat compte davantage que le drapeau lui-même.