Guide des fonctionnalités de la version 3.11 de Cursor : la discussion latérale ne coupe pas la fenêtre principale, Cmd+K pour revenir aux anciens échanges

Cette page vous permet de maîtriser trois nouvelles fonctionnalités de Cursor 3.11 en une seule fois : ouvrir la conversation latérale pour poser des questions sans interrompre le Agent principal, parcourir des milliers d’anciennes conversations locales avec Cmd+K, puis utiliser des Hooks pour intervenir et surveiller les sous Agents aux nœuds clés. Vous trouverez un exemple complet de hooks.json prêt à exécuter, ainsi qu’un piège que l’on risque de rencontrer avec un Agent en cloud.
(Contexte : la société SpaceXAI, détenue par Musk, a officiellement lancé le modèle le plus puissant « Grok 4.5 » ! En partenariat avec Cursor, ils attaquent fort l’AI en tant que codage d’agents, avec une intégration parfaite des logiciels bureautiques Office.)
(Ajout de contexte : Cursor Mobile est lancé : une appli dédiée pour piloter plus facilement l’écriture de code AI depuis votre téléphone, et superviser la production)

Table des matières

Toggle

• Plan de l’article
• La conversation latérale fait que le Agent principal ne s’arrête pas : ouvrir une autre conversation qui hérite du context
• Rechercher avec Cmd+K des milliers d’anciennes conversations locales, Cmd+F pour trouver la conversation en cours
  • Rechercher toutes les anciennes conversations : dans Agents Window, appuyez sur Cmd+K
  • Rechercher cette conversation : appuyez sur Cmd+F
• Hooks d’Agents cloud : vous pouvez intervenir aux nœuds clés, surveiller et contrôler les sous Agents
  • Comment écrire et où placer hooks.json
  • Pour bloquer une action, seuls deux nœuds les reconnaissent
  • Les pièges de l’Agent en cloud
• Faire fonctionner les trois fonctionnalités ensemble
• Annexe : ressources complémentaires
• Questions fréquentes

Le Agent principal est en train de réaliser une grosse refonte, et soudain vous voulez vérifier si une fonction est appelée ailleurs. Avant, il fallait soit l’arrêter, soit changer de tâche, soit interrompre le travail en cours. Les trois fonctionnalités ajoutées par Cursor 3.11 (publié le 10 juillet 2026) — conversation latérale, recherche de conversations, Hooks d’Agents cloud — résolvent justement le problème : « je ne veux pas interrompre la ligne principale ».

Cet article suppose que vous utilisez déjà les Agents de Cursor. Il vous guide pour prendre en main les trois nouvelles fonctionnalités, avec un exemple de hooks.json et un piège que l’on peut facilement rencontrer avec un Agent en cloud.

Plan de l’article

• Conversation latérale : le Agent principal ne s’arrête pas, ouvrir une conversation qui hérite du context pour poser des questions
• Recherche de conversations : Cmd+K pour parcourir des milliers d’anciennes conversations locales, Cmd+F pour trouver la conversation en cours
• Hooks d’Agent cloud : intervenir à des nœuds comme la soumission de prompt, la réponse, le démarrage des sous Agents
• Comment relier les trois fonctionnalités, et les pièges des Hooks cloud

La conversation latérale permet de ne pas arrêter le Agent principal et d’ouvrir une conversation qui hérite du context

La conversation latérale (side chat) résout un scénario très précis : quand le Agent principal exécute une tâche longue, vous voulez dévier pour poser une question, mais sans l’interrompre.

Il y a trois façons d’ouvrir une conversation latérale ; choisissez celle qui vous paraît la plus simple :

2. Commande : dans la zone de chat, saisissez /side ou /btw
3. Bouton : appuyez sur le bouton + en haut du panneau de chat

La conversation latérale ouverte hérite directement du context de la conversation principale (contexte), donc vous n’avez pas besoin de recopier le background : il sait déjà ce sur quoi vous travailliez.

Le point le plus facile à mal comprendre : par défaut, la conversation latérale ne fait que trois choses — lecture, recherche et réponse — et ne modifie pas votre code. Son rôle est de vous permettre de poser des questions de suivi, de consulter des informations, d’explorer une autre voie, ou de faire un sanity-check (vérification rapide) avant d’agir. Pendant ce temps, le Agent principal continue sans être affecté. Si vous voulez qu’il modifie vraiment quelque chose, il faut le dire clairement dans la conversation.

Chaque conversation latérale correspond à un dialogue complet et conservé à long terme avec l’agent, ce n’est pas une simple question puis terminé. Vous pouvez y revenir plus tard, continuer à poser des questions. Quand vous trouvez une conclusion utile, utilisez @ pour ramener cette conversation latérale vers la conversation principale : le context se ré-attachera alors à la ligne principale.

De mon expérience, l’endroit le plus utile pour la conversation latérale n’est pas « qu’est-ce que c’est », mais plutôt : « le Agent principal prévoit de faire une modification comme ça, mais je pense que ça touchera X ; tu peux vérifier si X est aussi utilisé ailleurs ». La ligne principale avance, vous vérifiez sur le côté : les deux lignes ne se bloquent pas.

Rechercher avec Cmd+K des milliers d’anciennes conversations locales, Cmd+F pour la conversation en cours

Avant, pour retrouver « la façon dont il a résolu ce bug dans la conversation Agent de la semaine dernière », on ne pouvait compter que sur le nom de la conversation ou le numéro de PR, ce qui était pénible. La version 3.11 intègre une recherche, et en deux niveaux.

Rechercher dans toutes les anciennes conversations : dans Agents Window, appuyez sur Cmd+K

Dans Agents Window (la fenêtre de dialogue de l’agent), appuyez sur Cmd+K pour afficher la palette de commandes, puis lancez une recherche directement dans le contenu des conversations Agent (transcript), pas seulement le nom et le numéro de PR. Cursor crée un index de recherche local sur votre machine, donc même si vous avez accumulé plusieurs milliers de conversations, la recherche reste rapide.

Comme l’index est construit localement, le contenu n’est pas téléversé sur le cloud pour être recherché : c’est rassurant pour ceux qui accordent de l’importance à la confidentialité.

Rechercher la conversation en cours : appuyez sur Cmd+F

Si vous voulez juste trouver un passage dans la longue conversation que vous êtes en train de lire, utilisez Cmd+F. Il vous affiche un match counter (compteur du nombre d’occurrences), vous permettant de sauter d’un passage correspondant à l’autre ; en même temps, si votre transcript est long et que vous le faites défiler vers le bas, il peut continuer à chercher.

À noter : juste après la mise à niveau, l’index a besoin d’un peu de temps pour se construire. Si vous constatez que d’anciennes conversations ne sont pas trouvées pendant un moment, ou que l’historique semble vide, attendez la fin de la construction de l’index : c’est généralement un problème de délai, pas une perte de données.

Hooks d’Agent cloud : intervenir aux nœuds clés pour surveiller et contrôler les sous Agents

Les Hooks (crochets) sont la mise à jour la plus importante pour les développeurs de cette fois. Ils vous permettent d’accrocher vos propres scripts aux nœuds clés d’une conversation Agent : quand l’agent atteint ce nœud, votre script se déclenche automatiquement.

Les nœuds ajoutés dans 3.11 couvrent plusieurs moments clés dans un cycle de conversation d’Agent :

• beforeSubmitPrompt : vous soumettez le prompt, mais la requête n’a pas encore été envoyée au backend
• afterAgentResponse : après qu’Agent a terminé une réponse
• afterAgentThought : après la fin d’une pensée (thinking)
• subagentStart : juste avant de créer un sous Agent (outil de tâche)
• subagentStop : le sous Agent a fini de tourner
• stop : quand la boucle complète de l’Agent se termine et que la tâche s’arrête

Avec ces nœuds, vous pouvez faire trois choses : surveiller tout le processus d’exécution, contrôler les sous Agents avant et après leur démarrage, et construire une boucle d’auto-correction (self-correcting). Par exemple : après que l’Agent a fini sa réponse, il lance automatiquement un test ; s’il échoue, l’erreur est renvoyée pour qu’il la corrige lui-même.

Comment écrire hooks.json et où le placer

La configuration des Hooks se fait dans hooks.json, et le champ version est fixe à 1. Il y a trois emplacements possibles : tant que le fichier existe, il sera exécuté :

• Niveau projet : /.cursor/hooks.json
• Niveau global utilisateur : ~/.cursor/hooks.json
• Niveau entreprise : /etc/cursor/hooks.json

Un exemple minimum opérationnel : il fait deux choses — à chaque fois qu’Agent modifie un fichier, il lance un script d’audit, et quand la tâche s’arrête, il enregistre un enregistrement :

{
  "version": 1,
  "hooks": {
    "afterFileEdit": [
      { "command": "./hooks/audit.sh" }
    ],
    "stop": [
      { "command": "./hooks/on-stop.sh" }
    ]
  }
}

Le chemin dans command est relatif à l’emplacement de hooks.json. Vos scripts reçoivent une portion de JSON depuis stdin (entrée standard) : il contient des champs de base comme conversation_id, generation_id, model, hook_event_name, ainsi que des champs liés au nœud concerné. Par exemple, beforeSubmitPrompt contient le prompt, afterAgentResponse contient le texte de la réponse.

Un script qui ne fait rien d’autre, juste vérifier qu’il reçoit les données, ressemble à ceci :

#!/bin/bash
cat > /dev/null   # lire stdin
exit 0            # signaler la réussite

Pour bloquer une action, seuls deux nœuds le permettent

Voici un piège facile à rencontrer : tous les hooks ne peuvent pas bloquer une action. Seuls beforeShellExecution (avant l’exécution d’une commande shell) et beforeMCPExecution (avant l’appel d’un outil MCP) peuvent décider d’autoriser ou non, en fonction du JSON renvoyé par stdout (sortie standard) :

{
  "continue": true,
  "permission": "allow",
  "userMessage": "message affiché pour vous",
  "agentMessage": "message affiché pour l’AI"
}

permission : mettez allow pour autoriser, deny pour bloquer, ask pour déclencher une demande de confirmation. Pour les autres nœuds, comme afterAgentResponse : même si vous renvoyez permission, ils l’ignorent. Ils peuvent seulement observer, enregistrer et déclencher d’autres actions : ils ne peuvent pas bloquer.

Pièges de l’Agent Agent cloud

Si vous utilisez Hooks avec un Agent en cloud (cloud agent), un nœud devient directement inefficace : beforeSubmitPrompt. La raison est très concrète : ce hook est attaché au cycle de vie au tout début de la session, mais la machine virtuelle (VM) du cloud n’est créée qu’après le démarrage de la session. Au tout début, la machine n’existe pas encore, donc rien ne peut exécuter ce hook.

D’après mon expérience : si vous utilisez le cloud, choisissez plutôt des nœuds attachés à « avant/après l’exécution d’outils », comme beforeShellExecution, afterFileEdit, subagentStart, subagentStop, stop. Ceux-là sont plus stables. Évitez d’en attacher à des moments de « démarrage de session ».

Relier les trois fonctionnalités ensemble

Les trois fonctionnalités sont expliquées séparément, mais vous devez les tester pour sentir comment elles s’assemblent. Exemple concret :

Le Agent principal exécute une refonte qui s’étend sur plusieurs fichiers. Vous ouvrez une conversation latérale (/side) pour vérifier « combien d’endroits utilisent vraiment cette interface », et la ligne principale continue. Une fois la vérification terminée, vous identifiez un risque : utilisez @ pour ramener les conclusions de la conversation latérale dans la conversation principale, et faites en sorte que le Agent principal traite ces endroits ensemble. En parallèle, dans votre hooks.json, vous avez accroché un nœud stop : quand la refonte se termine, il lance automatiquement des tests. Ensuite, utilisez Cmd+F pour revenir dans cette longue conversation et trouver quelles fonctions l’Agent dit avoir modifiées juste à ce moment-là.

Une fois le cycle terminé, vous n’avez pas été interrompu, et toutes vos actions prévues ont été faites.

Annexe : ressources complémentaires

• Changelog officiel de Cursor : détails complets de chaque version ; la conversation latérale et la recherche de conversation de la version 3.11 sont couvertes ici
• Fichier officiel des Cursor Hooks : tous les nœuds de hook, les champs stdin/stdout, et une référence complète sur le format de configuration
• Fichier des Cursor Subagents : quand vous utilisez subagentStart／subagentStop, vous pouvez d’abord consulter cet article

Questions fréquentes

Q1. La conversation latérale modifie-t-elle mon code ?
R : Non, par défaut. Elle ne fait que lecture, recherche et réponse. Son rôle est de vous permettre de vérifier et de poser des questions de suivi. Si vous voulez qu’elle modifie le code, il faut le dire explicitement dans la conversation.

Q2. Si je coupe la conversation latérale, elle disparaît ?
R : Non. Chaque conversation latérale conserve à long terme un dialogue complet avec l’agent. Vous pouvez y revenir plus tard, continuer à poser des questions, et vous pouvez aussi la ramener vers la conversation principale via @.

Q3. La recherche Cmd+K cherche du cloud ou du local ?
R : Localement. Cursor construit un index de recherche sur votre ordinateur ; le contenu n’est pas téléversé pour la recherche, et vous pouvez tenir jusqu’à plusieurs milliers de conversations rapidement.

Q4. Après la mise à niveau, je ne trouve pas les anciennes conversations, ou chat history est vide ?
R : Très probablement l’index local est encore en construction ; attendez qu’il ait fini, et regardez à nouveau : en général ce n’est pas une perte de données.

Q5. Quelles différences entre Hooks sur un Agent cloud et sur un Agent local ?
R : La plus grande différence : beforeSubmitPrompt ne fonctionne pas sur le cloud, car au moment où la session démarre, la VM cloud n’est pas encore créée. Les hooks attachés aux nœuds avant/après l’exécution d’outils — comme beforeShellExecution, afterFileEdit, subagentStart — sont plus fiables en cloud.

Q6. Où faut-il placer hooks.json pour qu’il prenne effet ?
R : Dans le .cursor/hooks.json du projet, dans le ~/.cursor/hooks.json global utilisateur, ou dans /etc/cursor/hooks.json au niveau entreprise. Les trois emplacements s’exécutent si le fichier existe.

Q7. Je veux que le hook bloque directement une commande dangereuse, est-ce possible ?
R : Oui, mais seulement deux nœuds le permettent : beforeShellExecution et beforeMCPExecution, qui acceptent la permission renvoyée via stdout. Si vous remplissez deny, l’action est bloquée. Les autres nœuds ne peuvent qu’observer et déclencher : ils ne peuvent pas bloquer.