Reviews
This page is generated from docs/guide.en.md · Edit this page on GitLab
The three stages of one merge request, behind a segmented filter — To review · Reviewed · Done — with a shared search (title, author, project, ticket, number: "!260"). Where to start. A dropdown arranges the queue — usual order (a ticket in review comes first), smallest first, oldest first, lowest score. The size and the age are written on every card; what was missing was being able to use them. The choice is remembered, and it sits on the same row as the author chips: who, and in which order, are two ways of narrowing the same queue.
What asks for nothing more is counted in the morning brief: a score above the convergence threshold, a green verdict that is not stale, and no ticket standing in the way — three columns already in the database. The tool merges nothing; it says how many merge requests are only waiting for a decision.
A merge request in conflict says so on its card, and the badge opens Git → Merge prefilled in the direction that unblocks it (the target branch into the MR's branch). Next to it, Update with the AI opens the coding session modal already filled in: the MR's branch, its target branch as the base, automatic push unticked, the label (“MR !N: update … with …”), and the instruction — first understand what the branch changes and why, merge the target's current state into the branch (git merge), resolve each conflict keeping what the target brings and the branch's intent, check, commit, do not push. The instruction says in so many words to add commits to fix the conflicts, with no rebase or amend: the history already pushed stays intact, and nobody has a force push to do. You re-read the instruction, launch, re-read the diff, then Push — normally, without forcing. It works on a colleague's merge request as well as yours; Update with main on a project line stays the shortcut with no instruction to re-read, for merge requests born from a session.
A merge request behind its target says so too, without waiting for a conflict: the card carries "N commit(s) behind" — what the target branch received and this branch never saw. It still merges, but its code never ran with those commits; the badge opens Git → Merge as a conflict does, and Update with the AI is there as well, with an instruction that states the delay rather than a conflict that does not exist — and merges the same way. The count comes from the forge (GitLab's diverged commits count, GitHub's base...head comparison), read at discovery — one call per open merge request, capped per round — and when the merge modal opens. "Not known yet" shows nothing: a branch from a fork, or a silent forge, never becomes "up to date" by default.
Two merge requests that overlap say so before the conflict. An overlap is a fact: two open merge requests of the same repository, towards the same target branch, that change at least one file in common. The card then carries overlaps !214 · 3 files · 2 d (several: overlaps 3 MRs), before "in conflict"; the report header repeats the badge. Clicking opens a panel anchored on the card: one line per overlapping merge request (number, title, author, age, score when a report exists), which leads to it in Reviews, the shared paths below it, monospace, folded past ten, and at the foot Fetched on <sha> · 4 min ago — on which commit and when the list was read. Nothing is judged, nothing recommended: only git knows whether there will be a conflict, the tool shows that two branches are going to meet and the human decides the merge order. The file list of every open merge request is fetched at discovery, never at display time — the diff a review already stored when it is about the current head, otherwise the local clone, otherwise one forge call per merge request, capped per round (most recently active first, the rest at the next round, the log says so) — and invalidated as soon as the head SHA moves, like the "stale" badge. Until a merge request has its list it shows nothing, never "no overlap"; a list of more than 5,000 files (a massive migration, vendoring) is not stored, and hovering the ⋯ button says not fetched · too many files. No AI call, no token: the three settings live in Settings → Merge Request → Discovery.
And how many test files it changes. Next to the size, the card says 14 files · 3 tests — discreet — or 14 files · 0 tests, emphasised like "stale", when the merge request changes at least N code files (3 by default, adjustable) without touching a single test file. Below N, or when everything is neutral (documentation, images, lockfiles, tooling — and a bumped submodule, which is a commit pointer, not a written file), nothing: a two-line fix carries no badge. A file is a test or is not, by path patterns (**/*.test.*, **/tests/**, **/*_test.go…), resolved repository → group(s) → global settings → shipped defaults, a filled level replacing the one above; it is computed on the overlaps' file lists, at display time, without AI — files counted, never a coverage nor a "tested". The panel lists the tests touched, names the patterns that applied (a link leads to the setting: a false 0 tests on a Go repository is fixed in two clicks) and says on which commit the list was read. Without a fresh list, nothing — never a false 0 tests. The badge never blocks Merge, never changes the score, never triggers anything.
And which dependencies it adds. After the tests, the card says +2 dependencies — emphasised as soon as a direct dependency enters the project, · 1 major when a major bump can be read (^3.x → ^4.x) — or 3 dependencies changed, discreet, when versions move or packages leave without any entering. It is the second question in front of a merge request produced by an agent: a package added for thirty lines, the first library that came up, a name that does not exist. An added dependency is a manifest line that did not exist before, read by comparing the − / + lines of the manifest's diff — a diff the forge already sends when the files are fetched, of which the manifests' alone is now kept, with no extra call, no AI, no registry. Recognised manifests: package.json, composer.json, requirements*.txt, pyproject.toml, go.mod, Cargo.toml, Gemfile, pom.xml, build.gradle*, *.csproj, at any depth (a monorepo gives one section per manifest); lockfiles do not count. The panel lists one line per dependency, in monospace — left-pad ^1.3.0 added · prod, axios ^0.27.2 → ^1.7.0 major · prod, moment removed · dev —, added first, names the manifest patterns that applied (a link leads to the setting) and says on which commit the diff was read. No link to npm or PyPI: the tool recommends nothing, the name copies. A package.json whose scripts alone change carries nothing; a manifest of an ecosystem that is not analysed is said "changed (not analysed)", never counted; a manifest diff over 200 KB is not kept and the ⋯ button says so; without a kept diff (a fetch older than this version — the next round picks it up), nothing — never a false "no dependency". Nothing is judged or blocked: no score, no licence, no CVE.
And what the public registry knows about it: +2 dependencies · 1 unknown. This is the one case where adding a dependency is almost always a mistake — a name the agent made up, a homonym one letter off, a package published last week — and nobody checks it by hand. The registry check (unchecked by default, see Settings → Merge Request) asks, for each added dependency only (never the changed or removed ones), what the public registry of its ecosystem knows: unknown (the registry answers 404: · 1 unknown on the card), recent (first published thirty days ago or less, adjustable threshold: · 1 recent), or long known (nothing on the card). In the panel, each added line says it in words, never an icon alone: left-pad ^1.3.0 added · prod · unknown to the public registry npm, fastjson2 … first published 3 days ago (npm), lodash … published since 2012 (npm). The rule is non-negotiable: the registry answered, or it did not, and the tool says which — a timeout, an error, a 503, the round cap, an ecosystem with no registry set give registry unreachable (pypi.org, timed out) or not checked · round cap reached, never "unknown". A company package (@docaposte/*, an internal Composer vendor/*, a Go module on a private host) is no alert: the private package patterns (global, per group, per repository) and the clone's own configuration (.npmrc with registry= or @scope:registry=, composer.json with repositories, GOPRIVATE in go.env, pip.conf with index-url) mark it not checked · probably private package (.npmrc) without asking anyone — and the panel's footer leads to the patterns: a false "unknown" is fixed in two clicks. The footer also says Registries contacted: npm · 4 min ago, or Registry check disabled. Eight registries, one per ecosystem: npm, Packagist, PyPI, crates.io, RubyGems, the Go proxy, Maven Central, NuGet; the check runs in the discovery round, never at display time, at most thirty names per round (adjustable), cached by name — the same dependency added by ten merge requests costs one call, an "unknown" is re-checked after 24 h, a "known" after seven days. Nothing is judged: no score, no blocking, no near-name comparison, no link to the package page — the name copies.
A merge request that carries another one says so: contains !214. This is the stacked merge request: you start from a colleague's or an agent's branch, add your work, open towards main. The forge shows an ordinary merge request with the diff of both; nothing says that 220 of the 300 lines are already under review elsewhere, nor that the second one will change size the day the first one merges. A merge request contains another when the set of commits of the second (target..source) is included in the set of the first — a git fact, compared in SQL, with no AI call at all. The containing one carries contains !214 (several: contains 2 MRs), the contained one contained in !219, always together; a merge request that targets another one's branch carries based on !214 (the forge already shows it in the target, it is repeated in the same place); two merge requests with identical commits are twin of !220. All of it discreet, right before "overlaps" (a contained merge request necessarily overlaps the containing one; stacking is more precise and comes first): stacking is not a problem, it is an organisation — the merge order is already chosen, the tool shows it, the human merges in that order or not. Clicking opens an anchored panel: the linked merge request (number, title, author, age, score when a report exists — the row leads to it), 12 shared commits · 4 own commits, and the own diff — Own diff: 4 files, the paths the containing one touches and the contained one does not, what the reviewer has to read here and not there, computed from the file lists when the panel opens (own diff not computed when one of the two lists is stale); a chain (C contains B contains A) reads link by link, deepest first. When the contained one merges or closes, the badge leaves the containing one at once; if it was merged by squash or rebase, its original commits are still in the branch: "N commits behind" and Update with the AI take over, and the panel keeps contained !214 · merged 2 h ago for seven days — the explanation of the lag that just appeared. The commit list of every open merge request is fetched at discovery, in the same round and under the same cap as its files (no second counter) — the local clone when it holds both branches, no network; otherwise one forge call per merge request, pages included — and invalidated as soon as the head SHA or the target branch changes. Without a fresh list, with a refused list (more than 500 commits: such a branch necessarily contains others) or a truncated one (GitHub cuts at 250), nothing — never a false "independent", never an inclusion computed on a partial list. Two branches with different commits but the same diff (after a rebase) do not contain each other: that is true, and that is what is said. The report of a containing merge request receives, at the head of its context, a fact sentence — This merge request contains !214 (open, to review): 12 commits and 9 files are already submitted there. — so the review bears on the own diff and refers to !214 for the rest; it reads in clear in the report's Context dialog, exactly as the AI received it. Nothing in the brief; the badge changes neither the score, nor the verdict, nor the ranking, and never blocks Merge. One setting, under Settings → Merge Request → Discovery.
The ticket's status reaches every merge request, not just watched tickets: discovery already reads the whole issue for its context, so it keeps its status too — at no extra call.
Three chips above the queue sort by author: All · Mine · Other people's. A tech lead looks first at what the team is waiting on, a developer at what they pushed. The token's account is read once per forge; without it — a token that cannot read its own account — the chips do not appear at all, rather than sorting on a guessed identity.
The card says who carries the merge request, as the forge sees it. The requested reviewers (eye) and the assignees (silhouettes) read at discovery each get their own chip — three names at most, the rest in the tooltip — and the number of 👍 (GitLab upvotes, GitHub +1 reaction) a third one: how many colleagues already said "fine by me" without a formal approval. Nothing shows when nobody is named and the count is zero. On GitHub the 👍 are not in the pull request list: discovery reads the repository's issue list, one more call per repository, and a failure of that call leaves the count at zero without blocking discovery. The assignment itself happens on the forge: Mergerie reads it, it does not replace it.
Fetch new MRsqueries the forge and fills the list (filtered by pattern). The automatic refresh does it for you (every 5 minutes on a new database — see Settings), and opening the Reviews tab runs a discovery by itself when the last one is older than that interval. Repositories whose fetch MRs box is unticked (Settings → Repositories) are skipped by this search: the merge requests already fetched stay in the queue, only new ones stop coming in. Not to be confused with enabled, which removes the repository from everywhere.Review N MRsruns the AI review over the whole queue; past 5, a confirmation reminds you that each MR costs one AI call.Reviewhandles a single MR.- Review with or without an explanation. By default a review produces two things: the report (findings + score) and a teaching explanation (a second AI call, Explanation tab). You can skip it to go faster and spend fewer tokens: Settings → General → “Generate the teaching explanation” sets the default, and the small ▾ menu next to
Reviewlets you override it for one MR (Review + explanation/Review without explanation). If the explanation is missing, aGenerate the explanationbutton on the report produces it on demand (a single AI call, without re-running the review or creating a new version). - Take the reviewer with you. Settings → Merge Request, “Take the reviewer with you” section under the form: “Export the reviewer as a skill” downloads a self-contained Claude Code skill — a single
branch-review/SKILL.md, no script and no reference to Mergerie — that does the same review on the current branch of a cloned repository: the team's review template word for word, the active review rules with their condition and scope, the score out of 10./branch-review [target]: the target is the branch the work is meant to land in (the repository's default branch by default, read fromorigin/HEAD; the skill asks when several are plausible); the source is always the current branch. The agent runsgit fetchandgit diff origin/<target>...HEADitself (the diff from the common ancestor, the one a merge request would show) and reads the commit messages as the intent. The report is filed under.branch-review/<branch>/<branch>-<YYYY-MM-DD-HH-mm-ss>.md(one sub-folder per branch, one file per review, the diff deleted once the report is written). Drop it in.claude/skills/of the repository or of the machine. - Review without thinking about it. Settings → Merge Request → “Automatically review a merge request when it arrives” sends every newly discovered merge request out for review, unasked. Unchecked by default, and capped even when checked (“At most N automatic reviews per MR discovery”, right under the checkbox, 5 by default): each review is a billed AI call, and the first discovery of a fresh install brings in every open merge request you have. Merge requests beyond the cap keep their
Reviewbutton, and the server log says how many did not start.0= no limit. “When it arrives” means when it arrives: a branch moving forward triggers nothing — re-reviewing stays a deliberate gesture, and an incremental one. - A merge in progress says what it is catching up. You arrive on this screen from a merge request's “conflict” badge: the merge's row therefore carries its number, its score and its ticket, and leads there. Once committed, a link opens the merge's diff in the same window as “Compare” — after thirty conflicts resolved one by one, “what does it give, all told?” needed a terminal.
- Merge one branch into another, conflicts included.
Git → Merge: pick a repository, the branch to merge and the one to merge it into, and the tool prepares the merge. The shared clone is never touched — everything happens in a workspace of its own, so a review or a session running alongside never finds a half-merged repository. When there are conflicts, the screen takes them file by file and conflict by conflict: the destination branch's version and the merged branch's version, one under the other, each withKeep, plusKeep both. What you keep is highlighted, so you never have to re-read the buttons to know where you stand. No<<<<<<<marker is ever left for you to decipher. If neither side will do,Write it myselfopens the result of your choices in a free text field: you fix it, and that text is what gets saved. Each side shows the date and time of its last commit, aFullscreenview puts the whole file three times side by side, andAsk the AIproposes a resolution for every conflict at once, to keep or ignore one by one — see Git → Merge below. Once everything is resolved,Commitopens a dialog with the message already filled in (Merge branch 'x' into y, plus the list of files that were in conflict) — you read it and confirm. ThenPush, after a confirmation, sends the merge to the destination branch. The two gestures are separate, and nothing goes out before the second one.Abandonputs everything back: the destination branch has not moved an inch until you push. The catch-up is also offered from the merge dialog: it asks the forge as it opens, says in red that the merge request is in conflict, and carries the same button. Both paths ask for the same confirmation — it is the same history rewrite, and where you clicked does not change what you are committing to. If the two branches share no common ancestor — a reinitialised repository, a branch made with--orphan,masterandmaineach with their own root — the tool says so in plain words and offers to do it anyway. Git refuses by default, and rightly so: merging two unrelated histories juxtaposes two projects, usually with conflicts everywhere. In demo mode the Merge tab genuinely works: the demo data includes a small real git repository (groupe/tarification) with two branches editing the same line. The other demo repositories point at a fictional forge and cannot be cloned; this one can. - Pull the verification report into a follow-up. The verification broke tests and you want the AI to fix them.
Fix (AI session), from the report, opens a new session; from the session that produced the branch, what you want is a follow-up. SoSend a follow-upcarries aUse the verification reportbutton that fills the field with exactly the same prompt — the broken tests, their messages, the commits that were tested. It only shows up if the latest verification is red and attributable to these branches: an already-red base is not your doing, and asking the agent to fix what it did not break would send it into unrelated code. - Catch up with the starting branch. The session produced its branch and its merge request, then
mainmoved on: the forge shows conflicts. TheUpdate with mainbutton then appears on the project's line — only when the forge reports conflicts, never permanently — and replays the session's commits on top of an up-to-date starting branch — arebase, not a merge:main's history is kept exactly as it is and your changes go back on top. When git stops on a conflict, the AI settles it, told to keep whatmainbrings and reapply the branch's intent on top; that is the whole point of the button, otherwisegit rebasewould do. Nothing is pushed: a rebase rewrites history, sending it needs a force push, and thePushbutton — a second, deliberate gesture — is what decides. If the resolution does not converge (or no agent is configured), the branch is put back exactly as it was: a rebase left half-done would block the clone for everything else. The same catch-up is offered inside the merge dialog: on opening, the forge is asked, and if the merge request is in conflict the dialog says so in red — naming the branch — and carries the button. You learn about the conflict before clicking “Merge”, not in the refusal that would follow. From the queue (a merge request that did not come from a session) the conflict is announced the same way, without the button: there is no session branch to replay. Forcing is decided in thePushconfirmation, by a “Force the push (--force-with-lease)” checkbox. It is unchecked by default: forcing rewrites a published branch, and that is not decided for you. It arrives pre-checked only when we know a normal push will be refused — the branch has just been caught up, its history was rewritten. Left unchecked, the push goes out normally and the forge refuses it: that is the right answer, and the refusal shows on the project's line. Checked, it is--force-with-lease— never--force: a commit pushed to the branch since the last fetch makes the push fail instead of disappearing. A teammate's work is never silently erased. The project's line also carries the same “in conflict” tag as the merge request queue, next toUpdate with main, when the forge has actually flagged a conflict — the button offered the fix, nothing said why it was there —, and the tag and the button leave with the conflict: a successful catch-up clears them, no push needed. The catch-up runs in the background, and a toast follows it to its end, success or failure, saying that a force push is next. Every remedy button of a failed project (“Catch up with the base and retry”, “Resolve the conflict”, “Start from a fresh agent session”, “Re-clone the repository”) explains itself on hover. - Reach the session that produced the branch, from Reviews. When a merge request's branch comes from a coding session this workstation knows, its card — to review, reviewed or done — carries the
Session #Nchip (the most recent on that branch; "running" while it runs), and the ⋯ menu offersOpen coding session #N. Clicking lands on its card in AI Dev, even when it is archived or hidden by a filter: the list reveals it instead of leading nowhere. On arrival the card keeps an outline until you click elsewhere (or press Escape), even while the list re-renders, and a banner at the top says "You are on session #N, from merge request !12 of grp/app, branch feature/x", withShow the cardto scroll back to it. The report header carries the same chip. A branch without a session carries nothing. And the other way round: on a session's card, the project line'sMR !5 · 6.0/10chip leads to the merge request in Reviews — its card when it is to review (marked the same way), its report otherwise; the↗link to the forge stays next to it. - Pull the review report into a follow-up. Once the merge request has been reviewed you often want the AI to work through the findings. The report's
Let the AI fix the codebutton opens a new session for that; from the session that produced the branch, what you want is a follow-up — the agent picks up its own thread instead of rediscovering the code. So onSend a follow-upaUse the review reportbutton fills the field with the same prompt (“apply the relevant fixes from this review”, report included). It only shows up when there is a report, and it asks before overwriting a draft you already wrote. The text stays readable and editable: the button fills, you send. A multi-project session pulls in each project's report, named — its follow-up goes to all of them. - Follow a branch that keeps moving. Once the review is done the branch carries on: the report no longer describes the code that is there, and the merge request gets the
stalebadge. Settings → Merge Request → “Automatically re-review when the report goes stale” makes the review start again by itself at the next discovery, incrementally — the AI only reads what changed and gets the previous report as context. Unchecked by default: on a branch that moves ten times a day, that is ten calls. It is independent of the previous checkbox (arriving and moving are two different costs) and shares the same per-discovery cap with its own budget: a big push on merge requests you already know does not eat the budget of the new ones. A merge request that was never reviewed is not concerned — no report, nothing to go stale. - Publish the report on the merge request. A review report stays with you by default: it lives in Mergerie and nobody else sees it. The report's
Publish to GitLab/Publish to GitHubbutton posts it as a comment on the MR, exactly as it sits on disk — that is how you hand the review back to its author without copying it over. A confirmation spells it out: what goes out is read by the whole team. Once published, the button becomesPublish againand carries the date of the first send, so you do not post the same text twice believing the first one failed. - Approve, resolve, and the forge's CI. The report gets published; what was missing is what the forge calls a review.
Approve, in the report's actions, posts a GitLab approval or a GitHubAPPROVEreview — with no comment at all, never a burst of inline remarks. The confirmation says what you are committing to (the score against the threshold, the verification verdict) without forbidding anything; the button then readsApproved ✓, read back from the forge, and is withdrawn in one click. On every discussion thread,Resolve/Reopencloses what a re-review saw disappear (GitLab: the discussion; GitHub: the review thread, through GraphQL — a general comment cannot be resolved there, and the tool says so). And every card carries the forge CI badge — GitLab pipeline, GitHub check-runs and statuses, aggregated into one word: green, red, running — with the link to what broke. It is not Mergerie's verdict, which stays a separate badge with a separate word. - Publish the report LINK rather than the report — only when the team shares a data repository. Six hundred lines copied into a comment, nobody reads them, and the next pass posts six hundred more. The report is already in the team's repository, in Markdown rendered by the forge: the
Publish the report LINKbutton posts a three-line comment pointing at its address, with the score and the pass number. The merge request stays readable and the report keeps a single copy, which everyone re-reads in the same place. The sync runs first: publishing a link to a file still sitting on this machine would send the team to a 404, which is worse than no comment at all — you would believe the work was done. If the repository cannot be sent (offline, rebase in progress), nothing is published and the screen says why. A data repository on a local path (shared drive, USB key) has no web address: the button says so rather than inventing a link. The automatic publication can do it too: under the “Automatically post the review report…” checkbox, a second one — “Post the link to the report, not the report” — changes what goes out on every pass. It does not decide whether the author is told, only the form; and if the link cannot be made, the report itself goes out, with the job log saying why. It only shows when a data repository is configured. The text of the comment is yours to write, just underneath — a team template: everyone posts the same thing. Left empty it is the shipped message, which follows the interface language (the field shows it as a placeholder rather than making you guess). Filled, it is taken word for word, with{url}(required),{note}— empty when the pass has none —,{v}the pass number,{iid},{project},{title}, and{blockers},{majors},{minors}— the number of blocking, major and minor findings of the pass, counted as on the card (resolved findings are left out); the list is written under the field. An unknown variable is left as written. A template without{url}is refused when saved, not when publishing: it would announce a report without saying where it is. The setting Settings → Merge Request → “Automatically post the review report on the MR” does it at the end of every review. It is unchecked by default: writing on other people's work is a decision. If it is checked and the forge refuses, the review is not lost — the report stays saved, and the job log says why publishing did not happen. A second checkbox appears underneath it: “Only post when there are blocking findings”. The report then goes out only when it holds at least one finding of severity blocker; the others are still saved and readable in the tab — nobody is simply disturbed on their MR over three minor remarks. A report with no finding at all does not go out either: the job log writes how many the pass held, which tells “nothing blocking” apart from a report whose findings block is missing. ThePublishbutton ignores this filter — an explicit gesture always goes out. - The card holds a single row of actions:
View diff·Context|Review ▾|⋯. The⋯menu gathers everything else — Let the AI code it, Verify, See results, Copy the reference, Refresh from the forge, Dismiss without review, Merge. Seven buttons of equal weight per card said nothing about which one was the normal path, and their number changed from one card to the next: the action column was never twice in the same place. The gestures are unchanged, one extra click for the less frequent ones. View diffopens the MR's diff before any review, in the full-screen viewer (tree, inline diff, navigation) — the repository is cloned on demand if needed. The left panel becomes a decision panel: if the MR is trivial,Dismiss without review; otherwiseReview. The point is to not spend an AI call on an obvious MR.Let the AI code itopens a coding session pre-filled on the MR's branch (working branch = source branch, starting branch = target branch).Linked projects(underContext): other repositories plus a branch that the AI reads read-only during the review, to flag whether the MR's changes might affect them (API signatures, contracts, schemas…). Mounted underai-dev-tools-internal/linked/, reset afterwards. Each linked project adds time and token cost — pick them deliberately.Contextattaches to an MR anything that helps judge it — ticket content, a specification, a business rule, an excerpt of a conversation — as text and/or a screenshot (paste with Ctrl+V). If Jira is configured (URL + email + API token, Settings → Jira), the ticket's summary + description are fetched automatically at discovery and pre-fill the context — the nominal case is zero clicks. What you type by hand stays a separate addition (never overwritten), and a Refresh button re-fetches the ticket on demand. All of it goes into the review prompt alongside the diff, and the button carries a ✓ once a context is saved.- Merging opens a confirmation with its options. Before merging, a dialog restates the MR and its target branch, and offers Squash (fold the commits into one) and Delete the source branch after merging. Both boxes are pre-ticked from what was chosen when the MR was created. It also restates what is known: the score, the blocking findings, the verification verdict, whether the report has gone stale, and the remarks written and never sent — those would go out with the merge request. Nothing is recomputed: these are the list's badges, under the same rules. Nothing known (a merge request opened outside the queue): nothing shown, rather than a line that reassures.
- Creating an MR opens the same family of dialog: pre-filled title, and the same two options. GitLab records them at creation time; GitHub cannot express them at creation — Mergerie then remembers them and applies them at merge, which the dialog says.
Mergemerges the MR directly, without a review — for a trivial MR: you confirm, and if the merge really happens the MR leaves the queue (marked done). Also available in the decision panel ofView diff, which is precisely where triviality is judged.Dismiss without reviewtakes an MR out of the queue, with a few seconds to undo.Refresh from the forge(⋯ menu of the card and of the report) re-reads this merge request alone on GitLab or GitHub, without waiting for the automatic refresh or running a discovery over every repository: title, branches, latest commit, conflicts, how far behind the target it is, draft, reviewers, assignees, 👍 (GitLab), and its state. A commit that landed since makes the report stale and triggers what discovery would have (the automatic re-review and the “on stale” verifications, when enabled); a merge request merged in the meantime gets its merged badge, one closed without merging its closed badge. The message says what the forge answered: refreshed, nothing new, new commits, merged, closed. On a merged merge request it also records the SHAs that let it be re-read (the merge-base of the time and the head, which the forge keeps even after the branch is deleted) and, when the repository is already cloned, fetches that head:Open the codethen shows the diff instead of an empty screen. Call budget: the MR's detail (one call), plus the changed files when the commit moved, and on GitHub the comparison with the target — never more than three.- A merge request with no common ancestor is still re-read. When the target and the source share no ancestor in the clone (target changed on the forge, target history rewritten, orphan branch),
git diff target...sourceanswers “no merge base”. The review andView diffthen re-read the merge request as the forge shows it, by the SHAs of itsdiff_refs(one call), and keep them on the row. When the forge has no base either (GitLab returnsdiff_refswithoutbase_sha), the two trees, target and source, are compared as they are: for a target re-imported identically, that is exactly what the branch changes; for two truly unrelated histories, the diff is large but true, and the log says so. When nothing allows a re-read, the error names the situation and the reason, instead of git'sfatal. - Jobs on the same repository run one after the other, in the order they were asked; a live log panel shows the commands, the output and the progress, with a Stop button (which also empties the queue — the confirmation says so), a stopwatch since the start and, once a rhythm is established, an estimate of the time left (it goes quiet rather than lie when the pace drifts).
- Jobs on different repositories run in parallel by themselves (up to 3 at a time): a review on repository A no longer waits for a session on repository B. Two jobs that touch a repository or a folder in common keep their order — a collision is refused, not arbitrated: two agents in the same clone would corrupt it —, a job whose scope is unknown waits for everything, and jobs launched by hand pass before automatic ones. The log panel lists what is waiting and still lets you promote a job to run alongside by hand when it is eligible. Each job running alongside gets its own tab in the panel, with its own Stop button; the tab stays after the job ends, so you can re-read the output. An interrupted job can be re-run from the queue.
- Edit your own comment. A comment posted from Mergerie — inline in the explorer or general on the MR — can be rewritten without going through the forge. Yours only: a colleague's are read-only.
- Full or incremental re-review.
Re-run the reviewdoes a full review (the whole diff). When the branch has moved since the last review (a stale MR), aRe-run (delta)button appears: the incremental re-review only reads what changed since the last reviewed SHA (reviewed_sha..current_sha) and supplies the previous report as context — the AI produces a complete, up-to-date report (score included) while reading far less diff (so fewer tokens). It falls back to a full review automatically when there is no usable delta (a force-push, say). Re-run re-reads the MR from the forge first: a colleague's review, arrived through the shared data repository, may target a head this workstation has not discovered yet, and a reviewed SHA that is not an ancestor of the head gets a full review, never a backwards delta. Re-running a review resumes the same agent session as the previous one: the AI remembers its analysis and focuses on what changed. - ⚡ Converge — the autonomous quality loop. A report's
Convergebutton starts an autonomous loop: review → AI fix applied to the code (commit + push on the branch) → incremental re-review of the delta → and round again until the score threshold (8/10 by default) or the pass ceiling (3 by default). You push a mediocre MR, you come back later: it has gone from 5.8 to 8.4 in a few iterations, with the whole history versioned (v1 → v2 → v3, scores, findings resolved and appeared, each fix commit readable). Guard rails: it stops if the score drops or stalls, the pass ceiling is strict, and there is never an automatic merge — the loop prepares, you review and merge (the review and the fix come from the same model: a score reached autonomously is not a score validated by a human). Threshold and ceiling are set globally (Settings → Merge Request → Convergence) and can be overridden at launch. A notification tells you when it ends (“Convergence finished: 8.4/10 in 3 passes”). If the “the AI may ask questions” option is on and the AI hesitates during a pass, the loop pauses (notification) instead of guessing: you answer, then you start Converge again — which resumes the same session. The verifier's verdict beside the loop — never an exit condition: after every pass, the verifier that carries the merge request (the session's, or one set to re-run when its verdict goes stale and covering the repository) runs inside the job, with a throwawayHOME, and the convergence panel shows its latest verdict — green, red, or stale when the branch moved since. A verdict that turns red is written in the journal and the loop goes on: green tests do not mean everything is right, and the score threshold keeps the last word. - Modification requests are kept. The
Ask the AI for a changesection lists the requests already made on this report, with their date, and a button opens the report each one produced (the matching version). You can therefore find what was asked to arrive at a given report, instead of reconstructing it from memory. - Ask a question about the review, without rewriting it.
Ask the AI for a changeregenerates the report and makes it one version more: asking why a finding is blocking therefore cost you the report you were reading, and the score could move along the way. TheAsk a question about this reviewsection is for asking without risking any of that: the answer joins the exchanges under the report — question and answer together, most recent first — and neither the report, nor its score, nor its versions change. This is not an instruction given to the AI: the code that answers writes nowhere else, so an agent rewriting the report of its own accord would have no effect. A question resumes the review session when there is one: the AI has already read the diff and its own report, so the answer costs a question rather than a fresh read.Re-read every exchangeopens them in the same column view as a session's iterations — with its search, its pins and its names. Exchanges go with the report if you delete it: they quote it, and re-reading them without it would no longer say anything about what had been asked. - On a report: regenerate the report, comment on the MR, merge, re-run the review, mark done, delete the report (the MR goes back to “to review”), and above all Have the AI fix the code — which opens a coding session pre-filled with the report injected into the prompt, so you can adjust before launching. If the branch came from a coding session, its session id is pre-filled: the AI picks up the thread of its own work instead of rediscovering code it just wrote. It is a suggestion, not a rule — the link is inferred from the repository and the branch, which is not proof: clearing the field starts from a fresh session.
- Every review pass is kept. Re-running a review or regenerating a report no longer overwrites the previous one: a version selector appears in the report from the second pass on (
v2 — current · 20/07 14:30 · 7.8/10) and lets you re-read an earlier review, with a banner reminding you it is read-only. - Resolution tracking between two passes: from the second review on, a banner shows the findings resolved · persistent · new and how the score moved (
score 6.4 → 7.8). A finding is only called “resolved” if the line concerned actually changed between the two versions of the code (checked through git); otherwise it is marked “gone” — the AI may simply not have reported it again. The findings come from a structured block the AI emits alongside the report (invisible when reading); your review prompt template is not modified, the instruction is added on the fly. The Stats tab turns this into a resolution rate per project. - Findings become remarks in one gesture. Eight findings meant eight trips through the viewer: find the file, scroll to the line, click “+”, retype the finding. Two buttons above the list —
Turn into draftsandThe N blocking ones— turn them into inline comments as drafts, one per finding, attached to their line; and each finding carries its own draft button, next to “ask why” and “fix this”, to keep one or two out of forty. Nothing is sent: you re-read, adjust, and send them as a batch as usual. On a single finding, the message says why nothing was created — outside the diff, an identical draft already there. Four things are left aside, and the tool says so: resolved findings (commenting what was just fixed is noise), those without a file and a line (they would have nowhere to attach), those that already have an identical draft — clicking twice is the most natural gesture in the world — and above all those that fall outside the diff. That last case is the most frequent, and the only surprising one: a report has every right to talk about a line the branch did not touch (“this function is now called withnull”). An inline remark does not: it attaches to the diff, the forge refuses a position that is not in it, and the screen would meanwhile show it stuck to a line nobody modified. The crossing is done with the diff of the reviewed version — the one the findings come from — and a line unchanged but present in a hunk is anchored with both of its numbers, without which GitLab refuses the position. - The header says which commit the report covers (
cf4fea90), and the version selector repeats it for each one: two passes of the same afternoon differed only by the clock, while they describe two states of the code. - The convergence banner names its best version (“best: v3”) and takes you there in one click — after three passes, the report on screen is not necessarily the one holding the best score. When the loop stopped on a question, it says that too: it will not resume on its own.
Reviewapplies to what is on screen — and to the selection when there is one. It used to launch the whole queue whatever the search and the filters: you searched “payment”, clicked, and thirty-seven unrelated reviews went with it. The label says what is about to go.- An MR that is no longer open on the forge carries the merged badge; the Merge button disappears.
- Filter by score colour. Under Reviewed and Done, four checkboxes above the list — green (≥ 7/10), amber (4 to 6.9), red (< 4) and
— no score— combine: “show me the red and the amber ones” is two clicks, and each carries the number of merge requests it will bring up. The choice is remembered between visits; unticking the last box brings everything back, rather than leaving an empty list with no way out. The summary on the right follows the filter. The To review stage has no such boxes: an MR only returns there once its report has been deleted, so there is no score left to filter on.— no scoreis a box like the others, and it exists for a reason: the score is not computed, it is read back from the report. When the AI writes none, the card shows—— and without that box it left the list at the first filter, with no counter and no box to call it back. You then took it for lost, or never reviewed.
- List and report scroll independently. Going down the list to pick another merge request no longer carries the report off the screen — you look at both together.