Partager avec une équipe (dépôt de données)
Cette page est générée depuis docs/guide.fr.md · Modifier cette page sur GitLab
Mergerie est fait pour une personne, et le reste par défaut. Mais le travail qu'on accumule — les règles de review, les vérificateurs, les agents et leur carte du code, les todos — a toutes les raisons d'être commun : une carte de domaine coûte des heures d'agent à produire, et la refaire sur six postes, c'est payer six fois la même chose pour obtenir six réponses légèrement différentes.
Le principe. On désigne un dépôt git — celui de l'équipe, sur la forge qu'elle a déjà — et Mergerie y range ce travail : un fichier par objet, en texte lisible. Chacun garde son instance, ses jetons et son abonnement au CLI d'IA : les requêtes partent de son poste et lui sont facturées, et c'est le résultat qui est partagé. Il n'y a rien à installer, rien à administrer : l'équipe a déjà une forge, des droits, des sauvegardes et un historique.
Reprendre la session d'un collègue sur ce poste. Une session de codage reçue du dépôt se lit : le handle d'agent, le clone et les suivis sont sur l'autre poste — quand Claire est absente, la session que son agent a laissée en attente d'une réponse attend avec elle — sa question se lit sur sa carte (ses options, « en attente chez Claire »), elle ne se répond pas d'ici. Sur la ligne de projet de sa carte, « Reprendre sur ce poste » (ou « Répondre et reprendre sur ce poste » si la cible attend une réponse) crée une session à toi, sur ton clone et ton abonnement, qui repart de sa branche telle qu'elle est sur la forge (nouvelle branche <branche>-reprise-<toi>, -2, -3 si le nom est déjà pris, posée sur la tête de la forge), avec tes réglages — jamais les siens, qui ne voyagent pas — et dont l'agent reçoit, comme premier message, tout l'historique de la session d'origine, tel quel : le prompt, chaque passe avec son genre, le prompt réellement envoyé et le retour de l'agent, les questions et les réponses, le dernier rapport de review et la dernière vérification liés à la branche, puis ta réponse à la question en attente et ta consigne de reprise. Assemblé mécaniquement, sans aucun appel d'IA, jamais résumé : la modale le montre en entier avant de lancer, avec les tokens estimés, un curseur « passes incluses » (défaut : toutes) et la case « joindre le diff de la branche » ; la première passe le conserve. Rien n'est automatique, rien ne touche la session d'origine, et aucun handle d'agent n'est réutilisé — il n'existe que sur l'autre machine. La filiation va dans les deux sens : ta carte dit reprise de la session de Claire (#123), la sienne — chez tout le monde après synchro — reprise par Amady (#207) · il y a 10 min ; plusieurs reprises, plusieurs lignes, aucune n'est « la » suite officielle. Le bouton n'apparaît que pour une session de codage sur dépôt reçue d'un autre poste, dont la branche a été poussée (branche non poussée par Claire sinon) et n'est pas mergée (branche mergée (!214)) ; la forge est relue à l'ouverture (branche absente de la forge), et l'en-tête dit quand elle est N commits plus loin que la dernière passe connue. Hors dépôt, exploration, question libre : rien à reprendre en v1.
Et l'équipe, ce matin ? L'onglet Équipe (« Notre matin ») lit ce même dépôt pour dire qui attend quoi, depuis quand — décisions en attente, questions sans réponse, vérifications en échec — sans rien partager de plus ; les postes de l'équipe et leur dernière synchro se lisent ici même, sous Postes de l'équipe. Voir la section Équipe.
Ce qui ne part JAMAIS dans le dépôt. Les six jetons d'API, le dossier de clonage, la langue, les chemins absolus de cette machine, les sessions rangées, les journaux de jobs. Chaque colonne de la base est classée nommément, et un contrôle automatique refuse une colonne au nom de secret qui ne serait pas déclarée — parce qu'un secret commité dans git est définitif : l'historique est immuable, chaque clone le garde, la forge le garde. Le retirer ne suffit pas, il faut révoquer. SIX ONGLETS RESTENT LOCAUX : Dépôts, Liens, Docker, Jenkins, Git et Jira. La grille services × environnements, une palette de commandes git, un job Jenkins visé, un conteneur sauvegardé, un ticket surveillé : tout cela dit où l'on va travailler et comment on est branché — pas ce qu'on a produit. Les partager imposerait à chacun l'outillage du voisin, ferait voyager un journal d'actions que personne d'autre ne peut rejouer, et remplirait la liste de todos de tout le monde au premier changement d'état d'un ticket suivi par un seul. Les dépôts que tu suis sont aussi les tiens : en ajouter un, c'est ajouter son clonage et la découverte de ses merge requests avec lui, sur ton jeton et ton abonnement — partager la liste aurait déclenché tout ça sur chaque poste dès qu'un seul ajoutait un dépôt, sans case à cocher pour le refuser. Chaque poste garde sa propre liste et ne synchronise que les dépôts qu'elle porte ; une merge request ou une règle de revue désigne toujours son dépôt de la même façon pour tout le monde une fois découverte, donc une équipe lit toujours la même histoire sur les dépôts qu'elle suit des deux côtés.
Les todos aussi se partagent une par une, et jamais celles qu'aucune main n'a écrites : la todo née d'une veille Jira ou d'une question posée par un agent ne quitte jamais le poste qui l'a créée — partagées, elles remplissaient la liste de tout le monde. Un brouillon ne part jamais : une remarque inline pas encore envoyée, le texte d'une relance en cours de frappe, le profil d'agent qu'on essaie. Et les valeurs d'environnement d'un vérificateur restent ici : seuls leurs NOMS voyagent, pour que chacun sache quoi renseigner — une variable de commande de test est le lieu naturel d'un mot de passe.
Les automatismes ont un exécutant. Les reviews et vérifications automatiques sont réglées pour l'équipe, mais chaque poste a sa propre file : sans exécutant désigné, deux postes allumés lanceraient deux fois la même review — deux appels d'IA facturés, et deux commentaires sur la merge request. Réglages → Merge Request demande donc qui les fait tourner ; sans personne, elles ne tournent nulle part. La liste offre deux réponses. Un poste : une personne paie les appels de toute l'équipe, et rien ne tourne quand sa machine est éteinte. Ou « l'auteur de la merge request » : chaque poste ne prend que les merge requests dont le compte de la forge est le SIEN, avec son abonnement, et laisse celles du voisin — la décision n'est plus globale, elle se prend merge request par merge request. Le compte est celui du jeton de la forge concernée, comparé à l'auteur sur son identifiant de forge — le nom affiché, que n'importe qui peut prendre, ne sert que pour une merge request découverte avant que l'identifiant ne soit relevé. Si ce compte ne peut pas être connu (jeton absent, forge injoignable), le poste ne lance rien et le dit dans le journal : mieux vaut rien que la même review sur tous les postes.
Les sessions se partagent UNE PAR UNE, et pas par défaut. Une session de codage, une exploration, une question libre : ce qu'elles portent n'est pas un produit mais la façon dont on a travaillé — le prompt tel qu'on l'a tapé, les trois relances, la question qu'on n'aurait pas posée à voix haute, la capture collée qui montre une autre fenêtre, et ce qu'a coûté chaque essai. Le résultat, lui, part déjà par son propre canal : la branche et la merge request sur la forge, la carte du code, la page de notes qu'un agent a produite. Chaque session porte donc une case « Partager avec l'équipe », décochée. Ses itérations et ses pièces jointes suivent la session — elle ne peut pas être à moitié partagée —, et la décocher retire tout le dossier du dépôt. Les sessions écrites avant cette version deviennent privées et en sortent au premier démarrage. Enfin, la session d'un collègue ne se supprime pas : on la range. L'effacer ici l'effacerait chez tout le monde.
Une session partagée se passe de main en main, et l'IA ne perd pas le fil. C'est ce qui rend le partage d'une session utile plutôt que documentaire : tu lances une session sur un ticket, tu coches la case, un collègue la reprend — avec son abonnement à lui. Son agent n'a pourtant aucune mémoire de la tienne : une conversation d'agent appartient au poste qui l'a ouverte et ne voyage pas. Ce qui voyage, ce sont les itérations : la demande et la réponse de chacune. L'outil les rejoue en tête du prompt quand il n'a pas de session locale à reprendre, et l'agent du collègue repart donc avec tout ce qui s'est dit — pas sa mémoire, sa transcription, bornée aux plus récentes quand l'échange est long (le prompt dit alors combien sont omises). Dans l'autre sens, quand la session te revient, ton agent à toi est rattrapé sur les itérations faites ailleurs pendant ce temps, et sur celles-là seulement : lui rejouer sa propre conversation le ferait douter de ce qu'il a déjà fait. La session peut ainsi faire plusieurs tours d'équipe.
Les pages de notes se partagent UNE PAR UNE, et pas par défaut. Tout le reste de ce que l'outil garde est un produit — une review, une règle, une carte du code —, et le produire pour soi seul n'aurait guère de sens : cela part donc en bloc. Une page de notes, non : c'est le seul endroit de l'outil où l'on écrit sans destinataire — un brouillon, un mot de passe collé le temps d'un test, ce qu'on pense d'une architecture avant de savoir le dire. Chaque page porte donc une case « Partager », décochée, et rien ne part tant qu'on ne l'a pas cochée ; la décocher retire la page du dépôt d'équipe — et des instances des collègues, puisqu'elle n'était pas à eux ; sa propre copie, elle, reste entière. Les pages déjà écrites restent à soi. La case n'apparaît pas en mono-poste, et la liste marque d'un pictogramme celles qui sont chez tout le monde. Partager une sous-page emporte sa page mère, et cesser de partager une mère reprend ses sous-pages : une sous-page est nommée par sa mère, seule elle n'arriverait nulle part. L'écran le dit plutôt que de le faire en silence.
Ce qu'on partage dit par qui. Une session, une question, une page ou une todo partagée porte la mention « partagé par Claire » — ou « partagé par moi » —, dans la liste comme dans l'éditeur. C'est celui qui l'a partagée, pas le dernier à l'avoir corrigée : une page que l'équipe annote reste celle de son auteur. Et c'est lui seul qui peut la retirer du partage ou la supprimer — l'effacer du dépôt l'effacerait chez tout le monde. La corriger reste ouvert à tous.
L'écran suit ce que l'équipe fait. Quand une synchronisation apporte le travail d'un collègue — une merge request qu'il a reviewée, une todo qu'il a cochée, une page qu'il a complétée, un agent à approuver —, l'écran ouvert se met à jour de lui-même, compteurs et badges compris, sans recharger la page. Deux garde-fous empêchent qu'une mise à jour écrase ce qu'on est en train d'écrire :
- une page de notes ouverte que le collègue a modifiée pendant qu'on écrivait ne s'enregistre plus par-dessus sa version : un bandeau nomme l'auteur et propose « Prendre sa version » ou « Garder la mienne » ; rien ne part tant qu'on n'a pas choisi ;
- le formulaire des réglages n'envoie que les champs qu'on a réellement changés : resté ouvert, il ne réécrit plus l'ancienne valeur d'un réglage d'équipe qu'un collègue vient de modifier.
Mettre une équipe en route.
- Créer un dépôt sur la forge, privé, par exemple
equipe/mergerie-data. Vide ou avec un README, peu importe : le bouton fait la différence tout seul. - Le premier poste — celui qui a déjà l'historique — colle son URL dans Réglages → Données partagées, puis clique « Cloner / rattacher ». Mergerie pousse ce que ce poste porte déjà : l'initialisation d'une équipe, c'est ça.
- Les autres postes collent la même URL et cliquent le même bouton. Le geste va dans les deux sens : le contenu de l'équipe descend — règles, vérificateurs, agents, notes, todos — et ce que ce poste avait accumulé de son côté monte avec, dans le même commit. Personne ne laisse ses mois de reviews à quai en rejoignant, et l'écran dit combien de documents sont partis.
- Chacun vérifie que git le connaît (
git config --global user.name) : c'est cette identité qui signe les commits, et c'est elle qui répondra plus tard à « qui a écrit ça ? ». Sans elle, rien n'est commité, et l'écran le dit.
Au quotidien, on ne fait rien. Toutes les n secondes (30 par défaut), l'outil envoie ce qui est nouveau et récupère ce qui l'est chez les autres. Le pied de page affiche ↑2 ↓0 et l'heure de la dernière synchro ; le survol dit dans combien de secondes part la prochaine, et un clic force un tour sans attendre. Hors ligne, tout continue de marcher : les commits restent locaux, le témoin passe à l'ambre, et le retard se rattrape au retour.
Avant de rattacher, on te dit ce qui part. « Cloner / rattacher » et « Tout ré-envoyer » ouvrent d'abord un récapitulatif : dans quel sens va l'échange, ce qui part par famille, ce qui reste sur ce poste (les sessions et les todos sont privées par défaut), combien de documents le dépôt porte déjà, et fichier par fichier combien seront ajoutés, modifiés ou laissés tels quels. Supprimés : aucun — l'envoi écrit, il ne supprime jamais ; le travail d'un collègue est lu et ajouté chez toi AVANT que quoi que ce soit ne parte.
« Synchroniser » n'envoie que ce qui a changé. C'est ce qu'on veut au quotidien, mais ça ne remet rien dans un dépôt vidé à la main : la file des écritures est vide, donc il n'y a rien à envoyer. Pour ce cas-là, il y a « Tout ré-envoyer », qui réécrit tout ce qui se partage.
Une synchro ne peut pas vider ta base. « Un fichier parti emporte sa ligne » vaut pour UN document supprimé. Pour un dépôt remis à zéro — un push --force, un projet recréé sur la forge — la même règle effacerait tout d'un coup. Une passe qui ferait disparaître plus de la moitié de ce que le dépôt porte (et au moins dix documents) est donc refusée : rien n'est supprimé, et le témoin passe au rouge avec la raison. Un « Cloner / rattacher » réécrit alors ce qui manque.
Et si deux personnes modifient la même chose ? C'est rare par construction — un fichier par objet, nommé par un identifiant qui ne dépend d'aucun poste : deux postes ne se croisent que s'ils ont vraiment modifié le même objet. Quand ça arrive, la version distante l'emporte, et la vôtre est gardée : Réglages → Données partagées la montre avec deux boutons, Reprendre la mienne et Garder la leur. Jamais de rebase en plan, jamais de marqueur de conflit dans le dépôt, jamais une commande git à taper.
Ce que git offre en prime. Sur une page de notes, un bouton Historique liste qui l'a modifiée, quand, et montre le diff. Aucune table de versions n'a été écrite pour ça : l'information existe parce qu'on est passé par git.
Les agents planifiés ont un exécutant. Trois instances allumées lanceraient trois fois le même agent — et l'équipe paierait trois fois. Le formulaire d'agent propose donc un champ Exécutant : seule l'instance de cette personne honore l'horaire. Sans exécutant, l'agent ne tourne qu'à la main, et c'est le défaut.
Le codage hors dépôt voyage à moitié, et c'est voulu. La session se partage — ses passes se relisent —, mais /Users/moi/projets/api ne désigne rien sur le Linux du collègue. Sa carte affiche donc le nom du dossier et son propriétaire, et « Relancer » est refusé plutôt que de faire travailler l'agent dans un homonyme.