Mergerie
Contents

AI Dev

This page is generated from docs/guide.en.md · Edit this page on GitLab

A search at the top of the list (prompt, project, branch, folder) filters the sessions of the current sub-tab — useful as soon as they pile up. It resets when you switch sub-tab, so as not to contradict the counters, which show totals.

The lists put what just finished running at the top — and above everything, what is running right now. It is the execution end date that decides, not the last modification: fixing a prompt, pushing a branch or tidying a session does not lift it above the one that just ran. A session that was never run sits at its creation date.

Two sub-tabs. In both cases a session covers one or several projects, each with its own branch, and its creation date is shown. The repository is picked from the keyboard (a selector with search), like the branches — which matters when the list of repositories is long.

Tidying finished sessions. A finished session can be hidden without being deleted; a “Show hidden sessions” checkbox (whose state is remembered) brings them back, and a counter reminds you how many are filtered out. This applies to coding, out-of-repo coding and exploration alike. In the list, a long prompt is folded to three lines with a “Show more” that unrolls it.

“Plan first”: read, approve, then code. Ticked in the session modal (repository coding only), the first pass touches nothing: the agent reads the repository and returns a plan — files, steps, risks, open questions — as an iteration marked plan. The project line says plan to approve, offers Read the plan, an optional remark (“keep the API as is”), and two actions — the same ones in the view Read the plan opens, where the feedback field replaces “Prepare a follow-up”: you re-read a plan to correct it or approve it. Regenerate the plan with my feedback sends your feedback to the same session, which rewrites the whole plan with it, still without coding: the line stays plan to approve, with a new plan iteration — as many rounds as needed. Approve and code: the same session resumes and carries the plan out, remark included, then commits as usual. Relaunching a planned session plans again from scratch. With Claude the pass runs in its plan mode whatever the secure/yolo switch says — this is what the session asked for, not a restriction; another backend follows the instruction, and the next pass starts from a clean clone anyway.

“Stop and resume with this instruction.” While a session runs, the follow-up field no longer hides its button: it becomes Stop and resume with this instruction. The pass stops, and the instruction goes back as a follow-up — into the same agent session when its handle is known (Claude gives it before it says a word), otherwise into a fresh one that receives the task and the transcript. The instruction is kept as the card's draft until the follow-up has left.

The journal stays short, the annex holds the rest. An agent's message is cut at 600 characters in the job journal, an Edit is one line — Edit src/x.js (+12 −3) — and the agent's reasoning shows as a short ∴ line. Each of those carries a “… see” that opens the full text, or the diff of the change, in a panel; the polling never carries the content. Jobs run in parallel by themselves when they touch different repositories or folders: a review on repository A no longer delays a session on repository B; two jobs on the same repository keep their order, a job whose scope is unknown waits for everything, and jobs launched by hand pass before automatic ones.

“The AI may ask me questions” applies to all three flavours. Coding in a repository, out-of-repo coding and exploration: ticked, the option lets the agent stop in front of a decision it cannot settle instead of guessing. An exploration hesitates just like a coding session — “which of the three services do you mean?” beats a summary about the wrong one — and out of a repository it matters most: the agent works in place, with no branch and no commit to re-read.

What happens then, in all three cases: the session goes into waiting (neither finished nor failed), the questions appear on its card, you answer, and the work resumes in the same session — the agent keeps what it read. Two differences worth knowing: an exploration asks once for all its repositories (they share the session), whereas out of a repository each folder has its own, and answering one does not make the others work again. ⚠ While a question stands, nothing has been done: no summary saved for an exploration, no file touched out of a repository.

And if it is a colleague's session? Received from the shared data repository, it can be read but not relaunched from here: its project line carries "Take over on this machine" — or "Answer and take over on this machine" when its target is waiting for an answer. The dialog opens prefilled and locked on the essentials (their repository, their branch as the base, a proposed new branch, your settings), one field to fill — your instruction —, and a foldable box shows in full the first message your agent will receive: the whole history of their session, then your instruction. See Sharing with a team.

And if you answered in your terminal? “Resume in terminal” copies the agent session, so you can answer there and let the agent carry on — inside Mergerie's clone, which knows nothing about it. The I answered in the terminal button, next to Answer and resume, settles that wait: the questions go away, the todo closes, and nothing is re-run. The state is not guessed: on a repository session Mergerie re-reads the branch (the same machinery as Check branch state) — commits ahead and the project goes back to committed or pushed with its diff, nothing at all and it returns to to do. Out of a repository there is neither branch nor commit to question: the folder is returned to done, and what it contains is what your terminal made of it. Without this gesture the project stayed waiting forever, and the form offered to answer a second time — which would have sent the agent back over work already finished.

A session stopped on a question raises its own todo. When the AI interrupts itself to ask something, a high-priority todo is created automatically — "Reply to the AI — session #12", with the projects concerned in its note. The queue is free, nothing will restart, and the notification was dismissed long ago: the todo stays in sight, in Notes and in the morning brief. Answering closes it (ticked, not deleted: what you did with your day is re-read in "Done").

⚠ On a multi-repository session it only closes when no project is waiting any more: answering the first does not settle the work, and a todo ticked too early makes you forget the other four. It stays an ordinary todo — you can tick, edit or delete it: the tool raises it and closes it, it does not take over what you did with it.

Duplicate a session. On the card, next to Edit, a button opens the form pre-filled from that session — coding, exploration and out-of-repo coding. There is no identifier behind it: saving creates a new session instead of overwriting the one you copied. This is the gesture of running the same instruction on another repository, or starting from a past session with two words changed. Everything is copied — prompt, label, commit message, repositories or folders, base branch, options, verifier — except the following, stated under the prompt:

  • the agent session is never resumed: a copy starts a fresh conversation, not the continuation of the original one;
  • in coding, the working branch is shifted (feature/x → feature/x-2, then -3 if that one is taken) because two sessions on the same branch would tread on each other, the second committing on top of the first's work. In exploration, the branch is the one you read: it is copied as is, shifting it would point at a branch that does not exist;
  • the images attached to the original are not copied; their number is stated.

The buttons are those of a creation — Create and run alongside Create without running, as everywhere else: a button that changed meaning depending on whether you create or copy would be a trap. Everything stays editable before saving: it is a proposal, not a carbon copy.

The form tells four things, in order. It is the same form for all four flavours and rearranges itself for the one you are creating — but the sequence does not change: where (the projects and their branches, or the root folder and its projects — the “the AI edits in place, no commit” warning follows that choice, not the bottom of the form), what (the Jira ticket that fills the prompt, the prompt, the attachments, then the label — optional, so after what it summarises), how the AI works (questions, the binary, when to launch) and finally once the code is written (commit message, auto-push, verifier) — last because it is chronologically last, and it disappears whole as soon as there is nothing to commit. Two discreet captions separate the last three groups; a free question shows none of them, it only has the request. “The AI may ask me questions when unsure” stays in plain sight, above “Launch later, on”, in the coding, exploration and out-of-repo forms alike: whether the AI may stop and ask is a decision you take for each session, not a setting to go looking for. The Advanced accordion (commit message, agent session to resume, skills, read-only linked projects) opens folded so the form fits the screen; one click unfolds it, and editing a session unfolds it by itself when one of its fields holds a value.

A label, optional. A short title when creating a session — coding, out-of-repo or exploration. A list is otherwise read through its prompt, three folded lines whose first words look alike from one session to the next; the label says what it is about where the prompt says what to do. It shows at the top of the card, takes part in the search, and can be changed later. Left empty, the card is exactly what it was.

⚠ The label is NOT sent to the AI, and is not used as a commit message. It is a filing title, written for the human scanning the list — not an instruction. Slipping it into the prompt would change what the agent produces without anyone asking, and two sessions with the same prompt but different labels would stop producing the same thing. A test keeps that door shut, including against a module that would start reading it.

The chosen commit message applies to EVERY commit of the session. When the Commit message field is filled it is the rule: the first run, every follow-up, the resume after questions and the convergence passes all commit under that message. It is what anyone who prefixes their commits expects — a ticket key, a team convention: a follow-up falling back on its own first line would break the rule exactly when nobody re-reads it, and the offending commit is already pushed. Left empty nothing changes: each gesture keeps its own default, which says what it just did (the prompt's first line for the run, the follow-up's own for a follow-up).

And when it is filled in after the fact — you run a session, you see a badly named commit, you fill the field and relaunch — the last commit is renamed: the AI finds everything already done and commits nothing, so without this the field you just filled would have nothing left to name. Only the message changes; the commit's contents are untouched and no extra commit appears. ⚠ Unless the branch is already on origin: renaming a published commit would rewrite a history the forge — and possibly a merge request, and possibly a colleague — already has. The job log says so, rather than staying silent or doing it behind your back.

A follow-up written while it runs, sent when you decide. The remark comes while you read what the agent is doing — not twenty minutes later, once the session is over and your mind is elsewhere. On a running session, Prepare a follow-up opens the same form as Send a follow-up, with Save the follow-up instead of Send: the text stays on the card, under your eyes, for as long as it has not gone out. You can reword it, delete it (clearing the text is enough), and Send the follow-up fires it in one click once the session is over. Applies to coding, out-of-repo and exploration sessions.

An attachment can be pasted or picked, in a follow-up as at creation time. The Attach a file button, or Ctrl+V for a screenshot. An image shows a thumbnail, a document shows a named chip — and that is the only difference between them: to the agent, a screenshot and a PDF are the same thing, a file to open. Works for all four flavours: coding, out-of-repo coding, exploration and the free question. Accepted: images, PDF, text (.txt, .md, .log), data (.csv, .tsv, .json, .yml, .xml, .html) and Office documents (.docx, .xlsx, .pptx, .odt, .ods, .odp, .rtf), up to 10 MB each. Anything else is refused with its reason, before anything is stored. The attachment belongs to that request: the follow-up prompt gets the ones from the initial instruction plus the one you just attached, but not those of an earlier follow-up — they illustrated something else, and a prompt announcing “here are the attachments” while showing the wrong one sends the agent off course. ⚠ A saved follow-up (draft) only keeps the text — that is what the database stores. The attachments stay on the open form and go out with the follow-up itself; a message says so when you save, rather than making them vanish silently. Reopening a session shows what is actually attached to it. The edit form does not show a count (“2 screenshots attached”) but the attachments themselves — a thumbnail for an image, a name for a document — openable in one click and removable with a cross, in all four flavours. Removing deletes the file from disk: that is irreversible, so it is confirmed. An attachment that came with a follow-up is drawn dashed: it does not belong to the instruction being edited.

⚠ The original NAME travels with the file into the prompt (“devis-client.pdf”), because pj_2.pdf teaches the agent nothing. On disk, however, the file carries a made-up name: a name coming from a form has no business in a path. And what the agent can actually read is up to it: a .txt or a .csv are safe, an .xlsx much less so — Mergerie provides the file, it does not convert it.

Or it goes out by itself, if you ask. A checkbox Send it automatically when the session finishes, under the text, arms the follow-up: it leaves as soon as the session has finished working, with nothing for you to come back to. The card says so — Follow-up armed instead of Follow-up waiting — and it goes out once only: the text is removed and the box disarmed before launching, otherwise the follow-up pass would find the same instruction on finishing and the session would loop. Nothing goes out after a failure either, nor on a session waiting for an answer.

⚠ Unticked, the box does nothing — and that is the default. The send button stays disabled for as long as the session runs, and an unarmed follow-up waits for your gesture indefinitely. Sending automatically is a choice made while writing the remark, never a side effect: the column is read only by the function that decides to send, and no module talking to the agent knows about it — two tests keep that door shut. If you picked a verifier, it waits for the automatic follow-up to finish: a verdict on code that is about to change again would be worth nothing.

Running again asks first. On a session that has already run, Run again opens a confirmation that says what is about to happen: the AI starts again from the initial prompt, on top of the work already produced, and anything asked since — follow-ups, answers to questions — is not replayed. The button sits next to the ones you use all the time, and one click too many costs a whole session. The very first run stays a single click: there is nothing to protect. The same applies to the Run again of one particular project.

Create now, run later. All four session flavours — coding, out-of-repo coding, exploration, free question — and sessions opened from a merge request carry the same two buttons: Create and run (the main gesture, one click) and Create without running next to it, to prepare the prompt and the targets and launch when you want.

Or at a date and time. The same modal — coding, exploration and out-of-repo alike — carries a “Launch later, on” field: a date and a time side by side, each with its native picker (a calendar, a clock), both typeable by hand; filling only one of the two is signalled under the missing one, like a passed date. Filled, the primary button reads Create and schedule: the session is created and waits, its card shows the date with a cross to cancel it, and editing the session shows and saves the date with the rest. A waiting follow-up can be scheduled the same way (“Or send it on…”): it then goes out by itself at that moment, whether or not “automatically at the end” is ticked — a follow-up has one trigger, never two. Launching a session by hand cancels its date, a date already past is refused, and the date belongs to the workstation that set it: that one launches, and catches up at the next minute if it was switched off at the time. Free questions are not schedulable.

Verify afterwards, without thinking about it. An optional Verify afterwards field when creating a coding session: the chosen verifier runs by itself, once, at the end — after convergence if you converge, after the coding run otherwise. You launch the session in the morning and find a verdict, not one more box to tick.

Only verifiers that cover every repository in the session are offered: a partial green would say nothing about half the batch, which is worse than no verdict at all. The list is rebuilt when you change projects.

A verifier reads what the forge exposes, so it needs pushed code. Picking a verifier ticks auto-push and says so; unticking auto-push drops the verifier. The server applies the same rule on its side — a screen is not a safeguard, and the API is callable without it.

Three refusals, silent for the session but written in its log: nothing was pushed, the verifier no longer covers every repository, or another verification is already running on them. And a failure to start the verification does not fail the session: the code is written and pushed, announcing an error would misrepresent what happened.

Resume an existing agent session. An optional “session identifier” field at creation time (coding, out-of-repo, exploration) makes the AI work inside that session instead of opening a new one — so it keeps all the context it has already built. Filled in, it also enables the “Resume in terminal” button. The field can be edited afterwards too.

⚠ The identifier FOLLOWS the passes. Resuming an agent session does not always continue under the same identifier: claude --resume opens a new one, carrying the whole exchange plus the turn just made. Mergerie therefore records, after every pass, the one the agent reports — otherwise two follow-ups in a row on the same project would both start from the initial state, and the second would ignore the first. It is also what makes “Resume in terminal” open the conversation as it stands, not as it was three follow-ups ago.

Enrich from a Jira ticket (optional). If Jira is configured (Settings → Jira), the dialog offers a ticket field — type a key, or a few letters and pick one of your tickets in the list it opens: picking one fills the key and fetches the ticket — with a Fetch button: the ticket's title + description are pulled through the Jira API and added at the top of the prompt as a context block — visible and editable before you launch. The number is pre-filled if the working branch already contains a key (e.g. feature/PROJ-1234-…). Available for coding and exploration.

  • Coding — the AI modifies the code. For each project: a working branch, and an optional starting branch (a dropdown with search; empty = the repository's default branch). The prompt is applied to each project, sequentially — one failing project does not stop the others. Each project then carries its own actions: Diff · Push · Create MR · Merge. The line also offers Review as soon as the merge request exists and has no report yet — the obvious next move, which meant going to find it in Reviews — and Use the console when a linked Jenkins job is red on that branch: the follow-up is filled with the last thirty console lines and the build number, exactly as Use the verification report. Jenkins keeps the verdict; the agent only receives the text to fix. Once the merge request is open, the project's line says what it became — score, verdict, pending comments — instead of a bare MR !216 ↗ that sent you back to Reviews, and Tell Jira comments the ticket with the merge request link then moves it to review when Jira offers the transition, behind a confirmation that names the ticket. A checkbox in the session dialog, unchecked by default, does it at every merge request creation — and its default, together with the template of the comment ({url} {iid} {project} {title} {branch} {target} {key}, with a live preview), lives in Settings → Jira. Diff opens the same full-screen explorer as the merge requests — the whole project tree in the middle, the entire file with the changes in place on the right (navigation from one change to the next, mini-map) — with, on the left, the AI's report instead of the review report. So you read what the AI says it did and what it actually wrote, side by side, in the context of the whole file rather than in a raw patch. A compact stage trail (pills created → commit → push → MR) on each row tells you at a glance where the project stands — handy on a multi-project session. Send a follow-up continues the session on the existing branches, without starting over — a fix, a clarification, a question about what was just done: the AI keeps all the context of the work already produced (likewise for a re-run of the session). On a multi-repository session, each project carries its own button: a remark almost never applies to all five repositories (“use AbortController here instead” means nothing elsewhere), and sending it to the whole session costs one AI call per repository to redo work that was already fine. The button on the card itself still addresses everyone. An exploration answers as a single whole: it does not narrow down to one repository. The button also shows up on a project that stopped without coding, as long as its AI session is still alive — an AI that pauses to ask “should I continue?” in plain text has committed nothing, and that button is the one that answers it. Its label carries the count of follow-ups already sent — “Send a follow-up (2)” — on every session, question and off-repo card. When coding ends, AI output shows what the agent says it did (like an exploration's answer) — useful to understand its work, or when nothing changed: if the prompt was incomplete and the AI answered instead of coding (e.g. “give me the file name”), its answer is surfaced directly in the project's error rather than an opaque “no change”. On the other hand, if the branch already carries the work — the case of a re-run after a failure that happened after the commit, a rejected push say — the absence of new changes is not an error: the session goes back to its “commit ready” state, with the diff and the MR creation button.
  • What the chosen repository already carries. As soon as a repository is chosen in the session modal, a grey line under the selector says N open MRs on this repository; when the session restarts from the branch of an existing merge request, its overlaps; and when the prompt names a path that exists in the clone (src/payment/, tva.js), the line becomes 2 open MRs touch src/payment/ (!214, !219). Information only: nothing is blocked, the session starts anyway. When the session restarts from the branch of an open merge request, the line also says The created branch will contain !214 (open, to review) — known before starting, so the target is chosen knowingly.
  • How many tests the branch changes. As soon as a session project is committed, its line carries 0 tests modified (emphasised) or 3 tests modified (discreet), from the branch diff and the repository's test patterns — before the merge request exists, when a follow-up "add the tests" costs the least. A session that only bumps a submodule touched no code: nothing. Outside a repository: nothing.
  • Which dependencies the branch adds. On the same line, 2 dependencies added (emphasised) or 1 dependency changed (discreet), read from the manifests in the branch diff — where a follow-up "drop left-pad, write the function" costs the least. The detail is on the merge request's card. With the registry check on, the line completes on the next render — 2 dependencies added · 1 unknown — under the same cache as the cards, ten names at most per session.
  • Read-only linked projects (Advanced). In coding, the session dialog lets you add other repositories as context: the AI reads them — their API, their schema, their contracts — to respect what they expose, without ever modifying them. A repository (with search, as everywhere a project is picked) and an optional branch (empty = the repository's default branch). Mounted as a symlink under ai-dev-tools-internal/context/ for the duration of the pass, reset afterwards — the same mechanism as a review's linked projects. A repository that is already a coding target of this same session cannot also be linked read-only. Optional — exploration has no use for it, it already sees all its repositories side by side.
  • Activity — what you launched, and what finished. The log panel exposes an Activity view: what ran, on what, for how long, and how it ended — a finished verification is read by its verdict (green ✓, red ✗, base already red, failed), never “ok” in front of a broken test suite, and Failures only keeps it when it is red; the log banner and the footer button say it in red as well. Each row names its object and takes you there in one click; a button reopens the log of a past job — the view stays on it while another job writes, and a job launched afterwards takes it back. What has finished since your last visit is marked, and the count appears on the button. Desktop notifications did not answer that question: they only live in the server's memory and are deliberately not replayed on load — so anything that finished with the tab closed existed nowhere. The footer's journal button says what is behind it even when the panel is hidden: amber and pulsing while a job still runs, green once done, red on a failure — hiding the panel (or its own auto-collapse a few seconds after a job ends) no longer leaves it looking the same whether the job is still working or long finished.
  • The project list opens folded. Past a few repositories, a session filled the whole screen and hid the others — which are exactly what you came to look at. A “Show the N projects” unfolds it, and the state is remembered per session: otherwise the automatic refresh would close it again every second and a half during a job. Applies to all three families (coding, out-of-repo coding, exploration).
  • Push all · Create all MRs. Two grouped actions, which only appear when they have something to do (the number concerned is in the label). Push all pushes, in a single job, every branch that is committed but not yet pushed. Create all MRs opens a merge request for each pushed project that has none: the dialog asks for the options once — squash, delete the source branch — and each MR reuses the session's commit message as its title, rather than demanding ten titles in a row. In both cases a failing project does not stop the others, and the summary names the ones that failed.
  • Run one project at a time. On a multi-repository session, each project carries its own Run button, and a session with several failures offers Re-run failed projects. Previously a session could only be re-run as a block: on ten repositories of which six had succeeded, that cost six AI calls to redo good work, and sent the agent back over code you no longer wanted touched. A targeted pass only reserves its own repositories, so two projects of the same session on distinct repositories can run in parallel. Re-running the whole session is still one click away — nothing became implicit.
  • Check branch state — repair without spending an AI call. When projects stayed in error although their work is already committed, a button on the session re-reads the real state of each branch: if it carries commits, the diff is regenerated and the project goes back to “commit ready” (or “pushed”), MR creation button included. Nothing is faked — a genuinely empty branch stays in error, with its message. Re-running the session would repair the same thing, but at the cost of one AI call per repository to redo work already done. The button only appears if at least one project is in error, and the operation goes through the job queue: touching a clone while an agent is writing in it would corrupt it.
  • Export an answer. The full-screen view of an agent's output (as of an exploration's answer) carries an Export button: HTML, Word (.docx) or PDF. The HTML is a self-contained document — embedded styles, no external resource: it reads offline and can be sent as is. The .docx is a real Word document (headings, lists, tables, code blocks), built without installing anything. The PDF goes through the browser's print dialog, where you pick “Save as PDF”: the rendering is the one you have in front of you, and Mergerie does not ship a 300 MB rendering engine for one button. In all three cases the document carries its title and its date: a file that gets forwarded loses its name long before its content.
  • Every iteration is kept. A session iterates (launch, Send a follow-up, answers to questions, convergence passes): each pass keeps the prompt actually sent and the matching AI output. An From the second pass on, AI output lists the iterations in a column on the left — each with its number, kind, date and the request that produced it — and shows the one you pick on the right. Nobody remembers an iteration by its number; you remember what you asked: a search field at the top of the column therefore searches those requests and hides the iterations that do not match, losing none of them — and the filter survives switching iterations. Re-reading an answer without knowing which request it answered teaches nothing: the two are therefore shown together. A single iteration shows no column — there is nothing to pick. Applies to out-of-repo coding too, folder by folder. Each iteration shows its token count, and the column's heading adds up the tokens of every iteration listed below it. A follow-up can be written and sent right there, from inside AI output — no need to close the view, find the card again and reopen its form. Pin and name. Past a few passes, neither the number nor the date says what happened in them. Every iteration therefore carries two gestures: a tag that lifts it to the top of the column (the number stays visible, so the chronology still reads), and a name typed in place — Enter confirms, Escape gives up. The name shows in bold under the header and joins the search, like the request does. ⚠ Neither the tag nor the name goes to the AI: it is filing, written for the human scanning the column — the same rule as a session's label. An iteration predating the pass history has no row in the database: it can be neither named nor pinned, and the screen says so rather than offering a gesture with no effect. The diff of THIS iteration. The project's diff shows everything the branch brings: by the third follow-up, the three-line fix you just asked for has to be found among two hundred, and you re-read all of it every time. The latest iteration of a session on a repository therefore keeps its two bounds — the commit before, the commit after — and the patch between them: under the request, See what this iteration changed opens the same screen as the project diff (file tree, whole file with the changes in place), bounded to that pass. The request and the AI's output stay on the left: a diff re-read without knowing what was asked teaches nothing more than the branch diff does. Escape closes the diff and gives the iteration back, not the session list. ⚠ Only the LATEST measurement is kept. What you just asked for is what you re-read; the diff of the next-to-last follow-up never gets reopened and would weigh for nothing. Every new pass therefore erases the measurement of the ones before it, and the screen stays silent about them — to compare two older follow-ups, the project diff is still there. An iteration that changed nothing in the code (the AI stopped to ask its questions, or found everything already done) says so instead of opening an empty view; a superseded iteration, or one predating this measurement, shows nothing at all: promising a diff you do not have is worse than staying silent. Out of repository too. There is no branch and no commit there, so Mergerie keeps a tracking repository whose work tree is your folder but whose .git lives in its own working directory — your folder receives nothing, not even the git used to measure, and if it already is a repository its own .git is never read or written. Two snapshots per pass, and the diff between them. Whatever your folder already ignores (.gitignore) is ignored here too, plus dependency and build folders — node_modules/, dist/, .venv/ and the rest: seeing those in a follow-up's diff would make it unreadable. And a guard rail: past 20,000 files or 512 MB the measurement is abandoned for that folder — once and for all — and the log says so. The coding itself carries on: slowing work down for a re-reading convenience would be the wrong trade. Cleanup is automatic. Those tracking repositories live under data/tasks/local/; they go with the session when it is deleted, and once a day (at startup, then every 24 h) Mergerie removes the ones no session folder references any more — changing a session's folder list leaves some behind, so does a database restored from a backup — and compacts the rest. Those still referenced are never removed: an iteration gets re-read months later, and keeping it is the whole point.
  • ⌨️ Resume the session in a terminal. Every project of a coding session (repository or out-of-repo), and the reviews too, exposes a “Resume in terminal” button that copies the ready-to-paste command: a cd to the right folder plus the agent launched with the session identifier (claude --resume <id>, copilot COPILOT_HOME=… --continue). You pick the AI's conversation up yourself, with all its context, where the app left it.
  • 🙋 The AI can ask you a question. A per-session checkbox — “The AI may ask me questions when unsure”, in plain sight above “Launch later, on”, never inside Advanced; ticked by default on a new session, a habit set once in Settings → General: if the AI hits a structural decision it cannot settle (an architecture choice, an ambiguity, a clash of conventions), it stops and asks you instead of guessing. The session goes into waiting (the queue frees up, a notification warns you); you answer from the card — offered choices or free text — and the AI resumes the same session where it stopped. As soon as you confirm, the form gives way to a “resuming…” (no more waiting without visual feedback). The option is remembered when you edit an existing session. Resuming was first validated by a test bench in Settings → AI sessions.
  • ⚡ Converge from a session — from prompt to converged MR. The …then converge up to 8/10 (3 passes max) checkbox of the new session dialog — and the Converge button of an existing session — chain the whole path without intervention: the AI codes the task → commit → push → creates the MR (target = the starting branch) → then starts the convergence loop (review → fix → re-review) until the threshold. You write an intention, you come back: an open, tested, scored and converged MR is waiting — all that is left is to read it and merge. Multi-project: each project gives its MR, converged in turn, in series (one failure does not stop the others). Idempotent: a session already coded is not coded again, an MR already open is converged directly. Same guard rails as “Converge” on an MR — and never an automatic merge.
  • Out-of-repo coding — the AI carries out the prompt directly in local folders, in place and without git: no branch, no commit, no push. Handy for folders that are not repositories of a forge (scripts, experiments, a local mono-repo…). The working folder is no longer typed in: you pick a local directory (declared in Settings → Repositories) then the project or projects it contains — the path follows, and a hand-typed path is a typo you only discover halfway through the run. The form (projects + prompt) lives in the same dialog as coding — so you can also attach files (screenshots, PDFs, spreadsheets, text) (button or Ctrl+V) to enrich the prompt. The same prompt is applied to each folder, one after another — a failing folder does not stop the others, and the status is shown per folder. As with repository Git, optionally. A Branch to create field (optional) gives the folder the path of a coding session: the branch is created in the folder, the AI works on it, its work is committed (your commit message, otherwise the first line of the prompt), then, depending on the boxes, pushed, the merge request opened and the convergence started on it — converging implies the MR, the MR implies the push. The folder must be a git repository. Uncommitted or untracked files already there do not block the session: they stay where they are and are left out of its commit, unless the AI itself changed them. The forge is found through the folder's origin remote, which must be a repository registered in Mergerie; otherwise the branch is pushed and the card says why there is no MR. Without a branch name nothing changes: the AI writes in place and nothing is committed. Each folder shows its branch, the state of its commit and its MR link. Convergence works on Mergerie's clone: a git pull in your folder brings its fixes back. coding, each folder exposes AI output — what the agent says it did, useful when the folder has not moved (incomplete prompt, the AI answered instead of coding) — and the session offers Send a follow-up: a fresh pass over the same folders that resumes each one's session, so the AI keeps all the context of what it has just produced. An out-of-repo session is editable afterwards (prompt, folders, session identifier), like a repository session. Re-runs can be targeted: every folder has its own Run again, and the card offers Re-run the failed folders when there are any — on five folders where one broke, re-running everything would cost four agent passes for nothing. Like any re-run, it asks first. A session's error is cleared for good (the cross on the error box), and does not come back on the next refresh. ⚠ No safety net: the agent modifies the files in place, without a backup; on a git repository you can review and undo yourself (git diff / git checkout), on a non-git folder there is no undo — a warning says so. (Dedicated sub-tab, between Coding and Exploration.)
  • Exploration — read-only: you ask a question about one or several projects, the AI explores the code and writes a single synthesis answer saved as .md, readable at any time through View answer. No diff, no merge. A follow-up question resumes the same agent session — as for coding — instead of re-injecting its previous answer: the AI remembers its exploration instead of re-reading a summary of it. The repositories are reset afterwards: no modification survives. Each exploration also exposes “Resume in terminal” so you can continue the conversation yourself. Every question is kept: a follow-up question overwrites the answer file, but the pass is archived — View answer lines the iterations up on the left, with the search over the questions asked, and replays the one you pick on the right with the answer it got. Turn into code makes a coding session out of an exploration: the dialog opens on the same repositories, with the question and its answer as context, and the exploration's agent session placed in “resume an existing session” — the agent keeps what it has read instead of re-reading three repositories.
  • Free question — the same thing, with no repository at all. You ask the AI something — a notion to dig into, two options to compare, a plan to challenge — and the answer is kept here. Nothing on the machine is read or changed: no clone, no folder, none of your files. An optional label files the study away (“Concurrency”, “Payment architecture”), and the search covers the question and the label. As everywhere else, a follow-up question resumes the same agent session — which is what makes a five-question study possible instead of one — every pass is archived with its question, and “Resume in terminal” hands the thread back so you can continue it yourself. The answer exports (HTML, Word, PDF) like an exploration's. A free question reserves no repository: it never blocks a review or a coding session, and nothing blocks it. (Dedicated sub-tab, after Exploration.)