OpenAI Codex 0.154.0 transforme la CLI en système de travail parallèle

OpenAI Codex 0.154.0 apporte un changement notable : l’agent de codage peut désormais gérer le travail en parallèle sans faire passer chaque tâche par un seul checkout. Publiée le 9 septembre 2026, la mise à jour combine des worktrees expérimentaux, des questions intégrées, l’accès à GPT-6-Astra et un serveur Windows partagé.

Considérées comme de simples améliorations du terminal, les fonctionnalités individuelles paraissent modestes. Ensemble, elles modifient le modèle de fonctionnement de la Codex CLI. Codex devient une couche de coordination persistante pour plusieurs sessions de codage, dépôts, modèles et processus en arrière-plan.

Cette orientation met sous pression l’assistant de codage conventionnel à session unique. GitHub Copilot, Claude Code et des produits similaires rivalisent de plus en plus sur l’orchestration, et non uniquement sur la complétion de code. La question essentielle est de savoir si OpenAI peut rendre ce flux de travail élargi suffisamment prévisible pour le travail d’ingénierie quotidien.

Ce que change réellement OpenAI Codex 0.154.0

Cette version fait évoluer Codex au-delà d’une seule conversation associée à un seul répertoire de travail.

L’ajout phare est la prise en charge expérimentale des worktrees. Un worktree Git est un checkout supplémentaire relié au même dépôt, qui permet à des branches distinctes d’exister dans des répertoires distincts.

Les développeurs peuvent demander un checkout isolé au démarrage d’une nouvelle session ou d’une session forkée. La CLI expose cette possibilité via --worktree, tandis que l’interface interactive ajoute des contrôles /worktree pour créer et parcourir ces sessions.

L’implémentation des worktrees gérés d’OpenAI associe chaque thread éligible à son checkout. Ce checkout devient alors le répertoire de travail de cette session.

Cette conception répond à un problème courant du développement assisté par agents. Deux agents modifiant le même checkout peuvent écraser des fichiers, perturber des tests ou laisser le dépôt sur une branche inattendue.

Des worktrees distincts réduisent ce risque de collision. Une session peut analyser un bug en production pendant qu’une autre prépare une mise à niveau de dépendances, chacune utilisant son propre arbre de travail.

La fonctionnalité change également la manière dont les utilisateurs peuvent reprendre un travail parallèle. Codex peut afficher dans son navigateur les sessions adossées à des worktrees, puis permettre aux utilisateurs de reprendre ensemble le thread et le checkout concernés.

Cette association compte, car l’état de la conversation et l’état du dépôt divergent souvent. Une transcription restaurée est moins utile lorsque le répertoire de travail ne correspond plus aux fichiers précédemment examinés par l’agent.

OpenAI qualifie toujours cette fonctionnalité d’expérimentale. L’implémentation initiale rejette les combinaisons de commandes non prises en charge, l’exécution distante, les sessions éphémères et les tentatives effectuées sans le feature flag.

Le nettoyage automatique reste également limité pour les allocations de la CLI. Les développeurs doivent donc surveiller la consommation de stockage et les worktrees obsolètes, en particulier dans les dépôts comportant d’importants assets générés.

GPT-6-Astra constitue le deuxième élément visible de cette version. Le modèle apparaît dans le sélecteur intégré, tandis que des modifications connexes du catalogue le rendent disponible via les routes Amazon Bedrock prises en charge.

OpenAI avait déjà introduit une partie de cette intégration au cours de la série de correctifs 0.153 précédente. La version 0.153.1 a ajouté la configuration API, la 0.153.3 a étendu les catalogues Bedrock et la 0.153.4 a corrigé la visibilité dans le sélecteur.

Cette séquence explique pourquoi certains utilisateurs ont rencontré Astra avant la sortie de la version 0.154.0. La nouvelle version regroupe le travail sur le modèle avec des changements plus larges relatifs aux sessions et à l’interface.

OpenAI a également enrichi la copie des réponses. Les applications de texte enrichi peuvent conserver davantage de mise en forme, tandis que /copy offre davantage de contrôle sur la copie d’une réponse entière ou d’un bloc de contenu sélectionné.

Ces améliorations ne constituent pas le cœur stratégique de la version. Elles servent toutefois la même idée plus large : les résultats de Codex doivent pouvoir être transférés proprement vers les revues, documents, tickets et autres systèmes d’ingénierie.

La prise en charge des worktrees par Codex modifie l’unité de travail

Le mécanisme central de cette version est l’isolation des sessions, et non le nom d’un nouveau modèle.

Un assistant de codage traditionnel fonctionne dans le checkout actuel du développeur. Ce modèle semble simple jusqu’à ce que l’utilisateur lui demande de mener plusieurs tâches à la fois.

Imaginons un développeur confronté à une régression d’authentification, une migration de base de données et une correction de documentation. Exécuter ces trois tâches dans un seul arbre de travail crée des problèmes d’état partagé.

Un agent peut changer de branche alors qu’une autre commande est encore en cours. Une tâche de migration peut réécrire des fichiers générés qui apparaissent dans le diff de la session consacrée à la régression.

Les équipes évitent souvent ces conflits manuellement. Les développeurs clonant de nouveau les dépôts, créent eux-mêmes des worktrees ou limitent les agents à une tâche active par machine.

La prise en charge des worktrees par Codex transforme cette précaution manuelle en propriété de session. Lorsqu’une session éligible démarre avec --worktree, la CLI alloue un checkout géré et l’associe au thread.

Les sessions forkées peuvent également recevoir leur propre checkout isolé. Un utilisateur peut faire bifurquer le raisonnement et l’état du dépôt à peu près au même moment.

Cette combinaison rend les forks plus utiles sur le plan opérationnel. Un fork n’a plus besoin de rester une conversation spéculative déconnectée du travail exécutable.

Par exemple, une session pourrait mettre en œuvre un correctif minimal tandis qu’un fork tente une refactorisation plus vaste. Chaque agent peut exécuter des tests et modifier des fichiers sans mélanger immédiatement les résultats.

Le développeur peut ensuite comparer les diffs, évaluer les résultats des tests et décider quelle branche mérite un travail supplémentaire. Cette approche se rapproche davantage du développement humain en parallèle qu’une interface de chat.

La conception reconnaît aussi que les sessions d’agents ont des cycles de vie. Elles démarrent, se mettent en pause, forkent, échouent, reprennent et survivent parfois au terminal qui les a lancées.

Associer un checkout à un thread crée un point de référence durable au fil de ces transitions. Cela donne au système une réponse plus solide à la question : « Quel état du dépôt appartient à cette conversation ? »

La contrepartie est une gestion d’état supplémentaire. Les worktrees Git partagent les données du dépôt, mais créent malgré tout des répertoires, branches, verrous et enregistrements administratifs.

Un processus interrompu ou une expérimentation abandonnée peut laisser des artefacts. Les équipes auront besoin de conventions claires pour nommer, examiner, fusionner et supprimer les worktrees créés par les agents.

La première implémentation d’OpenAI évite délibérément le nettoyage automatique pour les allocations de la CLI. Cela protège les utilisateurs contre la perte de modifications inachevées, mais reporte l’entretien sur le développeur.

La fonctionnalité est également contrôlée par un flag et limitée dans son périmètre. Elle ne signifie pas que chaque exécution de Codex devient automatiquement un environnement isolé.

Cette distinction est importante pour la sécurité. Un worktree sépare les fichiers et les branches, mais n’isole pas automatiquement les identifiants, l’accès réseau, les processus ou les services externes.

Deux sessions utilisant des worktrees peuvent toujours affecter la même base de données ou le même compte cloud. Elles peuvent aussi se disputer les ports, conteneurs, caches et services de développement locaux.

Les développeurs doivent donc considérer les worktrees comme une isolation du contrôle de version. Ils ne sont pas équivalents à des machines virtuelles, des conteneurs ou des sandbox de sécurité.

Malgré ces limites, la fonctionnalité marque une décision produit significative. OpenAI conçoit Codex autour de tâches simultanées au lieu de supposer une seule conversation au premier plan.

Ce choix pousse les autres assistants de codage à relier la gestion des sessions à la gestion des dépôts. Une meilleure génération de code ne peut à elle seule résoudre les collisions entre agents parallèles.

Les questions intégrées maintiennent l’agent en mouvement

Codex peut désormais demander des décisions sans s’emparer du brouillon principal de l’utilisateur.

Les tâches de codage longues restent rarement entièrement autonomes. Un agent finit par nécessiter un choix concernant le périmètre, le style d’implémentation, la compatibilité ou le niveau de risque acceptable.

Les schémas d’interaction précédents pouvaient interrompre le flux de travail de l’utilisateur. Une question pouvait occuper le composeur principal tandis que le développeur préparait une instruction détaillée pour une autre partie de la tâche.

Le flux de questions intégrées d’OpenAI sépare ces interactions. Les questions de l’agent actif apparaissent avec un compteur réduit et un éditeur de réponse extensible.

Les utilisateurs peuvent parcourir, répondre, mettre en file d’attente ou ignorer les questions tout en conservant le texte déjà rédigé dans le composeur principal. Des choix suggérés peuvent accélérer les décisions routinières, tandis qu’un texte personnalisé permet de traiter les exceptions.

Prenons une session de migration qui découvre deux stratégies de base de données incompatibles. Codex peut demander quel objectif de compatibilité importe, tout en poursuivant les tâches qui ne dépendent pas de la réponse.

L’utilisateur peut répondre sans abandonner une instruction plus longue en cours de rédaction pour cette même session. Les réponses acceptées empruntent le chemin existant de transmission des entrées.

Cela semble être un détail d’interface, mais cette approche traite un goulot d’étranglement d’orchestration. Les agents parallèles créent davantage de demandes de décision, et celles-ci peuvent submerger un seul flux de chat.

Les questions structurées rendent l’interruption plus légère. Elles présentent aussi la décision comme un élément d’état distinct au lieu de l’enfouir dans un message général.

L’implémentation tient compte des déconnexions temporaires. Les questions restent modifiables lorsque le client est déconnecté, bien que l’envoi et l’ignorance restent désactivés jusqu’au retour de la connexion.

OpenAI indique que ses tests couvrent les réponses mises en file d’attente, les brouillons conservés, les mises en page contraintes, les entrées mises en mémoire tampon et le comportement d’annulation de Vim. Ces cas comptent, car les interfaces de terminal rencontrent fréquemment des états d’entrée partiels.

La fonctionnalité offre également à GPT-6-Astra un chemin d’interaction plus clair. Les correctifs antérieurs de la série 0.153 ont corrigé les instructions d’Astra concernant les outils de clarification asynchrones et leur format d’entrée pris en charge.

L’effet pratique est un lien plus étroit entre le comportement du modèle et les capacités du client. Un modèle ne devrait demander une réponse asynchrone que lorsque la session active est en mesure de l’afficher et de la transmettre.

Cette dépendance révèle un risque plus large. Les fonctionnalités d’agents reposent de plus en plus sur la coordination des instructions du modèle, du comportement du serveur et de la prise en charge du client local.

Si ces couches ne sont plus synchronisées, un modèle peut demander un outil dont l’interface ne dispose pas. Le client peut également afficher des contrôles que le fournisseur sélectionné ne peut pas exécuter.

La version 0.153.4 a précisément ajusté les consignes d’Astra afin qu’il n’utilise des questions asynchrones que lorsque l’outil était disponible. Ce correctif illustre la rapidité avec laquelle les hypothèses liées au catalogue et à l’interface peuvent diverger.

OpenAI Codex 0.154.0 réduit ce décalage, mais n’élimine pas le défi architectural. Les entreprises peuvent utiliser des fournisseurs personnalisés, des clients plus anciens, des configurations gérées ou des catalogues de modèles restreints.

Ces environnements nécessitent des solutions de repli élégantes. Une question textuelle ordinaire doit rester utilisable lorsque les questions structurées ne sont pas disponibles.

Les développeurs doivent également éviter de considérer les réponses intégrées comme de simples confirmations sans conséquence. Un choix bref peut orienter un agent vers une modification de schéma, une commande destructive ou une décision de compatibilité.

Les équipes ont toujours besoin de limites de revue pour les actions importantes. La transmission pratique des entrées ne doit pas affaiblir les exigences d’approbation ni remplacer une inspection attentive.

La meilleure utilisation des questions intégrées est la clarification limitée. L’agent doit identifier une décision concrète, en expliquer la conséquence et ne poursuivre que là où la réponse importe.

Utilisée ainsi, cette fonctionnalité réduit le temps d’inactivité sans prétendre que chaque jugement d’ingénierie peut être automatisé.

Les services Windows et les contrôles Vim élargissent le flux de travail quotidien

OpenAI investit dans les détails opérationnels nécessaires pour que Codex reste actif tout au long de la journée d’un développeur.

Les sessions Windows peuvent désormais partager un serveur d’application Codex en arrière-plan. Un serveur d’application est le service local qui coordonne les fils de discussion, les événements et les connexions clientes derrière l’interface visible.

Le travail sur le daemon Windows ajoute la prise en charge du cycle de vie pour démarrer, arrêter et gérer ce processus partagé. Les mises à jour gérées peuvent se coordonner avec le service plutôt que de traiter chaque terminal comme un environnement d’exécution isolé.

Un serveur partagé peut réduire la duplication des ressources lorsque plusieurs sessions sont ouvertes. Il peut également offrir un emplacement cohérent pour l’état des sessions entre les clients.

C’est important pour les équipes dont les machines de développement standard fonctionnent sous Windows. Les outils d’agents arrivent souvent d’abord sur macOS et Linux, laissant les utilisateurs Windows avec une gestion des processus plus limitée ou des défaillances propres à la plateforme.

Un service en arrière-plan crée ses propres responsabilités opérationnelles. Le serveur doit démarrer de façon fiable, se mettre à jour en toute sécurité, s’arrêter proprement et se rétablir après des plantages.

Il devient également une frontière de sécurité. Un processus local de longue durée peut conserver des connexions, des métadonnées de session et l’accès aux environnements de projet.

Les entreprises voudront savoir comment le daemon authentifie les clients, stocke l’état, écrit les journaux et hérite des autorisations. L’infrastructure partagée amplifie les erreurs de configuration autant que les gains d’efficacité.

La version améliore aussi l’édition dans le terminal pour les utilisateurs qui préfèrent les commandes Vim. Le composeur prend désormais en charge le mode remplacement avec R, qui écrase les caractères existants jusqu’à ce que l’utilisateur quitte ce mode.

Le mode remplacement de Vim comprend l’intégration de l’annulation et le comportement de répétition par point. La répétition par point rejoue la dernière opération d’édition, selon une convention Vim familière.

La gestion d’Échap a reçu une attention supplémentaire, notamment pour les terminaux anciens. Les applications de terminal ont parfois du mal à distinguer une pression sur la touche Échap du début d’une autre séquence d’entrée encodée.

Une gestion peu fiable est plus qu’un désagrément dans une interface de type Vim. Échap change les modes d’édition ; une reconnaissance retardée ou manquée peut donc modifier le texte de manière inattendue.

Ces changements montrent qu’OpenAI s’attend à ce que les utilisateurs rédigent des prompts conséquents dans Codex. Un agent de terminal ne peut pas dépendre d’une zone de texte minimale si les développeurs rédigent des spécifications, collent des journaux, ajoutent du contexte et révisent des instructions détaillées.

Les changements relatifs à la copie soutiennent l’autre extrémité de ce flux de travail. Les réponses transférées dans des éditeurs de texte enrichi peuvent conserver leur mise en forme au lieu de se réduire à du texte brut difficile à exploiter.

C’est utile lorsque les développeurs déplacent un plan d’implémentation dans un ticket, partagent un résumé de revue ou conservent une sortie structurée dans la documentation.

Les équipes qui construisent une base de connaissances techniques pérenne peuvent associer ces résultats à une base de connaissances d’ingénierie consultable. La valeur vient de la conservation des décisions et du contexte, et non de la simple accumulation de code généré.

Aucune de ces améliorations d’interface ne garantit un meilleur raisonnement. Elles réduisent les frictions autour du processus de raisonnement.

Cette distinction est importante. Un agent doté d’excellents contrôles d’édition peut toujours faire une hypothèse architecturale erronée ou produire un correctif plausible mais dangereux.

Cependant, les frictions du flux de travail influencent la capacité des utilisateurs à repérer et corriger ces erreurs. Des brouillons fiables, une mise en forme préservée, un comportement prévisible d’Échap et des sessions durables facilitent la revue.

OpenAI concurrence donc aussi sur la qualité de l’interaction, en parallèle des capacités des modèles. C’est le même terrain que celui occupé par les environnements de développement matures, les multiplexeurs de terminal et les systèmes de programmation collaborative.

Le véritable affrontement : orchestration contre prévisibilité

Codex 0.154.0 étend ce qu’un développeur peut coordonner, tout en augmentant la quantité d’état qui doit rester fiable.

Le principal adversaire n’est plus un moteur d’autocomplétion particulier. C’est le flux de travail plus simple à session unique, dans lequel un assistant travaille dans un seul checkout sous supervision directe.

Cet ancien modèle présente des limites évidentes. Il évolue mal lorsqu’un développeur souhaite mener simultanément des investigations, de l’implémentation, des tests et de la documentation.

Il possède aussi un avantage majeur : l’état du système est plus facile à comprendre. Le développeur voit la branche active, le répertoire courant, la commande en cours d’exécution et la conversation immédiate.

OpenAI Codex 0.154.0 échange une partie de cette simplicité contre de la concurrence. Les worktrees, forks, services en arrière-plan, catalogues de modèles, réponses mises en file d’attente et sessions reprenables créent un système de coordination plus puissant.

Chaque couche supplémentaire peut échouer indépendamment. La conversation peut reprendre alors que son checkout manque, ou un checkout peut survivre après que son fil est devenu non pertinent.

Une réponse mise en file d’attente peut arriver après un changement de situation. Un daemon partagé peut exécuter une version plus récente que celle attendue par un client.

La disponibilité des modèles peut également différer selon le compte, le fournisseur, la région et le catalogue. La présence de GPT-6-Astra dans un sélecteur ne garantit pas un accès identique dans chaque installation.

De récents signalements publics illustrent l’incertitude entourant les premières fonctionnalités de modèles et de contexte. Un utilisateur a documenté des échecs de l’endpoint de contexte tandis que les requêtes de modèle ordinaires continuaient de fonctionner.

Ce signalement concernait une configuration expérimentale et incluait des paramètres de catalogue personnalisés. Il n’établit pas un défaut universel de Codex.

Il montre pourquoi le statut de sortie, la réponse du modèle et l’apparence de l’interface ne suffisent pas comme seuls signaux de réussite. Une tâche peut se poursuivre alors qu’une opération auxiliaire de gestion d’état échoue.

Un autre signalement public décrivait un comportement incohérent de GPT-6-Astra durant certaines sessions. Ces signalements sont des observations d’utilisateurs, et non des évaluations contrôlées ; ils ne doivent pas définir la qualité générale du modèle.

Ils fournissent néanmoins des tests de résistance utiles. Un modèle plus rapide ou plus capable apporte une valeur limitée lorsqu’une session de longue durée se termine prématurément ou signale à tort un travail inachevé.

OpenAI doit donc rendre l’orchestration observable. Les utilisateurs doivent savoir quel modèle a été exécuté, quel checkout a changé, quelle question reste en attente et quelle opération en arrière-plan a échoué.

Une équipe de production a également besoin d’une piste d’audit. Il devrait être possible de relier un correctif à son fil d’origine, à ses commandes, approbations, résultats de tests et décisions humaines.

Les worktrees peuvent améliorer cette traçabilité lorsqu’ils sont utilisés avec soin. Le diff de chaque session reste isolé jusqu’à ce qu’un développeur choisisse de le fusionner.

Ils peuvent aussi disperser le contexte sur de nombreuses branches abandonnées. Sans règles de nommage ni pratiques de nettoyage, l’isolation devient du désordre.

La même tension s’applique aux serveurs en arrière-plan. Les processus partagés simplifient la reconnexion et l’utilisation des ressources, mais ils rendent l’état invisible plus important.

Les acheteurs en entreprise jugeront la fonctionnalité à travers les contrôles de politique, les diagnostics, l’authentification et le comportement de récupération. Un daemon adapté aux développeurs n’est pas automatiquement un service prêt pour l’entreprise.

Les concurrents font face au même compromis. GitHub peut connecter étroitement un agent aux dépôts, pull requests et infrastructures de développement hébergées.

Anthropic peut se concentrer sur le raisonnement dans le terminal et l’utilisation directe d’outils. Les éditeurs d’IDE peuvent intégrer des agents aux éditeurs, débogueurs et systèmes d’intelligence du code.

La réponse d’OpenAI dans cette version est une coordination de sessions plus large. L’entreprise relie la sélection de modèles, l’exécution locale, les questions, les checkouts et les services persistants.

Cette approche devient défendable si les composants se comportent comme un système compréhensible. Elle devient fragile si les utilisateurs doivent diagnostiquer chaque couche séparément.

OpenAI ne devrait pas mesurer le succès uniquement au nombre de tâches simultanées. La mesure plus pertinente est la fréquence à laquelle les développeurs peuvent examiner, reprendre et fusionner ces tâches sans reconstruire un contexte perdu.

Pour les utilisateurs, le chemin d’adoption le plus sûr est progressif. Activez les worktrees sur un dépôt doté de tests solides et examinez les branches générées avant d’élargir l’utilisation.

Vérifiez que les reprises rouvrent le checkout attendu. Confirmez que les sessions arrêtées laissent des changements récupérables et que les worktrees abandonnés peuvent être identifiés.

Sous Windows, inspectez le comportement du daemon lors des mises à jour, redémarrages et avec plusieurs clients. Les équipes doivent aussi vérifier la journalisation et l’héritage des autorisations avant de standardiser le service.

Lors de l’utilisation de questions intégrées, distinguez les préférences courantes des décisions d’approbation. Une option suggérée ne devrait jamais contourner la revue pour des actions destructrices ou visibles de l’extérieur.

Cette version mérite de l’attention parce qu’elle s’attaque directement au problème de coordination. Son succès dépend moins de sa nouveauté que de la fiabilité de l’état pendant les journées de développement ordinaires et désordonnées.

Ce qu’il faut surveiller après OpenAI Codex 0.154.0

Les prochains tests concernent la durabilité des worktrees, la fiabilité d’Astra et le contrôle de l’entreprise sur le service en arrière-plan.

D’abord, observez comment OpenAI fait évoluer le nettoyage et la récupération des worktrees. La prudence actuelle autour du nettoyage automatique protège le code inachevé, mais peut laisser subsister un état de dépôt durable.

Un système plus robuste aiderait les utilisateurs à distinguer les worktrees actifs, reprenables, terminés et abandonnés. Il devrait préserver les changements non commités tout en rendant les décisions de suppression compréhensibles.

Des preuves de restauration fiable renforceraient l’affirmation centrale de cette version. Des signalements de sessions détachées, de répertoires manquants ou de propriété ambiguë l’affaibliraient.

Ensuite, surveillez les performances de GPT-6-Astra dans les catalogues Codex et Amazon Bedrock pris en charge. La disponibilité n’est que la première étape.

Les développeurs compareront la qualité d’exécution, la durée des tâches, l’utilisation des outils, le comportement face aux interruptions et les limites d’utilisation avec d’autres modèles disponibles. Un comportement cohérent importe davantage que la position dans le sélecteur.

OpenAI devra aussi maintenir les indications sur les modèles synchronisées avec les fonctionnalités du client. Les correctifs de la version 0.153 ont montré que les outils asynchrones et la visibilité des catalogues peuvent nécessiter des corrections rapides.

Des informations de compatibilité claires aideraient les utilisateurs à comprendre quelles combinaisons prennent en charge les questions structurées, la gestion du contexte et d’autres fonctionnalités de session.

Troisièmement, surveillez le bilan opérationnel du daemon Windows. L’infrastructure partagée en arrière-plan ne devient précieuse que si les mises à jour, redémarrages, authentification et connexions multi-clients restent prévisibles.

Une documentation de déploiement en entreprise constituerait un signal significatif. Les administrateurs ont besoin de contrôles pour la gestion du cycle de vie, les diagnostics, la conservation des données et les autorisations.

La question plus large est de savoir si Codex peut faire en sorte que l’action parallèle des agents paraisse maîtrisée. OpenAI Codex 0.154.0 fournit de nombreux éléments nécessaires, mais les dépôts réels mettront leurs connexions à l’épreuve.

Les développeurs devraient essayer une tâche isolée, examiner le checkout résultant, la reprendre et vérifier chaque transition d’état. Ils pourront ensuite déterminer si les sessions parallèles réduisent le travail de coordination ou le déplacent simplement.

Ce jugement devrait guider l’adoption au cours des prochaines versions. Si Codex préserve le contexte aussi fiablement qu’il génère de l’activité, la CLI deviendra un espace de travail crédible pour l’ingénierie parallèle. Sinon, le modèle plus simple à session unique restera l’option la plus sûre par défaut.