Mergerie
Sommaire

Reviews

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

Les trois stades d'une même merge request, réunis derrière un filtre segmenté — À traiter · Reviewées · Traitées — avec une recherche commune (titre, auteur, projet, ticket, numéro : « !260 »). Par quoi commencer. Une liste déroulante range la file — ordre habituel (le ticket en revue passe devant), petites d'abord, plus anciennes, note la plus basse. La taille et l'âge sont écrits sur chaque carte ; il manquait de pouvoir s'en servir. Le choix est mémorisé, et il se lit sur la même ligne que les pastilles d'auteur : qui, et dans quel ordre, sont deux façons de réduire la même file.

Ce qui ne demande plus rien se compte dans le brief : note au-dessus du seuil de convergence, verdict vert non périmé, aucun ticket qui s'y oppose — trois colonnes déjà en base. L'outil ne merge rien ; il dit combien de merge requests n'attendent plus qu'une décision.

Une merge request en conflit le dit sur sa carte, et le badge ouvre Git → Merge pré-rempli dans le sens qui débloque (la branche cible dans la branche de la MR). À côté, Mettre à jour avec l'IA ouvre la modale de session de codage déjà remplie : la branche de la MR, sa branche cible pour base, le push automatique décoché, le libellé (« MR !N : mise à jour de … avec … »), et la consigne — comprendre d'abord ce que la branche change et pourquoi, fusionner l'état actuel de la cible dans la branche (git merge), résoudre chaque conflit en gardant ce que la cible apporte et l'intention de la branche, vérifier, commiter, ne pas pousser. La consigne dit en toutes lettres d'ajouter des commits pour corriger les conflits, sans rebase ni amend : l'historique déjà poussé reste intact, et personne n'a de force push à faire. Tu relis la consigne, tu lances, tu relis le diff, puis Pousser — normalement, sans forcer. Cela vaut pour la merge request d'un collègue comme pour la tienne ; Mettre à jour avec main sur une ligne de projet reste le raccourci sans consigne à relire, pour les merge requests nées d'une session.

Une merge request en retard sur sa cible le dit aussi, sans attendre le conflit : la carte porte « N commit(s) de retard » — ce que la branche cible a reçu et que cette branche n'a jamais vu. Elle se merge encore, mais son code n'a pas tourné avec ces commits ; le badge ouvre Git → Merge comme pour un conflit, et Mettre à jour avec l'IA est là aussi, avec une consigne qui dit le retard plutôt qu'un conflit inexistant — et fusionne de la même façon. Le compte vient de la forge (le nombre de commits divergents chez GitLab, la comparaison cible...source chez GitHub), relevé à la découverte — un appel par merge request ouverte, plafonné par tour — et à l'ouverture de la modale de merge. « Pas encore su » n'affiche rien : une branche venue d'un fork, ou une forge muette, ne devient jamais « à jour » par défaut.

Deux merge requests qui se croisent le disent avant le conflit. Un croisement est un fait : deux merge requests ouvertes du même dépôt, vers la même branche cible, qui modifient au moins un fichier en commun. La carte porte alors croise !214 · 3 fichiers · 2 j (plusieurs : croise 3 MR), avant « en conflit » ; le même badge est repris dans l'en-tête du rapport. Cliquer ouvre un panneau ancré sur la carte : une ligne par merge request croisée (numéro, titre, auteur, âge, note si un rapport existe), qui mène à elle dans Reviews, les chemins communs dessous, en monospace, repliés au-delà de dix, et en pied Relevé sur <sha> · il y a 4 min — sur quel commit et quand la liste a été lue. Rien n'est jugé, rien n'est recommandé : git seul sait s'il y aura conflit, l'outil montre que deux branches vont se rencontrer et l'humain décide l'ordre des merges. La liste des fichiers de chaque merge request ouverte est relevée à la découverte, jamais à l'affichage — le diff déjà stocké par une review s'il porte sur la tête actuelle, sinon le clone local, sinon un appel forge par merge request, plafonné par tour (les plus récemment actives d'abord, le reste au tour suivant, le journal le dit) — et invalidée dès que le SHA de tête change, comme le badge « périmé ». Tant qu'une merge request n'a pas sa liste, elle n'affiche rien, jamais « aucun croisement » ; une liste de plus de 5 000 fichiers (migration massive, vendoring) n'est pas stockée, et le survol du bouton ⋯ dit non relevé · trop de fichiers. Aucun appel d'IA, aucun token : les trois réglages sont dans Réglages → Merge Request → Découverte.

Et combien de fichiers de test elle modifie. À côté de la taille, la carte dit 14 fichiers · 3 tests — discret — ou 14 fichiers · 0 test, accentué comme « périmé », quand la merge request modifie au moins N fichiers de code (3 par défaut, réglable) sans toucher un seul fichier de test. En dessous de N, ou quand tout est neutre (documentation, images, lockfiles, outillage — et un sous-module remonté, qui est un pointeur de commit, pas un fichier écrit), rien : une correction de deux lignes ne porte pas de badge. Un fichier est un test ou n'en est pas un selon des motifs de chemin (**/*.test.*, **/tests/**, **/*_test.go…), résolus dépôt → groupe(s) → réglages globaux → défauts livrés, un niveau rempli remplaçant celui du dessus ; c'est calculé sur les listes de fichiers des croisements, à l'affichage, sans IA — des fichiers comptés, jamais une couverture ni un « testée ». Le panneau liste les tests touchés, nomme les motifs qui ont servi (un lien mène au réglage : un faux 0 test sur un dépôt Go se corrige en deux clics) et dit sur quel commit la liste a été relevée. Sans liste fraîche, rien — jamais un faux 0 test. Le badge ne bloque pas Merger, ne change pas la note, ne déclenche rien.

Et quelles dépendances elle ajoute. Après les tests, la carte dit +2 dépendances — accentué dès qu'une dépendance directe entre dans le projet, · 1 majeur quand un passage de majeur se lit (^3.x → ^4.x) — ou 3 dépendances changées, discret, quand des versions bougent ou des paquets sortent sans qu'aucun n'entre. C'est la deuxième question devant une merge request produite par un agent : un paquet ajouté pour trente lignes, la première bibliothèque venue, un nom qui n'existe pas. Une dépendance ajoutée est une ligne de manifeste qui n'existait pas avant, lue en comparant les lignes − / + du diff du manifeste — un diff que la forge envoie déjà au relevé des fichiers et dont on garde désormais celui des seuls manifestes, sans aucun appel de plus, sans IA, sans registre. Les manifestes reconnus : package.json, composer.json, requirements*.txt, pyproject.toml, go.mod, Cargo.toml, Gemfile, pom.xml, build.gradle*, *.csproj, à toute profondeur (un monorepo donne une section par manifeste) ; les lockfiles ne comptent pas. Le panneau liste une ligne par dépendance, en monospace — left-pad ^1.3.0 ajoutée · prod, axios ^0.27.2 → ^1.7.0 majeur · prod, moment retirée · dev —, les ajoutées d'abord, nomme les motifs de manifestes qui ont servi (un lien mène au réglage) et dit sur quel commit le diff a été relevé. Aucun lien vers npm ou PyPI : l'outil ne recommande rien, le nom se copie. Un package.json dont seuls les scripts changent ne porte rien ; un manifeste d'un écosystème non analysé est dit « modifié (non analysé) », jamais compté ; un diff de manifeste de plus de 200 Ko n'est pas gardé et le bouton ⋯ le dit ; sans diff gardé (relevé antérieur à cette version, le tour suivant le reprend), rien — jamais un faux « aucune dépendance ». Rien n'est jugé ni bloqué : pas de note, pas de licence, pas de CVE.

Et ce que le registre public en sait : +2 dépendances · 1 inconnue. C'est le seul cas où un ajout de dépendance est presque toujours une erreur — un nom inventé par l'agent, un homonyme à une lettre près, un paquet publié la semaine dernière — et personne ne le vérifie à la main. Le contrôle au registre (décoché d'office, voir Réglages → Merge Request) demande, pour chaque dépendance ajoutée seulement (jamais les changées ni les retirées), ce que le registre public de son écosystème en sait : inconnue (le registre répond 404 : · 1 inconnue sur la carte), récente (première publication il y a trente jours ou moins, seuil réglable : · 1 récente), ou connue de longue date (rien sur la carte). Dans le panneau, chaque ligne d'ajoutée le dit en clair, jamais une icône seule : left-pad ^1.3.0 ajoutée · prod · inconnu du registre public npm, fastjson2 … première publication il y a 3 j (npm), lodash … publié depuis 2012 (npm). La règle est non négociable : le registre a répondu, ou il n'a pas répondu, et l'outil dit lequel — un délai, une erreur, un 503, le plafond du tour atteint, un écosystème sans registre renseigné donnent registre injoignable (pypi.org, délai dépassé) ou non contrôlé · plafond du tour atteint, jamais « inconnu ». Un paquet d'entreprise (@docaposte/*, un vendor/* Composer interne, un module Go sur un hôte privé) n'est pas une alerte : les motifs de paquets privés (globaux, par groupe, par dépôt) et la lecture du clone (.npmrc avec registry= ou @scope:registry=, composer.json avec repositories, GOPRIVATE dans go.env, pip.conf avec index-url) le marquent non contrôlé · paquet privé probable (.npmrc) sans rien demander à personne — et le pied du panneau mène aux motifs : un faux « inconnu » se corrige en deux clics. Le pied dit aussi Registres contactés : npm · il y a 4 min, ou Contrôle au registre désactivé. Huit registres, un par écosystème : npm, Packagist, PyPI, crates.io, RubyGems, le proxy Go, Maven Central, NuGet ; le contrôle se fait dans le tour de découverte, jamais à l'affichage, au plus trente noms par tour (réglable), mis en cache par nom — la même dépendance ajoutée par dix merge requests coûte un appel, un « inconnu » est revérifié après 24 h, un « connu » après sept jours. Rien n'est jugé : pas de score, pas de blocage, pas de comparaison de noms proches, pas de lien vers la page du paquet — le nom se copie.

Une merge request qui en embarque une autre le dit : contient !214. C'est la merge request empilée : on repart de la branche d'un collègue ou d'un agent, on ajoute son travail, on ouvre vers main. La forge l'affiche comme une merge request ordinaire, avec le diff des deux ; rien ne dit que 220 des 300 lignes sont déjà en revue ailleurs, ni que la seconde changera de taille le jour où la première merge. Une merge request en contient une autre quand l'ensemble des commits de la seconde (cible..source) est inclus dans celui de la première — un fait de git, comparé en SQL, sans aucun appel d'IA. La contenante porte contient !214 (plusieurs : contient 2 MR), la contenue contenue dans !219, toujours ensemble ; une merge request qui vise la branche d'une autre porte basée sur !214 (la forge le montre déjà dans la cible, on le reprend au même endroit) ; deux merge requests aux commits identiques sont jumelle de !220. Tout est discret, juste avant « croise » (une contenue croise forcément la contenante ; l'empilement est plus précis et passe devant) : l'empilement n'est pas un problème, c'est une organisation — l'ordre de merge est déjà choisi, l'outil le montre, l'humain merge dans cet ordre ou non. Cliquer ouvre un panneau ancré : la merge request liée (numéro, titre, auteur, âge, note si un rapport existe — la ligne mène à elle), 12 commits communs · 4 commits propres, et le diff propre — Diff propre : 4 fichiers, les chemins que la contenante touche et que la contenue ne touche pas, ce que le reviewer doit lire ici et pas là-bas, calculé sur les listes de fichiers à l'ouverture (diff propre non calculé si l'une des deux n'est pas à jour) ; une chaîne (C contient B contient A) se lit par maillon, la plus profonde d'abord. Quand la contenue merge ou ferme, le badge disparaît de la contenante au même instant ; si elle a été mergée par squash ou rebase, ses commits d'origine sont encore dans la branche : c'est « N commits de retard » et Mettre à jour avec l'IA qui prennent le relais, et le panneau garde contenait !214 · mergée il y a 2 h pendant sept jours — l'explication du retard qui vient d'apparaître. La liste des commits de chaque merge request ouverte est relevée à la découverte, dans le même tour et sous le même plafond que ses fichiers (pas de second compteur) — le clone local s'il porte les deux branches, aucun réseau ; sinon un appel forge par merge request, pages comprises — et invalidée dès que le SHA de tête ou la branche cible change. Sans liste fraîche, liste refusée (plus de 500 commits : une telle branche en contient forcément d'autres) ou tronquée (GitHub coupe à 250), rien — jamais un faux « indépendante », jamais une inclusion calculée sur une liste partielle. Deux branches aux commits différents mais au même diff (après un rebase) ne se contiennent pas : c'est vrai, et c'est dit. Le rapport d'une merge request contenante reçoit, en tête de son contexte, une phrase de fait — Cette merge request contient !214 (ouverte, à traiter) : 12 commits et 9 fichiers sont déjà soumis là-bas. — pour que la review porte sur le diff propre et renvoie à !214 pour le reste ; elle se lit en clair dans la modale Contexte du rapport, telle que l'IA l'a reçue. Rien dans le brief ; le badge ne change ni la note, ni le verdict, ni le classement, et ne bloque jamais Merger. Un réglage, dans Réglages → Merge Request → Découverte.

Le statut du ticket arrive sur toutes les merge requests, pas seulement sur les tickets surveillés : la découverte lit déjà l'issue en entier pour son contexte, elle en garde le statut — aucun appel de plus.

Trois pastilles au-dessus de la file trient par auteur : Toutes · Les miennes · Celles des autres. Un tech lead regarde d'abord ce que l'équipe attend de lui, un développeur ce qu'il a poussé. Le compte du jeton est lu une fois par forge ; sans lui — un jeton qui ne permet pas de lire son propre compte — les pastilles n'apparaissent pas du tout, plutôt que de trier sur une identité devinée.

La carte dit qui porte la merge request, d'après la forge. Les reviewers demandés (œil) et les assignés (silhouettes) relevés à la découverte y tiennent chacun leur pastille — trois noms au plus, le reste en infobulle —, et le nombre de 👍 (upvotes GitLab, réaction +1 GitHub) une troisième : combien de collègues ont déjà dit « pour moi c'est bon » sans passer par une approbation formelle. Rien ne s'affiche quand personne n'est désigné et que le compte est à zéro. Sur GitHub, les 👍 ne sont pas dans la liste des pull requests : la découverte lit la liste des issues du dépôt, un appel de plus par dépôt, et un échec de cet appel laisse le compte à zéro sans empêcher la découverte. La répartition elle-même se fait sur la forge : Mergerie la lit, il ne la remplace pas.

  • Chercher les nouvelles MR interroge la forge et remplit la liste (filtrée par pattern). Un rafraîchissement automatique le fait pour toi — toutes les 5 minutes sur une base neuve, réglable ou désactivable dans Réglages → Merge Request — et ouvrir l'onglet Reviews relance une recherche quand la dernière est plus vieille que cet intervalle. Les dépôts dont la case récupérer les MR est décochée (Réglages → Dépôts) sont ignorés par cette recherche : leurs merge requests déjà récupérées restent dans la file, on cesse seulement d'en ramener de nouvelles. À distinguer de actif, qui retire le dépôt de partout.
  • Reviewer les N MR lance la review IA sur toute la file ; au-delà de 5, une confirmation rappelle que chaque MR consomme un appel IA. Reviewer traite une MR isolée.
  • Review avec ou sans explication. Par défaut, une review produit deux choses : le rapport (constats + note) et une explication pédagogique (2e appel IA, onglet Explication). Tu peux t'en passer pour aller plus vite et dépenser moins de tokens : le réglage Réglages → Général → « Générer l'explication pédagogique » définit le défaut, et le petit menu ▾ à côté de Reviewer permet de surcharger ponctuellement une MR (Review + explication / Review sans explication). Si l'explication manque, un bouton Générer l'explication sur le rapport la produit à la demande (un seul appel IA, sans relancer la review ni créer de nouvelle version).
  • Emporter le reviewer. Réglages → Merge Request, section « Emporter le reviewer » sous le formulaire : « Exporter le reviewer en skill » télécharge un skill Claude Code autonome — un seul fichier branch-review/SKILL.md, sans script et sans référence à Mergerie — qui refait la même review sur la branche courante d'un dépôt cloné : le gabarit de review de l'équipe mot pour mot, les règles de review actives avec leur condition et leur portée, la note sur 10. /branch-review [cible] : la cible est la branche où le travail doit arriver (par défaut la branche par défaut du dépôt, lue sur origin/HEAD ; le skill demande quand plusieurs sont plausibles) ; la source est toujours la branche courante. L'agent lance lui-même git fetch et git diff origin/<cible>...HEAD (le diff depuis l'ancêtre commun, celui qu'une merge request montrerait) et lit les messages de commit en guise d'intention. Le rapport est rangé dans .branch-review/<branche>/<branche>-<AAAA-MM-JJ-HH-mm-ss>.md (un sous-dossier par branche, un fichier par review, le diff effacé une fois le rapport écrit). À poser dans .claude/skills/ du dépôt ou de la machine.
  • Reviewer sans y penser. Réglages → Merge Request → « Lancer automatiquement la review à l'arrivée d'une MR » met en review toute merge request nouvellement découverte, sans qu'on la demande. Décoché par défaut, et plafonné même une fois coché (« Au plus N reviews automatiques par recherche de MR », juste sous la case, 5 par défaut) : chaque review est un appel IA facturé, et la première découverte d'une installation neuve ramène d'un coup toutes les MR ouvertes du parc. Les MR au-delà du plafond gardent leur bouton Reviewer, et le journal du serveur dit combien n'ont pas démarré. 0 = sans limite. « À l'arrivée » veut dire à l'arrivée : une branche qui avance ne relance rien — la re-review reste un geste, et elle est incrémentale.
  • Le merge en cours dit ce qu'il rattrape. On arrive sur cet écran depuis le badge « en conflit » d'une merge request : la ligne du merge porte donc son numéro, sa note et son ticket, et y mène. Une fois commité, un lien ouvre le diff du merge dans la même fenêtre que « Comparer » — après trente conflits résolus un par un, « qu'est-ce que ça donne, au total ? » demandait un terminal.
  • Merger une branche dans une autre, conflits compris. Git → Merge : tu choisis un dépôt, la branche à fusionner et celle où la fusionner, et l'outil prépare le merge. Le clone partagé n'est jamais touché — tout se passe dans un espace de travail à part, pour qu'une review ou une session lancée en parallèle ne tombe pas sur un dépôt à moitié fusionné. S'il y a des conflits, l'écran les prend fichier par fichier, et conflit par conflit : la version de la branche de destination et celle de la branche fusionnée, l'une sous l'autre, avec Garder sur chacune et Garder les deux : main puis feature — le bouton nomme les deux branches et l'ordre dans lequel il les applique. Ce que tu retiens se colore, tu n'as pas à relire les boutons pour savoir où tu en es. Aucun marqueur <<<<<<< n'est jamais à déchiffrer. Si ni l'une ni l'autre ne convient, Écrire moi-même ouvre le résultat de tes choix dans un champ libre : tu le corriges, et c'est ce texte qui est enregistré. Demander à l'IA envoie tous les conflits de tous les fichiers en un seul job et rend, pour chacun, une troisième version avec son propre Garder et sa raison ; Plein écran montre le fichier entier — destination, source, résultat — côte à côte. Le détail est dans Git → Merge, plus bas. Quand tout est résolu, Commiter ouvre une fenêtre avec le message déjà rempli (Merge branch 'x' into y, plus la liste des fichiers qui ont été en conflit) — tu le relis, tu valides. Puis Pousser, après confirmation, envoie le merge sur la branche de destination. Les deux gestes sont séparés, et rien ne part avant le second. Abandonner remet tout comme avant : la branche de destination n'a pas bougé d'un pouce tant que tu n'as pas poussé. Le rattrapage se propose aussi depuis la fenêtre de merge : elle interroge la forge en s'ouvrant, dit en rouge que la merge request est en conflit, et porte le même bouton. Les deux chemins demandent la même confirmation — c'est la même réécriture d'historique, l'endroit du clic ne change pas l'engagement. Si les deux branches n'ont aucun ancêtre commun — dépôt réinitialisé, branche créée avec --orphan, master et main avec chacun leur racine —, l'outil le dit en clair et propose de le faire quand même. Git refuse par défaut, à juste titre : fusionner deux histoires étrangères juxtapose deux projets, souvent avec des conflits partout. En mode démo, l'onglet Merge fonctionne pour de vrai : le décor contient un petit dépôt git réel (groupe/tarification) avec deux branches qui modifient la même ligne. Les autres dépôts de la démo pointent vers une forge fictive et ne peuvent pas être clonés ; celui-ci, si.
  • Reprendre le rapport de vérification dans un suivi. La vérification a cassé des tests, et on veut que l'IA les répare. Corriger (session IA), depuis le rapport, ouvre une nouvelle session ; depuis la session qui a produit la branche, c'est un suivi qu'on veut. Sur Envoyer un suivi, un bouton Reprendre le rapport de vérif remplit donc le champ avec exactement le même prompt — les tests cassés, leurs messages, les commits testés. Il n'apparaît que si la dernière vérification est rouge et imputable à ces branches : une base déjà rouge n'est pas de ton fait, et demander à l'agent de corriger ce qu'il n'a pas cassé lui ferait toucher du code sans rapport.
  • Rattraper la branche de départ. La session a produit sa branche et sa merge request, puis main a avancé : la forge affiche des conflits. Le bouton Mettre à jour avec main apparaît alors sur la ligne du projet — seulement quand la forge signale des conflits, jamais en permanence — et rejoue les commits de la session par-dessus la branche de départ à jour — un rebase, pas une fusion : l'historique de main est conservé tel quel et tes changements repassent au-dessus. Quand git s'arrête sur un conflit, c'est l'IA qui tranche, avec pour consigne de garder ce que main apporte et d'y réappliquer l'intention de la branche ; c'est tout l'intérêt du bouton, sinon git rebase suffirait. Rien n'est poussé : un rebase réécrit l'historique, l'envoyer demande un push forcé, et c'est le bouton Pousser — un second geste — qui décide. Si la résolution n'aboutit pas (ou s'il n'y a pas d'agent configuré), la branche est remise exactement comme elle était : un rebase laissé en plan bloquerait le clone pour tout le reste. La ligne du projet porte alors la même étiquette « en conflit » que la file des merge requests, à côté du bouton — il offrait déjà le remède, rien ne disait pourquoi il était là. Le rattrapage tourne en arrière-plan ; un toast le suit jusqu'au bout, succès ou échec, et rappelle qu'un push forcé vient ensuite. Étiquette et bouton s'effacent dès que le rattrapage a réussi, sans attendre le prochain passage de la forge. Le même rattrapage est proposé dans la modale de merge : à l'ouverture, la forge est interrogée, et si la merge request est en conflit la modale le dit en rouge — avec la branche concernée — et porte le bouton. On apprend le conflit avant de cliquer « Merger », pas dans le refus qui suivrait. Depuis la file (une MR qui ne vient pas d'une session), le conflit est annoncé de la même façon, sans le bouton : il n'y a pas de branche de session à rejouer. Le forçage se décide dans la confirmation de Pousser, par une case « Forcer le push (--force-with-lease) ». Elle est décochée par défaut : forcer réécrit une branche publiée, ça ne se fait pas à ta place. Elle n'arrive pré-cochée que dans le cas où l'on sait que le push normal sera refusé — la branche vient d'être rattrapée, son historique a été réécrit. Décochée, le push part normalement et la forge le refuse : c'est la bonne réponse, et le refus s'affiche sur la ligne du projet. Cochée, c'est --force-with-lease — jamais --force : un commit poussé sur la branche depuis le dernier fetch fait échouer le push au lieu de disparaître. Le travail d'un collègue n'est jamais effacé en silence.
  • Rejoindre la session qui a produit la branche, depuis Reviews. Quand la branche d'une merge request vient d'une session de codage connue de ce poste, sa carte — à traiter, reviewée ou traitée — porte la puce Session #N (la plus récente sur cette branche ; « en cours » quand elle tourne), et le menu ⋯ propose Ouvrir la session de codage #N. Le clic mène à sa carte dans Dev IA, même rangée ou cachée par un filtre : la liste la révèle au lieu de ne mener nulle part. À l'arrivée, la carte garde un contour tant qu'on n'a pas cliqué ailleurs (ou Échap), même quand la liste se redessine, et un bandeau en tête dit « Vous êtes sur la session #N, issue de la merge request !12 de grp/app, branche feature/x » — avec Voir la carte pour y revenir. L'en-tête du rapport porte la même puce. Une branche sans session ne porte rien. Et dans l'autre sens : sur la carte d'une session, la puce MR !5 · 6,0/10 de la ligne de projet mène à la merge request dans Reviews — sa carte si elle est à traiter (marquée de la même façon), son rapport sinon ; le lien ↗ vers la forge reste à côté.
  • Reprendre le rapport de review dans un suivi. Une fois la merge request reviewée, on veut souvent que l'IA traite les constats. Le bouton Faire corriger le code par l'IA du rapport ouvre pour cela une nouvelle session ; depuis la session qui a produit la branche, c'est un suivi qu'on veut — l'agent reprend son propre fil au lieu de redécouvrir le code. Sur Envoyer un suivi, un bouton Reprendre le rapport de review remplit donc le champ avec le même prompt (« applique les corrections pertinentes de cette revue », rapport inclus). Il n'apparaît que s'il y a un rapport, et demande avant d'écraser un brouillon déjà écrit. Le texte reste relu et modifiable : le bouton remplit, c'est toi qui envoies. Une session multi-projets reprend le rapport de chaque projet, nommé — son suivi part à tous.
  • Suivre une branche qui bouge. Une fois la review faite, la branche continue d'avancer : le rapport ne parle alors plus du code en place, et la merge request porte le badge périmé. Réglages → Merge Request → « Relancer automatiquement la review quand le rapport est périmé » fait repartir la review d'elle-même à la découverte suivante, en incrémental — l'IA ne relit que ce qui a changé et reçoit le rapport précédent en contexte. Décoché par défaut : sur une branche qui bouge dix fois par jour, ça fait dix appels. Elle est indépendante de la case précédente (arriver et bouger sont deux dépenses différentes) et partage le même plafond par découverte, avec son propre budget : une poussée massive sur des MR connues ne mange pas celui des nouvelles. Une MR jamais reviewée n'est pas concernée — sans rapport, rien à périmer.
  • Publier le rapport sur la merge request. Un rapport de review reste par défaut chez toi : il vit dans Mergerie, personne d'autre ne le voit. Le bouton Publier sur GitLab / Publier sur GitHub du rapport le poste en commentaire sur la MR, tel qu'il est sur le disque — c'est la façon de rendre la review à l'auteur sans la recopier. Une confirmation le rappelle : ce qui part est lu par toute l'équipe. Une fois publié, le bouton devient Republier et porte la date du premier envoi, pour qu'on ne poste pas deux fois le même texte en croyant à un échec.
  • Approuver, résoudre, et la CI de la forge. Le rapport se publie ; ce qui manquait, c'est ce que la forge appelle une review. Approuver, dans les actions du rapport, pose une approbation GitLab ou une review APPROVE GitHub — sans aucun commentaire, jamais une rafale de remarques inline. La confirmation dit sur quoi on s'engage (la note face au seuil, le verdict de vérification) sans rien interdire ; le bouton passe ensuite à Approuvé ✓, relu depuis la forge, et se retire d'un clic. Sur chaque fil de discussion, Résoudre / Rouvrir clôt ce qu'une re-review a vu disparaître (GitLab : la discussion ; GitHub : le fil de review, par GraphQL — un commentaire général ne se résout pas là-bas, et l'outil le dit). Et chaque carte porte le badge CI de la forge — pipeline GitLab, check-runs et statuts GitHub, agrégés en un mot : vert, rouge, en cours — avec le lien vers ce qui a cassé. Ce n'est pas le verdict de Mergerie, qui reste un autre badge, d'un autre mot.
  • Publier le LIEN du rapport, plutôt que le rapport — seulement quand l'équipe partage un dépôt de données. Six cents lignes recopiées en commentaire, personne ne les lit, et la passe suivante en repose six cents. Le rapport est déjà dans le dépôt de l'équipe, en Markdown rendu par la forge : le bouton Publier le LIEN du rapport poste un commentaire de trois lignes qui pointe son adresse, avec la note et le numéro de passe. La merge request reste lisible et le rapport garde un seul exemplaire, que tout le monde relit au même endroit. La synchro part d'abord : publier un lien vers un fichier resté sur ce poste enverrait l'équipe sur un 404, ce qui est pire qu'un commentaire absent — on croirait le travail fait. Si le dépôt ne peut pas être envoyé (hors ligne, rebase en cours), rien n'est publié et l'écran dit pourquoi. Un dépôt de données posé sur un chemin local (disque partagé, clé USB) n'a pas d'adresse web : le bouton le dit plutôt que d'inventer un lien. La publication automatique sait le faire aussi : sous la case « Publier automatiquement le rapport… », une seconde — « Publier le lien vers le rapport, pas le rapport » — change ce qui part à chaque passe. Elle ne décide pas SI l'auteur est prévenu, seulement la FORME ; et si le lien ne peut pas être fait, c'est le rapport qui part, le journal du job disant pourquoi. Elle n'apparaît que si un dépôt de données est configuré. Le texte du commentaire s'écrit juste en dessous — un gabarit d'équipe : tout le monde poste le même. Laissé vide, c'est le message livré, qui suit la langue de l'interface (le champ le montre en filigrane, plutôt que de le faire deviner). Rempli, il est pris au mot, avec {url} (obligatoire), {note} — vide si la passe n'en a pas —, {v} le numéro de passe, {iid}, {project}, {title}, et {blockers}, {majors}, {minors} — le nombre de constats bloquants, majeurs et mineurs de la passe, comptés comme sur la carte (les constats résolus n'y sont pas) ; la liste est écrite sous le champ. Une variable inconnue est laissée telle quelle. Un gabarit sans {url} est refusé à l'enregistrement, pas à la publication : il annoncerait un rapport sans dire où il est. Le réglage Réglages → Merge Request → « Publier automatiquement le rapport de review sur la MR » le fait à la fin de chaque review. Il est décoché par défaut : écrire chez les autres est une décision. S'il est coché et que la forge refuse, la review n'est pas perdue pour autant — le rapport reste enregistré, et le journal du job dit pourquoi la publication n'a pas eu lieu. Sous cette case en apparaît une seconde : « Envoyer uniquement s'il y a des points bloquants ». Le rapport ne part alors que s'il porte au moins un constat de sévérité bloquant ; les autres restent enregistrés et lisibles dans l'onglet, simplement personne n'est dérangé sur sa MR pour trois remarques mineures. Un rapport sans aucun constat ne part pas non plus — le journal du job écrit combien la passe en comptait, ce qui distingue « rien de bloquant » d'un rapport dont le bloc de constats manque. Le bouton Publier, lui, ignore ce filtre : un geste explicite part toujours.
  • La carte tient sur une ligne d'actions : Voir le diff · Contexte | Reviewer ▾ | ⋯. Le menu ⋯ rassemble tout le reste — Faire coder l'IA, Vérifier, Voir les résultats, Copier la référence, Mettre à jour depuis la forge, Classer sans review, Merger. Sept boutons de même poids par carte ne disaient pas lequel était le chemin normal, et leur nombre changeait d'une carte à l'autre : la colonne d'actions n'était jamais deux fois au même endroit. Les gestes sont les mêmes, un clic de plus pour les moins fréquents.
  • Voir le diff ouvre le diff de la MR avant toute review, dans le viewer plein écran (arbre, diff inline, navigation) — le dépôt est cloné à la demande si besoin. Le panneau de gauche devient un panneau de décision : si la MR est triviale, Classer sans review ; sinon Reviewer. Objectif : ne pas dépenser un appel IA pour une MR évidente.
  • Faire coder l'IA ouvre une session de codage pré-remplie sur la branche de la MR (branche de travail = branche source, branche de départ = branche cible).
  • Projets liés (dans Contexte) : d'autres dépôts + une branche que l'IA consulte en lecture seule pendant la review pour signaler si les changements de la MR risquent de les impacter (signatures d'API, contrats, schémas…). Montés sous ai-dev-tools-internal/linked/, remis à zéro après. Chaque projet lié ajoute durée et coût en tokens — à choisir.
  • Contexte attache à une MR tout ce qui aide à la juger — contenu du ticket, spécification, règle métier, extrait d’échange — en texte et/ou en capture d’écran (collable au Ctrl+V). Si Jira est configuré (URL + email + jeton d’API, Réglages → Jira), le summary + description du ticket sont récupérés automatiquement au discover et pré-remplissent le contexte — cas nominal zéro clic. Ta saisie manuelle reste un complément distinct (jamais écrasé), et un bouton Rafraîchir re-récupère le ticket à la demande. Le tout est injecté dans le prompt de review, en plus du diff, et le bouton porte un ✓ quand un contexte est déjà enregistré.
  • Merger ouvre une confirmation avec ses options. Avant de fusionner, une modale rappelle la MR et sa branche cible, et propose Squash (réunir les commits en un seul) et Supprimer la branche source après le merge. Les deux cases sont pré-cochées d'après ce qui avait été choisi à la création de la MR. Elle rappelle aussi ce qu'on sait : la note, les constats bloquants, le verdict de vérification, le fait que le rapport soit périmé, et les remarques rédigées jamais envoyées — celles-là partiraient avec la merge request. Rien n'est recalculé : ce sont les badges de la liste, aux mêmes règles. Rien de connu (une merge request ouverte hors de la file) : rien d'affiché, plutôt qu'une ligne qui rassure.
  • Créer une MR ouvre la même famille de modale : titre pré-rempli, et les deux mêmes options. GitLab les retient dès la création ; GitHub ne sait pas les exprimer à la création — Mergerie les mémorise alors et les applique au merge, ce que la modale indique.
  • Merger merge la MR directement, sans review — pour une MR triviale : on confirme, et si le merge a réellement lieu la MR sort de la file (marquée traitée). Disponible aussi dans le panneau de décision de Voir le diff, là où l'on juge justement de la trivialité.
  • Classer sans review sort une MR de la file, avec annulation possible pendant quelques secondes.
  • Mettre à jour depuis la forge (menu ⋯ de la carte et du rapport) relit cette merge request seule sur GitLab ou GitHub, sans attendre le rafraîchissement automatique ni lancer une découverte sur tous les dépôts : titre, branches, dernier commit, conflits, retard sur la cible, brouillon, reviewers, assignés, 👍 (GitLab), et son état. Un commit arrivé depuis rend le rapport périmé et déclenche ce que la découverte aurait déclenché (re-review et vérifications automatiques « sur péremption », si elles sont activées) ; une merge request mergée entre-temps prend son badge mergée, fermée sans merge son badge fermée. Le message dit ce que la forge a répondu : mise à jour, rien de nouveau, nouveaux commits, mergée, fermée. Sur une merge request mergée, il écrit aussi les SHA qui permettent de la relire (merge-base d'alors et tête, que la forge conserve même après la suppression de la branche) et, si le dépôt est déjà cloné, ramène cette tête : Ouvrir le code montre alors le diff au lieu d'un écran vide. Côté appels : le détail de la MR (un appel), plus les fichiers changés quand le commit a bougé, et chez GitHub la comparaison avec la cible — jamais plus de trois.
  • Une merge request sans base commune se relit quand même. Quand la cible et la source n'ont aucun ancêtre commun dans le clone (cible changée sur la forge, historique de la cible réécrit, branche orpheline), git diff cible...source répond « no merge base ». La review et Voir le diff relisent alors la merge request comme la forge l'affiche, par les SHA de ses diff_refs (un appel), et les gardent sur la ligne. Quand la forge n'a pas de base non plus (GitLab rend des diff_refs sans base_sha), les deux arbres cible et source sont comparés tels quels : pour une cible réimportée à l'identique, c'est exactement ce que la branche change ; pour deux histoires vraiment étrangères, le diff est grand mais vrai, et le journal le dit. Si rien ne permet de relire, l'erreur dit la situation et la raison, au lieu du fatal de git.
  • Les reviews s'empilent dans une file — deux jobs sur le même dépôt gardent leur ordre, ceux qui n'ont rien en commun partent en parallèle d'eux-mêmes (voir Dev IA) ; un panneau de log en direct montre les commandes, la sortie et la progression, avec un bouton Stop (qui vide aussi la file — la confirmation le précise), un chronomètre depuis le démarrage et, une fois le rythme établi, une estimation du temps restant (elle se tait plutôt que de mentir quand la cadence dévie).
  • Voir la file d'attente et lancer en parallèle. Le panneau de log liste ce qui attend. Un job qui ne touche aucun dépôt ni dossier en commun avec ce qui tourne part de lui-même (jusqu'à 3 à la fois), les jobs lancés à la main avant les automatiques ; celui dont le périmètre est inconnu attend, et on peut le promouvoir à la main — la collision, elle, est refusée, pas arbitrée : deux agents sur le même clone le corrompraient. Chaque job promu a son onglet dans le panneau, avec son propre bouton Stop ; l'onglet reste après la fin, pour relire la sortie. Un job interrompu peut être relancé depuis la file.
  • Modifier son propre commentaire. Un commentaire posté depuis Mergerie — en ligne dans l'explorateur ou en général sur la MR — peut être réécrit sans passer par la forge. Seuls les siens : ceux des collègues sont en lecture seule.
  • Re-review complète ou incrémentale. Relancer la review refait une review complète (tout le diff). Quand la branche a bougé depuis la dernière review (MR stale), un bouton Relancer (delta) apparaît : la re-review incrémentale ne relit que ce qui a changé depuis le dernier SHA reviewé (reviewed_sha..current_sha) et fournit le rapport précédent en contexte — l'IA produit un rapport complet à jour (note incluse) en lisant beaucoup moins de diff (donc moins de tokens). Repli automatique sur une review complète s'il n'y a pas de delta exploitable (ex. force-push). La relance relit d'abord la MR sur la forge : la review d'un collègue, arrivée par le dépôt de données partagé, peut viser une tête que ce poste n'a pas encore découverte, et un SHA reviewé qui n'est pas un ancêtre de la tête donne une review complète, jamais un delta à l'envers. Relancer une review reprend la même session d'agent que la review précédente : l'IA se souvient de son analyse et se concentre sur ce qui a changé.
  • ⚡ Converger — la boucle de qualité autonome. Le bouton Converger d'un rapport lance une boucle autonome : review → correction IA appliquée au code (commit + push sur la branche) → re-review incrémentale du delta → et ça recommence jusqu'au seuil de note (défaut 8/10) ou au plafond de passes (défaut 3). Tu pousses une MR moyenne, tu reviens plus tard : elle est passée de 5,8 à 8,4 en quelques itérations, avec tout l'historique versionné (v1 → v2 → v3, notes, findings résolus/apparus, chaque commit de correction lisible). Garde-fous : arrêt si la note baisse ou stagne, plafond de passes strict, et jamais de fusion automatique — la boucle prépare, c'est toi qui valides et merges (review et correction viennent du même modèle : une note obtenue en autonomie n'est pas une note validée par un humain). Seuil et plafond sont réglables globalement (Réglages → Merge Request → Convergence) et surchargeables au lancement. Une notification t'avertit à la fin (« Convergence terminée : 8,4/10 en 3 passes »). Si l'option « l'IA peut poser des questions » est active et que l'IA hésite pendant une passe, la boucle Le verdict du vérificateur, à côté de la boucle — jamais une condition de sortie : après chaque passe, le vérificateur qui porte la merge request (celui de la session, ou un vérificateur « relancer quand le verdict se périme » qui couvre le dépôt) tourne dans le job, avec un HOME jetable, et le panneau de convergence affiche son dernier verdict — vert, rouge, ou périmé quand la branche a bougé depuis. Un verdict qui passe au rouge se dit dans le journal, et la boucle continue : des tests verts ne disent pas que tout est bon, et le seuil de note garde la main. se met en attente (notification) au lieu de deviner : tu réponds, puis tu relances Converger — qui reprend la même session.
  • Les demandes de modification sont conservées. La section Demander une modification à l'IA liste les demandes déjà faites sur ce rapport, avec leur date, et un bouton ouvre le rapport que chacune a produit (la version correspondante). On retrouve ainsi ce qui avait été demandé pour arriver à un rapport donné, au lieu de le reconstituer de mémoire.
  • Poser une question sur la revue, sans la réécrire. Demander une modification à l'IA régénère le rapport et en fait une version de plus : demander pourquoi un constat est bloquant coûtait donc le rapport qu'on était en train de lire, et la note pouvait bouger au passage. La section Poser une question sur cette revue sert à demander sans rien risquer : la réponse s'ajoute aux échanges sous le rapport — question et réponse ensemble, la plus récente en tête — et ni le rapport, ni sa note, ni ses versions ne changent. Ce n'est pas une consigne donnée à l'IA : le code qui répond n'écrit nulle part ailleurs, donc un agent qui réécrirait le rapport de lui-même n'aurait aucun effet. La question reprend la session de review quand il y en a une : l'IA a déjà lu le diff et son propre rapport, la réponse coûte donc une question et non une relecture. Relire tous les échanges les ouvre dans la même vue à colonnes que les itérations d'une session — avec sa recherche, ses épingles et ses noms. Les échanges partent avec le rapport si on le supprime : ils le citent, et les relire sans lui ne dirait plus rien de ce qui avait été demandé.
  • Sur un rapport : régénérer le rapport, commenter la MR, merger, relancer la review, marquer traitée, supprimer le rapport (la MR retourne « à traiter »), et surtout Faire corriger le code par l'IA — qui ouvre une session de codage pré-remplie avec le rapport injecté dans le prompt, pour ajuster avant de lancer. Si la branche vient d'une session de codage, son identifiant de session est pré-rempli : l'IA reprend le fil de son propre travail au lieu de redécouvrir un code qu'elle vient d'écrire. C'est une proposition, pas une règle — le lien est déduit du dépôt et de la branche, ce qui n'est pas une preuve : vider le champ repart d'une session neuve.
  • Chaque passe de review est conservée. Relancer une review ou régénérer un rapport n'écrase plus le précédent : un sélecteur de version apparaît dans le rapport dès la deuxième passe (v2 — actuelle · 20/07 14:30 · 7,8/10) et permet de relire une review antérieure, avec un bandeau rappelant qu'elle est en lecture seule.
  • Suivi de résolution entre deux passes : dès la 2e review, un bandeau indique les constats résolus · persistants · nouveaux et l'évolution de la note (note 6,4 → 7,8). Un constat n'est dit « résolu » que si la ligne concernée a réellement changé entre les deux versions du code (vérifié via git) ; sinon il est marqué « disparu » — l'IA a pu simplement ne pas le re-signaler. Les constats viennent d'un bloc structuré que l'IA émet en plus du rapport (invisible à la lecture) ; ton template de prompt de review n'est pas modifié, l'instruction est ajoutée à la volée. L'onglet Stats en tire un taux de résolution par projet.
  • Les constats deviennent des remarques d'un geste. Huit constats, c'était huit ouvertures du viewer : chercher le fichier, descendre à la ligne, cliquer « + », recopier le constat. Deux boutons au-dessus de la liste — Mettre en brouillons et Les N bloquants — en font des commentaires inline en brouillon, un par constat, accrochés à leur ligne ; et chaque constat porte son propre bouton brouillon, à côté de « pourquoi ce constat ? » et « corriger ceci », pour n'en garder qu'un ou deux sur quarante. Rien n'est envoyé : on relit, on ajuste, on envoie groupé comme d'habitude. Sur un constat seul, le message dit pourquoi rien n'a été créé — hors du diff, brouillon identique déjà là. Quatre choses sont laissées de côté, et l'outil le dit : les constats résolus (commenter ce qui vient d'être corrigé est du bruit), ceux sans fichier ni ligne (ils n'auraient nulle part où s'accrocher), ceux qui ont déjà un brouillon identique — cliquer deux fois est le geste le plus naturel du monde — et surtout ceux qui tombent hors du diff. Ce dernier cas est le plus fréquent, et c'est le seul qui surprend : un rapport a parfaitement le droit de parler d'une ligne que la branche n'a pas touchée (« cette fonction est maintenant appelée avec null »). Une remarque inline, non : elle s'accroche au diff, la forge refuse une position qui n'y est pas, et l'écran l'afficherait en attendant collée à une ligne que personne n'a modifiée. Le croisement se fait avec le diff de la version reviewée — celle dont les constats viennent —, et une ligne inchangée mais présente dans un hunk est accrochée avec ses deux numéros, sans quoi GitLab refuse la position.
  • L'en-tête dit sur quel commit le rapport porte (cf4fea90), et le sélecteur de versions le répète pour chacune : deux passes d'un même après-midi ne se distinguaient que par l'heure, alors qu'elles décrivent deux états du code.
  • Le bandeau de convergence nomme sa meilleure version (« meilleure : v3 ») et y mène en un clic — après trois passes, le rapport affiché n'est pas forcément celui qui porte la meilleure note. Quand la boucle s'est arrêtée sur une question, il le dit aussi : elle ne repartira pas toute seule.
  • Reviewer porte sur ce qui est à l'écran — et sur la sélection quand il y en a une. Il lançait la file entière quels que soient la recherche et les filtres : on cherchait « paiement », on cliquait, et trente-sept reviews sans rapport partaient avec. Le libellé dit ce qui va partir.
  • Une MR qui n'est plus ouverte sur la forge porte le badge mergée ; le bouton Merger disparaît.
  • Filtrer par couleur de note. Sous Reviewées et Traitées, quatre cases au-dessus de la liste — vert (≥ 7/10), orange (4 à 6,9), rouge (< 4) et — sans note — se cumulent : « montre-moi les rouges et les oranges » tient en deux clics, et chacune porte le nombre de merge requests qu'elle fera apparaître. Le choix est retenu d'une visite à l'autre ; décocher la dernière case ramène tout, plutôt que de laisser une liste vide sans issue. Le résumé de droite suit le filtre. Le stade À traiter n'a pas ces cases : une MR n'y revient qu'après suppression de son rapport, donc sans note à filtrer.
    • — sans note est une case comme les autres, et elle existe pour une raison : la note n'est pas calculée, elle est relue du rapport. Quand l'IA n'en écrit pas, la carte affiche — — et sans cette case, elle quittait la liste au premier filtre posé, sans compteur ni case pour la rappeler. On la croyait alors perdue, ou jamais reviewée.
  • Liste et rapport défilent chacun pour soi. Descendre la liste pour changer de merge request n'emporte plus le rapport hors de l'écran — on regarde les deux ensemble.