Mergerie
Sommaire

Dev IA

Cette page est générée depuis docs/guide.fr.md · Modifier cette page sur GitLab

Une recherche en tête de liste (prompt, projet, branche, dossier) filtre les sessions du sous-onglet courant — utile dès qu'elles s'accumulent. Elle se remet à zéro quand on change de sous-onglet, pour ne pas contredire les compteurs qui affichent des totaux.

Les listes montrent en tête ce qui vient de finir de s'exécuter — et au-dessus de tout, ce qui tourne en ce moment. C'est la date de fin d'exécution qui décide, pas la dernière modification : corriger un prompt, pousser une branche ou ranger une session ne la fait pas remonter devant celle qui vient de tourner. Une session jamais lancée se range à sa date de création.

Deux sous-onglets. Dans les deux cas, une session porte sur un ou plusieurs projets, chacun avec sa propre branche, et sa date de création est affichée. Le choix du dépôt se fait au clavier (sélecteur avec recherche), comme celui des branches — utile quand la liste des dépôts est longue.

Ranger les sessions terminées. Une session finie se masque sans être supprimée ; une case « afficher les sessions masquées » (dont l'état est mémorisé) les fait revenir, et un compteur rappelle combien sont filtrées. Vaut pour le codage, le codage hors dépôt et l'exploration. Dans la liste, un prompt long est replié sur trois lignes avec un « Voir plus » qui le déroule entier.

« Planifier d'abord » : lire, approuver, puis coder. Cochée dans la modale de session (codage sur dépôt seulement), la première passe ne touche à rien : l'agent lit le dépôt et rend un plan — fichiers, étapes, risques, questions ouvertes — comme une itération marquée plan. La ligne du projet dit plan à approuver, propose Lire le plan, une remarque facultative (« garde l'API telle quelle ») et deux gestes — les mêmes dans la vue qu'ouvre Lire le plan, où le champ de retours remplace « Préparer un suivi » : on relit un plan pour le corriger ou l'approuver. Régénérer le plan avec mes retours renvoie tes retours à la même session, qui réécrit le plan complet en les intégrant, toujours sans coder : la ligne reste plan à approuver, avec une nouvelle itération plan — autant de tours qu'il faut. Approuver et coder : la même session reprend et réalise le plan, remarque comprise, puis commite comme d'habitude. Relancer une session planifiée replanifie de zéro. Avec Claude, la passe tourne dans son mode plan quoi que dise l'interrupteur sécurisé/yolo — c'est ce que la session demande, pas une restriction ; un autre backend suit la consigne, et la passe suivante repart de toute façon d'un clone propre.

« Stopper et reprendre avec cette consigne ». Pendant qu'une session tourne, le champ de suivi ne cache plus son bouton : il devient Stopper et reprendre avec cette consigne. La passe s'arrête, et la consigne repart en suivi — dans la même session d'agent quand son handle est connu (Claude le donne avant de dire un mot), sinon dans une session neuve qui reçoit la tâche et la transcription. La consigne reste en brouillon sur la carte tant que le suivi n'est pas parti.

Le journal reste court, l'annexe garde le reste. Le message d'un agent est coupé à 600 caractères dans le journal du job, un Edit tient sur une ligne — Edit src/x.js (+12 −3) — et la réflexion de l'agent s'affiche en une ligne ∴. Chacune porte un « … voir » qui ouvre le texte entier, ou le diff de la modification, dans un panneau ; le polling ne transporte jamais le contenu. Les jobs tournent en parallèle d'eux-mêmes quand ils touchent des dépôts ou des dossiers différents : une review sur le dépôt A ne retarde plus une session sur le dépôt B ; deux jobs sur le même dépôt gardent leur ordre, un job au périmètre inconnu attend tout le monde, et les jobs lancés à la main passent avant les automatiques.

« L'IA peut me poser des questions » vaut pour les trois saveurs. Codage sur dépôt, codage hors dépôt et exploration : cochée, l'option autorise l'agent à s'arrêter devant une décision qu'il ne peut pas trancher, au lieu de deviner. Une exploration hésite comme un codage — « de quel des trois services parles-tu ? » vaut mieux qu'une synthèse à côté du sujet —, et hors dépôt c'est là que ça compte le plus : l'agent travaille en place, sans branche ni commit à relire.

Ce qui se passe alors, dans les trois cas : la session passe en attente (ni finie, ni en échec), les questions s'affichent sur sa carte, on répond, et le travail reprend dans la même session — l'agent garde ce qu'il a lu. Deux différences à connaître : une exploration pose ses questions une seule fois pour tous ses dépôts (ils partagent la session), alors qu'hors dépôt chaque dossier a la sienne, et répondre à l'un ne fait pas retravailler les autres. ⚠ Tant qu'une question tient, rien n'a été fait : pas de synthèse enregistrée en exploration, aucun fichier touché hors dépôt.

Et si c'est la session d'un collègue ? Reçue du dépôt de données partagé, elle se lit mais ne se relance pas d'ici : la ligne de son projet porte « Reprendre sur ce poste » — ou « Répondre et reprendre sur ce poste » quand sa cible attend une réponse. La modale s'ouvre pré-remplie et verrouillée sur l'essentiel (son dépôt, sa branche comme départ, une nouvelle branche proposée, tes réglages), un seul champ à remplir — ta consigne —, et un encart repliable montre en entier le premier message que ton agent recevra : tout l'historique de sa session, puis ta consigne. Voir Partager avec une équipe.

Et si tu as répondu dans ton terminal ? « Reprendre au terminal » copie la session d'agent : on peut donc répondre là-bas, et l'agent y poursuit le travail — dans le clone de Mergerie, qui n'en sait rien. Le bouton J'ai répondu au terminal, à côté de Répondre et reprendre, solde cette attente : les questions disparaissent, la todo se referme, et rien n'est relancé. L'état, lui, n'est pas deviné : sur une session de dépôt, Mergerie relit la branche (la même mécanique que Vérifier l'état des branches) — des commits d'avance et le projet repasse en commité ou poussé avec son diff, rien du tout et il revient à à faire. Hors dépôt, il n'y a ni branche ni commit à interroger : le dossier est rendu à l'état fait, et ce qu'il contient est ce que ton terminal en a fait. Sans ce geste, le projet restait en attente pour toujours, et le formulaire proposait de répondre une seconde fois — ce qui aurait relancé l'agent sur un travail déjà terminé.

Une session arrêtée sur une question pose sa todo. Quand l'IA s'interrompt pour demander quelque chose, une todo de priorité haute est créée automatiquement — « Répondre à l'IA — session #12 », avec les projets concernés en note. La file est libre, plus rien ne repartira, et la notification est fermée depuis longtemps : la todo, elle, reste sous les yeux dans Notes et dans le brief du matin. Répondre la referme (cochée, pas supprimée : ce qu'on a fait de sa journée se relit dans « Faites »).

⚠ Sur une session multi-dépôts, elle ne se referme que lorsque plus aucun projet n'attend : répondre au premier ne solde pas le travail, et une todo cochée trop tôt fait oublier les quatre autres. Elle reste une todo ordinaire — on peut la cocher, l'éditer, la supprimer : l'outil la pose et la referme, il ne reprend pas la main sur ce qu'on en a fait.

Dupliquer une session. Sur la carte, à côté de Modifier, un bouton ouvre le formulaire pré-rempli de la session — codage, exploration et codage hors dépôt. Il n'y a pas d'identifiant derrière : enregistrer crée une nouvelle session au lieu d'écraser celle qu'on copiait. C'est le geste de qui relance la même consigne sur un autre dépôt, ou repart d'une session passée en changeant deux mots. Tout se recopie — consigne, libellé, message de commit, dépôts ou dossiers, branche de départ, options, vérificateur — sauf ce qui suit, dit sous le prompt :

  • la session d'agent n'est jamais reprise : une copie démarre une conversation neuve, pas la suite de celle de l'originale ;
  • en codage, la branche de travail est décalée (feature/x → feature/x-2, puis -3 si elle est déjà prise) parce que deux sessions sur la même branche se marcheraient dessus, la seconde commitant par-dessus le travail de la première. En exploration, la branche est celle qu'on lit : elle se recopie telle quelle, la décaler pointerait vers une branche inexistante ;
  • les images attachées à l'originale ne sont pas copiées ; leur nombre est rappelé.

Les boutons sont ceux d'une création — Créer et lancer accompagné de Créer sans lancer, comme partout ailleurs : un bouton qui changerait de sens selon qu'on crée ou qu'on copie serait un piège. Tout reste modifiable avant d'enregistrer : c'est une proposition, pas un décalque.

Le formulaire raconte quatre choses, dans l'ordre. Il est le même pour les quatre saveurs et se réarrange selon celle qu'on crée — mais l'enchaînement ne change pas : où (les projets et leurs branches, ou le répertoire et ses dossiers — l'avertissement « l'IA modifie en place, sans commit » suit ce choix-là, pas la fin du formulaire), quoi (le ticket Jira qui remplit le prompt, le prompt, les pièces jointes, puis le libellé — facultatif, donc après ce qu'il résume), comment l'IA travaille (les questions, la reprise d'une session d'agent) et enfin une fois le code écrit (message de commit, auto-push, vérificateur) — le dernier groupe parce qu'il est chronologiquement le dernier, et il disparaît entier dès qu'il n'y a rien à commiter. Deux intertitres discrets séparent les trois derniers groupes ; une question libre n'en montre aucun, elle n'a que la demande.

Un libellé, facultatif. Un titre court à la création d'une session — codage, hors dépôt ou exploration. Une liste se lit sinon par son prompt, trois lignes repliées dont les premiers mots se ressemblent d'une session à l'autre ; le libellé dit de quoi il s'agit quand le prompt dit ce qu'il faut faire. Il s'affiche en tête de carte, entre dans la recherche, et se modifie après coup. Laissé vide, la carte est exactement ce qu'elle était.

⚠ Le libellé ne part PAS à l'IA, et ne sert pas de message de commit. C'est un titre de rangement, écrit pour l'humain qui parcourt la liste — pas une consigne. Le glisser dans le prompt changerait ce que l'agent produit sans que personne ne l'ait demandé, et deux sessions au même prompt mais au libellé différent ne rendraient plus la même chose. Un test le garde fermé, y compris contre un module qui se mettrait à le lire.

Le message de commit choisi vaut pour TOUS les commits de la session. Renseigné, le champ Message de commit est la règle : le premier run, chaque suivi, la reprise après questions et les passes de convergence commitent sous ce message. C'est ce qu'attend celui qui préfixe ses commits — une clé de ticket, une convention d'équipe : un suivi qui repartirait sur sa propre première ligne casserait la règle au moment précis où on ne relit pas, et le commit fautif est déjà poussé. Laissé vide, rien ne change : chaque geste garde son défaut, qui dit ce qu'il vient de faire (la première ligne du prompt pour le run, celle du suivi pour un suivi).

Et s'il est renseigné après coup — on lance, on voit passer un commit mal nommé, on remplit le champ, on relance —, le dernier commit est renommé : l'IA constate que tout est déjà fait et ne commite rien, donc sans ça le champ qu'on vient de remplir n'aurait rien à nommer. Seul le message change, le contenu du commit est intact et il n'y a pas de commit de plus. ⚠ Sauf si la branche est déjà sur origin : renommer un commit publié réécrirait une histoire que la forge — et peut-être une merge request, et peut-être un collègue — a déjà. Le journal du job le dit alors, plutôt que de se taire ou de le faire dans le dos.

Un suivi écrit pendant que ça tourne, envoyé quand tu le décides. La remarque vient en lisant ce que l'agent fait — pas vingt minutes plus tard, une fois la session finie et l'esprit ailleurs. Sur une session en cours, Préparer un suivi ouvre le même formulaire que Envoyer un suivi, avec Enregistrer le suivi au lieu d'Envoyer : le texte reste sur la carte, sous les yeux, tant qu'il n'est pas parti. On le corrige, on le supprime (l'effacer suffit), et Envoyer le suivi le lance en un geste une fois la session terminée. Vaut pour le codage, le codage hors dépôt et l'exploration.

Une pièce jointe se colle ou se choisit, dans le suivi comme à la création. Bouton Joindre un fichier ou Ctrl+V pour une capture. Une image montre sa vignette, un document sa puce nommée — et c'est la seule différence entre les deux : pour l'agent, une capture et un PDF sont la même chose, un fichier à ouvrir. Vaut pour les quatre saveurs : codage, codage hors dépôt, exploration et question libre. Sont acceptés les images, PDF, texte (.txt, .md, .log), données (.csv, .tsv, .json, .yml, .xml, .html) et documents Office (.docx, .xlsx, .pptx, .odt, .ods, .odp, .rtf), jusqu'à 10 Mo pièce. Le reste est refusé avec sa raison, avant que rien ne soit enregistré. La pièce accompagne cette demande-là : le prompt du suivi reçoit celles de la consigne initiale plus celle qu'on vient de joindre, mais pas celles d'un suivi précédent — elles illustraient autre chose, et un prompt qui annonce « voici les pièces jointes » en montrant la mauvaise envoie l'agent dans le décor. ⚠ Un suivi enregistré (brouillon) ne garde que le texte — c'est ce que sait stocker la base. Les pièces restent attachées au formulaire ouvert et partent avec l'envoi ; un message le rappelle au moment d'enregistrer, plutôt que de les faire disparaître en silence. Rouvrir une session montre ce qui y est vraiment joint. Le formulaire d'édition n'affiche pas un compte (« 2 captures jointes ») mais les pièces elles-mêmes — vignette pour une image, nom pour un document — ouvrables d'un clic et retirables d'une croix, dans les quatre saveurs. Retirer supprime le fichier du disque : c'est irréversible, donc c'est confirmé. Une pièce arrivée avec un suivi est montrée en pointillés : elle n'appartient pas à la consigne qu'on est en train de modifier.

⚠ Le NOM d'origine accompagne le fichier dans le prompt (« devis-client.pdf »), parce que pj_2.pdf n'apprend rien à l'agent. Sur disque, en revanche, le fichier porte un nom fabriqué : un nom venu d'un formulaire n'a rien à faire dans un chemin. Et ce que l'agent sait lire dépend de lui : un .txt ou un .csv sont sûrs, un .xlsx beaucoup moins — Mergerie fournit le fichier, il ne le convertit pas.

Ou il part tout seul, si tu le demandes. Une case L'envoyer automatiquement à la fin de la session, sous le texte, arme le suivi : il partira dès que la session aura fini de travailler, sans que tu aies à revenir. La carte le dit — Suivi armé au lieu de Suivi en attente — et il ne part qu'une fois : le texte est retiré et la case désarmée avant le lancement, sinon la passe de suivi retrouverait la même consigne en finissant et la session tournerait en boucle. Rien ne part non plus après un échec, ni sur une session qui attend une réponse.

⚠ Décochée, la case ne fait rien — et c'est le défaut. Le bouton d'envoi reste désactivé tant que la session tourne, et un suivi non armé attend indéfiniment ton geste. Un envoi automatique est un choix qu'on pose en écrivant la remarque, jamais un effet de bord : la colonne n'est lue que par la fonction qui décide d'envoyer, et aucun module parlant à l'agent ne la connaît — deux tests le gardent fermé. Si tu as choisi un vérificateur, il attend la fin du suivi automatique : un verdict rendu sur du code qui va encore changer ne vaudrait rien.

Relancer demande confirmation. Sur une session qui a déjà tourné, Relancer ouvre une confirmation qui dit ce qui va se passer : l'IA repart du prompt initial, sur le travail déjà produit, et ce qui a été demandé depuis — suivis, réponses aux questions — n'est pas rejoué. Le bouton voisine avec ceux dont on se sert tout le temps, et le clic de trop coûte une session entière. La toute première mise en route, elle, reste un seul clic : il n'y a rien à protéger. Vaut aussi pour le Relancer d'un projet en particulier.

La case est en vue, « Avancé » est replié. « L'IA peut me poser des questions » a quitté l'accordéon Avancé : c'est une décision prise pour chaque session, pas un réglage à aller chercher — elle est au-dessus de « Lancer plus tard », dans les formulaires de codage, d'exploration et hors dépôt. L'accordéon (message de commit, session d'agent à reprendre, skills) s'ouvre replié pour que le formulaire tienne à l'écran ; un clic le déplie, et l'édition d'une session le déplie d'elle-même quand un de ses champs porte une valeur.

Créer maintenant, lancer plus tard. Les quatre saveurs de session — codage, codage hors dépôt, exploration, question libre — et les sessions ouvertes depuis une merge request portent les deux mêmes boutons : Créer et lancer (le geste principal, en un clic) et Créer sans lancer à côté, pour préparer le prompt et les cibles et lancer quand on veut.

Lancer plus tard, le. La même modale — codage, exploration, hors dépôt — porte un champ date et un champ heure côte à côte, chacun avec son sélecteur natif (calendrier, horloge) et toujours saisissables à la main ; n'en remplir qu'un est signalé sous celui qui manque. Remplis, le bouton principal devient Créer et programmer : la session est créée et attend, sa carte montre la date avec une croix pour l'annuler, et l'éditer montre la date et l'enregistre avec le reste. Un suivi en attente se programme de même (« Ou l'envoyer le ») : il part tout seul à ce moment, que la case « automatiquement à la fin » soit cochée ou non — un suivi a un déclencheur, jamais deux. Lancer à la main annule la date, une date déjà passée est refusée, et la date est celle du poste qui l'a posée : c'est lui qui lance, et il rattrape à la minute suivante s'il était éteint à l'heure dite. Les questions libres ne se programment pas.

Vérifier après, sans y penser. Un champ facultatif Vérifier après à la création d'une session de codage : le vérificateur choisi part tout seul, une fois, à la fin — après la convergence si tu converges, après le codage sinon. On lance la session le matin, on trouve un verdict, pas une case à cocher de plus.

Seuls les vérificateurs qui couvrent tous les dépôts de la session sont proposés : un vert partiel ne dirait rien de la moitié du lot, ce qui est pire qu'une absence de verdict. La liste se refait quand tu changes de projets.

Un vérificateur lit ce que la forge expose : il lui faut donc du code poussé. Choisir un vérificateur coche l'auto-push et le dit ; décocher l'auto-push retire le vérificateur. Le serveur applique la même règle de son côté — un écran n'est pas un garde-fou, et l'API est appelable sans lui.

Trois refus, silencieux pour la session mais écrits dans son journal : rien n'a été poussé, le vérificateur ne couvre plus tous les dépôts, ou une autre vérification tourne déjà sur ces dépôts. Et un échec au lancement de la vérification ne fait pas échouer la session : le code est écrit et poussé, annoncer une erreur mentirait sur ce qui s'est passé.

Reprendre une session d'agent existante. Un champ facultatif « identifiant de session » à la création (codage, hors dépôt, exploration) fait travailler l'IA dans cette session-là au lieu d'en ouvrir une nouvelle — elle garde donc tout le contexte déjà acquis. Renseigné, il rend aussi disponible le bouton « Reprendre au terminal ». Le champ est également modifiable après coup.

⚠ L'identifiant SUIT les passes. Reprendre une session d'agent n'en poursuit pas toujours l'identifiant : claude --resume en ouvre un nouveau, qui porte l'échange entier plus le tour qu'on vient de faire. Mergerie enregistre donc, après chaque passe, celui que l'agent annonce — sinon deux suivis d'affilée sur le même projet repartiraient tous deux de l'état initial, et le second ignorerait le premier. C'est aussi ce qui fait que « Reprendre au terminal » ouvre la conversation telle qu'elle est, et non son état d'il y a trois suivis.

Enrichir depuis un ticket Jira (optionnel). Si Jira est configuré (Réglages → Jira), la modale propose un champ ticket qui liste tes tickets affectés à la frappe — en choisir un pose la clé et récupère le ticket — ou une clé tapée à la main suivie de Récupérer : le titre + la description du ticket sont récupérés via l'API Jira et ajoutés en tête du prompt comme bloc de contexte — visible et éditable avant de lancer. Le numéro est pré-rempli si la branche de travail contient déjà une clé (ex. feature/PROJ-1234-…). Disponible pour le codage et l'exploration.

  • Codage — l'IA modifie le code. Pour chaque projet : branche de travail, et branche de départ facultative (liste déroulante avec recherche ; vide = branche par défaut du dépôt). Le prompt est appliqué à chaque projet, séquentiellement — un projet en échec n'interrompt pas les autres. Chaque projet a ensuite ses propres actions : Voir le diff · Pousser · Créer la MR · Merger. La ligne offre aussi Reviewer dès que la merge request existe et n'a pas encore de rapport — le geste suivant évident, qui demandait d'aller le chercher dans Reviews — et Reprendre la console quand un job Jenkins lié est rouge sur cette branche : le suivi se remplit des trente dernières lignes de console et du numéro de build, comme Reprendre le rapport de vérif. Le verdict reste celui de Jenkins ; l'agent ne reçoit que le texte à corriger. Une fois la merge request ouverte, la ligne du projet dit ce qu'elle est devenue — note, verdict, commentaires en attente — au lieu d'un MR !216 ↗ qui renvoyait dans Reviews, et Prévenir Jira commente le ticket avec le lien de la MR puis le passe en revue quand Jira propose la transition, derrière une confirmation qui nomme le ticket. Une case de la modale de session, décochée par défaut, le fait à chaque création de merge request — son défaut, avec le gabarit du commentaire ({url} {iid} {project} {title} {branch} {target} {key}, aperçu en direct), se règle dans Réglages → Jira. Voir le diff ouvre le même explorateur plein écran que celui des merge requests — arborescence complète du projet au milieu, fichier entier avec les changements en place à droite (navigation d'un changement à l'autre, mini-carte) — avec, à gauche, le retour de l'IA au lieu du rapport de revue. On lit donc ce que l'IA dit avoir fait et ce qu'elle a réellement écrit, côte à côte, dans le contexte du fichier entier plutôt que dans un patch brut. Un fil d'étape compact (pastilles créée → commit → push → MR) sur chaque ligne situe d'un coup d'œil où en est le projet — utile sur une session multi-projets. Envoyer un suivi poursuit la session sur les branches existantes, sans repartir de zéro — une correction, une précision, une question sur ce qui vient d'être fait : l'IA garde tout le contexte du travail déjà produit (idem pour une relance de la session). Sur une session multi-dépôts, chaque projet porte son propre bouton : une remarque ne vaut presque jamais pour les cinq dépôts (« utilise plutôt AbortController ici » ne veut rien dire ailleurs), et l'envoyer à toute la session coûte un appel IA par dépôt pour refaire du travail déjà bon. Le bouton de la carte, lui, s'adresse toujours à tous. Une exploration répond d'un seul tenant : elle ne se restreint pas à un dépôt. À la fin du codage, Retour de l'IA affiche ce que l'agent dit avoir fait (comme la réponse d'une exploration) — utile pour comprendre son travail, ou quand rien n'a changé : si le prompt était incomplet et que l'IA a répondu au lieu de coder (ex. « donne-moi le nom du fichier »), sa réponse est remontée directement dans l'erreur du projet plutôt qu'un « aucun changement » opaque. En revanche, si la branche porte déjà le travail — cas d'une relance après un échec survenu après le commit, un push refusé par exemple —, l'absence de nouveau changement n'est pas une erreur : la session reprend son état « commit prêt », avec le diff et le bouton de création de MR. Un projet arrêté sans avoir codé — l'IA qui demande en clair « je continue sur le lot suivant ? », sans question structurée — garde son bouton Envoyer un suivi tant que sa session d'agent est vivante : c'est le seul geste qui répond à cette pause. Les boutons de remède d'une erreur (« Rattraper la base et réessayer », « Résoudre le conflit », « Repartir d'une session d'agent neuve », « Re-cloner le dépôt ») s'expliquent au survol.
  • Ce que le dépôt choisi porte déjà. Dès qu'un dépôt est choisi dans la modale de session, une ligne grise sous le sélecteur dit N MR ouvertes sur ce dépôt ; si la session repart de la branche d'une merge request existante, ses croisements ; et quand le prompt cite un chemin qui existe dans le clone (src/payment/, tva.js), la ligne devient 2 MR ouvertes touchent src/payment/ (!214, !219). Information seulement : rien n'est bloqué, la session se lance quand même. Quand la session repart de la branche d'une merge request ouverte, la ligne dit aussi La branche créée contiendra !214 (ouverte, à traiter) — on le sait avant de commencer, et on choisit la cible en connaissance de cause.
  • Combien de tests la branche modifie. Dès qu'un projet de session est commité, sa ligne porte 0 test modifié (accentué) ou 3 tests modifiés (discret), d'après le diff de la branche et les motifs de test du dépôt — avant que la merge request n'existe, quand un suivi « ajoute les tests » coûte le moins. Une session qui ne fait que remonter un sous-module n'a touché aucun code : rien. Hors dépôt : rien.
  • Quelles dépendances la branche ajoute. Sur la même ligne, 2 dépendances ajoutées (accentué) ou 1 dépendance changée (discret), lues dans les manifestes du diff de la branche — c'est là qu'un suivi « enlève left-pad, écris la fonction » coûte le moins. Le détail est sur la carte de la merge request. Contrôle au registre coché, la ligne se complète au rendu suivant — 2 dépendances ajoutées · 1 inconnue — sous le même cache que les cartes, dix noms au plus par session.
  • Projets liés en lecture seule (Avancé). En codage, la modale de session propose d'ajouter d'autres dépôts comme contexte : l'IA les consulte — leur API, leur schéma, leurs contrats — pour respecter ce qu'ils exposent, sans jamais les modifier. Un dépôt (recherche incluse, comme partout où l'on choisit un projet) et une branche facultative (vide = branche par défaut du dépôt). Montés en symlink sous ai-dev-tools-internal/context/ le temps de la passe, remis à zéro après — même dispositif que les projets liés d'une review. Un dépôt déjà cible du codage dans cette même session ne peut pas être aussi lié en lecture seule. Facultatif — l'exploration n'en a pas l'usage, elle voit déjà tous ses dépôts côte à côte.
  • Activité — ce que tu as lancé, et ce qui s'est terminé. Le panneau de log expose une vue Activité : ce qui a tourné, sur quoi, combien de temps, et comment ça s'est fini — une vérification finie se lit par son verdict (vert ✓, rouge ✗, base déjà rouge, échec), jamais « ok » devant une batterie cassée, et Échecs seulement la garde quand elle est rouge ; le bandeau du journal et le bouton de pied de page la disent en rouge de même. Chaque ligne nomme son objet et y mène en un clic ; un bouton rouvre le journal d'un job passé — la vue y reste tant qu'un autre job écrit, et un job lancé ensuite la reprend. Ce qui s'est terminé depuis ta dernière visite est marqué, et le compte s'affiche sur le bouton. Le bouton « journal » du pied de page dit aussi l'état du job derrière un panneau replié : ambre et pulsant tant qu'il tourne, vert quand c'est fini, rouge en échec — replié, il avait la même tête qu'un job encore au travail ou fini depuis longtemps. Les notifications bureau ne répondaient pas à cette question : elles ne vivent qu'en mémoire du serveur et ne sont volontairement pas rejouées au chargement — donc tout ce qui finissait onglet fermé n'existait nulle part.
  • La liste des projets s'ouvre repliée. Au-delà de quelques dépôts, une session occupait tout l'écran et masquait les autres — qui sont pourtant ce qu'on est venu regarder. Un « Voir les N projets » la déplie, et l'état est mémorisé par session : sinon le rafraîchissement automatique la refermerait toutes les secondes et demie pendant un job. Vaut pour les trois familles (codage, codage hors dépôt, exploration).
  • Pousser tous · Créer toutes les MR. Deux actions groupées, qui n'apparaissent que lorsqu'elles ont quelque chose à faire (le nombre concerné est dans le libellé). Pousser tous pousse en un seul job toutes les branches commitées mais pas encore poussées. Créer toutes les MR ouvre une merge request pour chaque projet poussé qui n'en a pas : la modale demande les options une fois — squash, suppression de la branche source — et chaque MR reprend le message de commit de la session comme titre, plutôt que de réclamer dix titres à la suite. Dans les deux cas, un projet en échec n'interrompt pas les autres et le bilan nomme ceux qui ont échoué.
  • Lancer un projet à la fois. Sur une session multi-dépôts, chaque projet porte son propre bouton Lancer, et une session comptant plusieurs échecs propose Relancer les projets en échec. Auparavant une session ne se relançait qu'en bloc : sur dix dépôts dont six avaient réussi, cela coûtait six appels IA pour refaire un travail bon, et faisait repasser l'agent sur du code qu'on ne voulait plus voir modifier. Une passe ciblée ne réserve que ses dépôts, donc deux projets d'une même session sur des dépôts distincts peuvent tourner en parallèle. Relancer la session entière reste à un clic — rien n'est devenu implicite.
  • Vérifier l'état des branches — réparer sans dépenser d'appel IA. Quand des projets sont restés en erreur alors que leur travail est déjà commité, un bouton sur la session relit l'état réel de chaque branche : si elle porte des commits, le diff est régénéré et le projet repasse « commit prêt » (ou « poussée »), bouton de création de MR compris. Rien n'est maquillé — une branche réellement vide reste en erreur, avec son message. Relancer la session réparerait la même chose, mais au prix d'un appel IA par dépôt pour refaire un travail déjà fait. Le bouton n'apparaît que s'il y a au moins un projet en erreur, et l'opération passe par la file de jobs : toucher un clone pendant qu'un agent y écrit le corromprait.
  • Exporter une réponse. La vue plein écran d'un retour d'agent (comme d'une réponse d'exploration) porte un bouton Exporter : HTML, Word (.docx) ou PDF. Le HTML est un document autonome — styles embarqués, aucune ressource extérieure : il se lit hors ligne et s'envoie tel quel. Le .docx est un vrai document Word (titres, listes, tableaux, blocs de code), fabriqué sans rien installer. Le PDF passe par la fenêtre d'impression du navigateur, où l'on choisit « Enregistrer au format PDF » : le rendu est celui qu'on a sous les yeux, et Mergerie n'embarque pas un moteur de rendu de 300 Mo pour un bouton. Dans les trois cas, le document porte son titre et sa date : un fichier transféré perd son nom bien avant son contenu.
  • Toutes les itérations sont conservées. Une session s'itère (lancement, Envoyer un suivi, réponses aux questions, passes de convergence) : chaque passe garde le prompt réellement envoyé et le retour de l'IA correspondant. Dès la deuxième passe, Retour de l'IA affiche les itérations en colonne à gauche — chacune avec son numéro, son genre, sa date et la demande qui l'a produite — et le contenu de celle qu'on choisit à droite. On ne se souvient pas du numéro d'une itération, on se souvient de ce qu'on a demandé : un champ de recherche en tête de la colonne cherche donc dans ces demandes et masque les itérations qui ne correspondent pas, sans en perdre aucune — et le filtre survit au passage d'une itération à l'autre. Relire une réponse sans savoir à quelle demande elle répondait n'apprend rien : les deux sont donc affichés ensemble. Une seule itération n'affiche aucune colonne — il n'y a rien à choisir. Vaut aussi pour le codage hors dépôt, dossier par dossier. Combien d'itérations déjà ? Le bouton Envoyer un suivi porte son compte dans son libellé — « Envoyer un suivi (2) » — sur chaque carte de session, de question et de dossier hors dépôt. Dans Retour de l'IA, chaque itération affiche ses tokens, l'en-tête de la colonne les additionne, et un suivi s'écrit et part de là — sans refermer la vue, retrouver la carte et rouvrir son formulaire pour demander la chose qu'on venait de lire. Épingler et nommer. Au-delà de quelques passes, ni le numéro ni la date ne disent ce qui s'y est joué. Chaque itération porte donc deux gestes : une étiquette qui la remonte en tête de colonne (le numéro reste affiché, la chronologie se lit encore), et un nom qu'on écrit sur place — Entrée valide, Échap renonce. Le nom s'affiche en gras sous l'en-tête et entre dans la recherche, comme la demande. ⚠ Ni l'étiquette ni le nom ne partent à l'IA : c'est du rangement, écrit pour l'humain qui parcourt la colonne — même règle que le libellé d'une session. Une itération antérieure à l'historique des passes n'a pas de ligne en base : elle ne peut être ni nommée ni épinglée, et l'écran le dit au lieu de proposer un geste sans effet. Le diff de CETTE itération. Le diff du projet montre tout ce que la branche apporte : au troisième suivi, la correction de trois lignes qu'on vient de demander se cherche au milieu de deux cents, et on relit tout à chaque fois. La dernière itération d'une session sur dépôt garde donc ses deux bornes — le commit d'avant, celui d'après — et le patch entre les deux : sous la demande, Voir ce que cette itération a changé ouvre le même écran que le diff du projet (arborescence, fichier entier avec les changements en place), borné à cette passe-là. La demande et le retour de l'IA restent à gauche : un diff relu sans savoir ce qu'on avait demandé n'apprend rien de plus que le diff de la branche. Échap referme le diff et rend l'itération, pas la liste des sessions. ⚠ Seule la DERNIÈRE mesure est gardée. Ce qu'on vient de demander est ce qu'on relit ; le diff de l'avant-dernier suivi n'est jamais rouvert et pèserait pour rien. Chaque nouvelle passe efface donc la mesure de celles qui précèdent, et l'écran se tait sur elles — pour comparer deux suivis anciens, c'est le diff du projet qui reste. Une itération qui n'a rien changé au code (l'IA s'est arrêtée pour poser ses questions, ou a constaté que tout était déjà fait) le dit, au lieu d'ouvrir une vue vide ; une itération dépassée, ou antérieure à cette mesure, n'affiche rien du tout : promettre un diff qu'on n'a pas est pire que se taire. Hors dépôt aussi. Là, il n'y a ni branche ni commit : Mergerie tient un dépôt de suivi dont l'arbre de travail est ton dossier mais dont le .git vit dans son propre dossier de travail — ton dossier ne reçoit rien, pas même le git qui sert à mesurer, et s'il est déjà un dépôt le sien n'est ni lu ni écrit. Deux instantanés par passe, et le diff entre les deux. Ce que ton dossier ignore déjà (.gitignore) est ignoré ici aussi, plus les dossiers de dépendances et d'artefacts — node_modules/, dist/, .venv/ et les autres : les voir dans le diff d'un suivi le rendrait illisible. Et un garde-fou : au-delà de 20 000 fichiers ou 512 Mo, la mesure est abandonnée pour ce dossier — une fois pour toutes — et le journal le dit. Le codage, lui, se poursuit normalement : ralentir un travail pour une commodité de relecture serait le mauvais échange. Le ménage est automatique. Ces dépôts de suivi vivent sous data/tasks/local/ ; ils partent avec la session supprimée, et une fois par jour (au démarrage, puis toutes les 24 h) Mergerie efface ceux que plus aucun dossier de session ne référence — changer la liste des dossiers d'une session en laisse derrière, une base restaurée d'une sauvegarde aussi — et compacte les autres. Ceux qui sont encore référencés ne sont jamais supprimés : une itération se relit des mois plus tard, et c'est tout l'intérêt de la garder.
  • ⌨️ Reprendre la session au terminal. Chaque projet d'une session de codage (dépôt ou hors dépôt), ainsi que les reviews, expose un bouton « Reprendre au terminal » qui copie la commande prête à coller : cd vers le bon dossier + lancement de l'agent avec l'identifiant de session (claude --resume <id>, copilot COPILOT_HOME=… --continue). Tu reprends toi-même la conversation de l'IA, avec tout son contexte, là où l'app l'a laissée.
  • 🙋 L'IA peut te poser une question. Option par session (case à cocher, désactivée par défaut) : si l'IA rencontre une décision structurante qu'elle ne peut pas trancher (choix d'archi, ambiguïté, conflit de conventions), elle s'arrête et te demande au lieu de deviner. La session passe en attente (la file se libère, une notification t'avertit) ; tu réponds depuis la carte — choix proposés ou texte libre — et l'IA reprend la même session là où elle s'était arrêtée. Dès que tu valides, le formulaire laisse place à un « reprise en cours… » (plus d'attente sans retour visuel). L'option se mémorise quand tu modifies une session existante. La reprise a d'abord été validée par un banc d'essai dans Réglages → AI sessions.
  • ⚡ Converger depuis une session — du prompt à la MR convergée. La case …puis converger jusqu’à 8/10 (3 passes max) de la modale de nouvelle session — et le bouton Converger d’une session existante — enchaînent tout le chemin sans intervention : l'IA code la tâche → commit → push → crée la MR (cible = la branche de départ) → puis lance la boucle de convergence (review → correction → re-review) jusqu'au seuil. Tu écris une intention, tu reviens : une MR ouverte, testée, notée et convergée t'attend — il ne reste qu'à relire et merger. Multi-projet : chaque projet donne sa MR, convergée à son tour, en série (un échec n'arrête pas les autres). Idempotent : une session déjà codée n'est pas recodée, une MR déjà ouverte est convergée directement. Mêmes garde-fous que « Converger » sur une MR — et jamais de merge automatique.
  • Codage hors dépôt — l'IA réalise le prompt directement dans des dossiers locaux, en place et sans git : ni branche, ni commit, ni push. Pratique pour des dossiers qui ne sont pas des dépôts d'une forge (scripts, expériences, mono-repo local…). Le dossier de travail ne se saisit plus : on choisit un répertoire local (déclaré dans Réglages → Dépôts) puis le ou les projets qu'il contient — le chemin en découle, et un chemin tapé à la main est une faute de frappe qu'on ne découvre qu'au milieu du traitement. Le formulaire (projets + prompt) vit dans la même modale que le codage — tu peux donc aussi joindre des fichiers — captures, PDF, tableurs, texte (bouton ou Ctrl+V) — pour enrichir le prompt. Le même prompt est appliqué à chaque dossier, l'un après l'autre — un dossier en échec n'interrompt pas les autres, et son statut est indiqué par dossier. Comme pour le codage sur dépôt, chaque dossier expose Git, en option. Un champ Branche à créer (facultatif) donne au dossier le parcours d'une session de codage : la branche est créée dans le dossier, l'IA y travaille, son travail est commité (message de commit au choix, sinon la première ligne du prompt), puis, selon les cases, poussé, la merge request ouverte et la convergence lancée dessus — converger implique la MR, la MR implique le push. Le dossier doit être un dépôt git. Les fichiers modifiés ou non suivis déjà présents ne bloquent pas la session : ils restent en place et ne partent pas dans son commit, sauf si l'IA y a elle-même touché. La forge est retrouvée par le remote origin du dossier, qui doit être un dépôt enregistré dans Mergerie ; sinon la branche est poussée et la carte dit pourquoi la MR manque. Sans nom de branche, rien ne change : l'IA écrit en place et rien n'est commité. Chaque dossier affiche sa branche, l'état de son commit et le lien de sa MR. La convergence travaille sur le clone de Mergerie : un git pull dans ton dossier rapporte ses corrections. Retour de l'IA — ce que l'agent dit avoir fait, utile quand le dossier n'a pas bougé (prompt incomplet, l'IA a répondu au lieu de coder) —, et la session propose Envoyer un suivi : une nouvelle passe sur les mêmes dossiers qui reprend la session de chacun, donc l'IA garde tout le contexte de ce qu'elle vient de produire. Une session hors dépôt est modifiable après coup (prompt, dossiers, identifiant de session), comme une session sur dépôt. La relance est ciblable : chaque dossier a son propre Relancer, et la carte propose Relancer les dossiers en échec quand il y en a — sur cinq dossiers dont un a cassé, tout reprendre coûterait quatre passes d'agent pour rien. Comme toute relance, elle demande confirmation. L'erreur d'une session s'efface pour de bon (la croix de l'encart), et ne revient pas au rafraîchissement suivant. ⚠ Aucun filet : l'agent modifie les fichiers en place, sans sauvegarde ; sur un dépôt git tu peux relire/annuler toi-même (git diff / git checkout), sur un dossier non-git il n'y a pas d'annulation — un avertissement le rappelle. (Sous-onglet dédié, entre Codage et Exploration.)
  • Exploration — lecture seule : tu poses une question sur un ou plusieurs projets, l'IA explore le code et rédige une seule réponse de synthèse enregistrée en .md, consultable à tout moment via Voir la réponse. Ni diff ni merge. Une question de suivi reprend la même session d'agent — comme pour le codage — au lieu de lui réinjecter sa réponse précédente : l'IA se souvient de son exploration au lieu d'en relire un résumé. Les dépôts sont remis à zéro après coup : aucune modification ne subsiste. Chaque exploration expose elle aussi « Reprendre au terminal » pour continuer la conversation toi-même. Chaque question est conservée : une question de suivi écrase le fichier de réponse, mais la passe est archivée — Voir la réponse aligne les itérations à gauche, avec la recherche sur les questions posées, et rejoue à droite celle qu'on choisit avec la réponse qu'elle a obtenue. Faire coder transforme une exploration en session de codage : la modale s'ouvre sur les mêmes dépôts, la question et sa réponse en contexte, et la session d'agent de l'exploration placée en « reprendre une session existante » — l'agent garde ce qu'il a lu au lieu de relire trois dépôts.
  • Question libre — la même chose, sans aucun dépôt. On pose une question à l'IA — une notion à creuser, deux options à comparer, un plan à challenger — et la réponse est gardée ici. Rien n'est lu ni modifié sur la machine : ni clone, ni dossier, ni fichier de ton code. Un libellé facultatif range l'étude (« Concurrence », « Archi paiement »), et la recherche porte sur la question et le libellé. Comme partout, une question de suivi reprend la même session d'agent — c'est ce qui permet de mener une étude en cinq questions plutôt qu'une —, chaque passe est archivée avec sa question, et « Reprendre au terminal » rend la main pour continuer l'échange soi-même. La réponse s'exporte (HTML, Word, PDF) comme celle d'une exploration. Une question libre ne réserve aucun dépôt : elle ne bloque jamais une review ni une session de codage, et rien ne la bloque. (Sous-onglet dédié, après Exploration.)