Documentation

Getting started

On Windows, download the installer from the home page and run it. Memento installs for the current user, needs no administrator rights, and keeps itself up to date. The portable build is the same application in a single file, if you would rather not install anything, but it doesn't update itself.

On Linux, see the notes below.

Git itself is not bundled. Memento drives the git already on your machine, so your credentials, SSH keys, hooks and configuration keep working exactly as they do in a terminal. If git --version answers in a terminal, Memento will work.

The first launch

The first time you open Memento, three short screens ask for a repository, offer to connect GitHub, and let you choose what runs by itself. Every one of them can be skipped, and nothing there is permanent: all of it is in the settings afterwards. If you already have repositories in your list, the setup does not appear at all.

Opening a repository

The first screen offers three ways in:

• Open a folder: any folder with a .git in it. If it isn't a repository yet, Memento offers to create one.
• Clone a URL: https://, git@… or ssh://. The folder name comes from the URL, and the parent folder is remembered for next time.
• Sign in to GitHub and pick from your repositories instead of typing a URL. The list has all of them, private ones and the ones you reach through an organisation included.

In that list, a repository you already have on disk is marked cloned. Selecting it offers to open your copy; cloning a second one is still possible if that's what you want.

On Linux

There are two builds for 64-bit Linux. Both need a distribution from roughly 2022 onwards (Ubuntu 22.04, Debian 12, Fedora 38 or newer).

• The AppImage runs without installing anything and updates itself. Make it executable (chmod +x Memento-*.AppImage, or tick "allow executing" in its properties) and open it. On Ubuntu 22.04 and later it needs FUSE: sudo apt install libfuse2 (libfuse2t64 on 24.04).
• The .deb installs like any package: sudo apt install ./memento.deb. It pulls in git if you don't have it. It can't update itself, since only your package manager is allowed to replace it, so install the new one when a version comes out.

A few things work differently than on Windows:

• Signing in to GitHub needs a keyring (gnome-keyring or KWallet), which most desktops already run. Without one, Memento refuses to store the token rather than keep it in a file any program could read, and tells you so.
• Closing the window quits by default. GNOME has no notification area unless you add an extension, so folding Memento away there would hide it with no way back. If your desktop has one (KDE, Cinnamon, XFCE, or GNOME with the AppIndicator extension), turn it on in Automation settings → In the background.
• Starting with your session adds a memento.desktop entry to ~/.config/autostart. Turning it off from your desktop's startup settings is respected.

Projects, and the repositories already on your PC

Open repositories become tabs, and Ctrl K switches between them. The Projects view lists the ones Memento knows, with their branch, uncommitted changes, and how far ahead or behind they are.

Below that, On this computer lists Git repositories Memento found on its own and that aren't in your projects yet. It looks in the usual places (Documents, Desktop, source, repos, dev, code and the like), in the folder above each repository you already opened, and in any folder you add with Add a folder.

To stay quick it never starts from the root of a drive, only goes a few folders deep, skips things like node_modules, and gives up after a few seconds. If it stopped early it says so. When a repository is missing, add the folder it lives in. The result is kept, and the search only runs again when it's more than ten minutes old or you press Look again.

The history

The commit graph draws lanes for every branch, with merges, refs and tags. Only the rows on screen exist in the page, so it stays smooth on repositories with tens of thousands of commits. There is no cap: the first thousand commits load at once, and older ones arrive as you scroll, down to the very first commit. The count at the top is the real total.

All branches shows every branch, remote branch and tag together; Current branch keeps only the commits of the branch you are on, the way git log would show them.

Ctrl F filters it by message, author, file, code or date. The filtering is done by git itself rather than in the app, so it is instant on a large history. Search terms are passed as fixed strings, so a term that begins with a dash is a search term and not an option.

Selecting a commit shows its author, its full message, the files it touched and the diff for each. From there you can blame a file at that revision, or browse the entire tree as it stood at that commit.

Reading a diff

Every diff has the same bar on top. Unified shows one column; Side by side puts the old version on the left and the new one on the right, each changed line facing its replacement. Words highlights the words that changed inside a line, so a renamed variable stands out from the rest of the line. Syntax colors keywords, strings and comments for the usual languages. Ignore whitespace hides changes that only touch spaces and indentation, which makes a re-indented file readable. The choice holds everywhere: history, changes, stashes, comparisons.

While whitespace is ignored, the diff no longer matches the file line for line, so staging individual lines is switched off until you turn it back on. Very large diffs are shown plain, without colors, to stay instant.

Several commits at once

Ctrl + click adds a commit to the selection, Shift + click takes everything in between. With several commits picked, you can cherry-pick them onto your branch (oldest first), revert them (newest first), save them as one patch, or copy their SHAs. With exactly two, the details pane shows every file that differs between them, with the diff.

A merge commit is refused before anything starts, since replaying one needs a parent to be chosen. If a commit in the series conflicts, git stops there as it would in a terminal: resolve it, then Continue, or Abort to go back.

The history of a file, or of a few lines

Right-click a file, in a commit or in your changes, then History of this file: the history narrows to the commits that touched it, following it through renames. In the blame, the same button is at the bottom.

To know where a few lines come from, open the blame, click a line number and Shift + click another to pick a range, then History of these lines. Each commit that changed them is listed with the diff of those lines only, followed even when the block moved inside the file.

Your own diff and merge tool

If your Git config names a diff.tool (Meld, Beyond Compare, KDiff3, VS Code…), Open in diff tool is in the right-click menu of a file, in a commit or in your changes. A merge.tool adds Merge tool to the conflict view. Tools that run in a terminal, such as vimdiff, can't be opened from a window and are refused rather than left waiting.

Your editor and terminal

Right-click a file, then Open in your editor: VS Code by default, or Cursor, VS Code Insiders, Windsurf, VSCodium, or whatever your system opens the file with, chosen in Settings → App. Repository → Open in… opens the whole folder, and Open in a terminal starts a terminal there (on Windows: Windows Terminal, PowerShell, Command Prompt or Git Bash). The editor opens through its own vscode:// address, never through a command line, so a strange file name can't turn into a command.

Ctrl = and Ctrl - make the whole interface bigger or smaller, Ctrl 0 goes back to 100 %. The size is remembered.

Changes and committing

The Changes view lists what is staged, what is not, and what git does not track yet. You can stage a whole file, a single hunk, or individual lines, which helps when one file holds two unrelated changes and only one of them belongs in this commit.

Lines and selections

In the diff, click the lines you want. Shift and a second click take everything in between, and Select hunk takes a whole block. Then Stage lines, or Unstage lines on something already staged, or Discard lines to undo just those lines in the file on disk.

This works by building a patch and feeding it to git apply, which means it respects everything git already knows: end-of-line settings, filters, and files with no trailing newline.

In the file lists, Ctrl and Shift clicks select several files at once, to stage or discard them together. The arrow keys move through the list, Space stages, Delete discards, and Ctrl A takes everything.

The menu next to All holds the bulk actions: stage everything, stage only what git already tracks, discard changes to tracked files, delete untracked files, or discard the lot. Each one asks first, saves a snapshot, and never touches files matched by .gitignore.

Writing the commit

• Summary and description are separate fields, so the first line stays short.
• Ctrl ↵ commits.
• Recent messages offers the last few subjects, for when a change follows on from the previous one.
• Amend rewrites the last commit. Memento will not amend a commit that has already been pushed without saying so.

Images are diffed side by side, before and after, for png, jpg, gif, webp and friends.

Work and personal identities

In Settings → Git, Save as an identity keeps the name and email you just set, with the organization of the repository's address (github.com/acme). Saved identities appear as chips: one click fills the fields. When you open a repository whose address matches an identity that isn't the one your commits would use, Memento says so and offers to switch, before the first commit goes out with the wrong email.

Signing commits

Some teams require signed commits. Settings → Git → Commit signing turns it on with a GPG key or an SSH key, for this repository or for everything you do. Memento lists the keys it can find, and Test signing signs a throwaway object to check the whole chain before you depend on it.

It only writes git's own settings (commit.gpgsign, gpg.format, user.signingkey), so a commit made from a terminal is signed the same way. Signed commits carry a badge in the history, and a signature that does not verify says so rather than staying quiet. If signing fails when you commit, the message says what to check instead of showing git's raw error.

Commit messages from an AI agent

Suggest, above the commit message, asks an AI agent to write the message from what you staged: a summary line, then a few lines that say what changed and why (Settings → AI can keep it to the summary). It follows the language of your last commits. If you had typed something, Restore mine puts it back, and the line under the message says which agent and which model wrote it.

Everything starts from the AI menu: Write commit messages with AI opens the list of agents the first time, then the same entry writes the message. With no agent chosen yet, the button above the message reads Write it with AI and leads to the same place.

Agents come from the ACP registry, the list Zed and JetBrains use: GitHub Copilot, Claude, Gemini, Codex, Junie, Cursor, OpenCode and others. Settings → AI lists them. Nothing is downloaded until you click Install. Archives are checked against the checksum the registry publishes, and agents shipped as npm packages run on a copy of Node.js that Memento downloads once from nodejs.org, also checked. Everything lives in Memento's data folder, and Remove deletes it.

Signing in

GitHub Copilot uses the GitHub account you signed in with in Memento: there is nothing else to do, as long as that account has Copilot (Copilot Free is enough). Other agents sign in their own way, through your browser or in a terminal window that Memento opens, and remember it for next time. OpenCode works without an account. Check says whether an agent is ready.

Which model

Once an agent is ready, Settings → AI shows the models it offers, as the agent lists them (Claude: Opus, Sonnet, Haiku…; OpenCode: its free models). Leave it on the agent's default, or pick one: Memento asks for it at every message, and falls back to the default if the agent stops offering it.

What the agent sees, and what it can do

• It receives the diff of what you staged, the branch name, your last commit subjects and the open todos of the branch. The first time, Memento asks before sending anything.
• Files that look like secrets are left out: .env, private keys, certificates, cloud credentials, anything in a secrets folder, and any file whose changes contain something that looks like a key or a token. Their name is mentioned, never their content. A very long diff is cut, and the agent is told.
• It cannot read your files, run commands or change anything. It works in an empty folder outside your repository, Memento advertises no file or terminal access, and refuses every permission it asks for. Copilot's and Claude's tools are switched off before the question, Claude also leaves out the MCP servers you set up for it, and OpenCode runs in its plan mode, which has no editing tools.
• If an agent tries to use a tool anyway, reading a file for instance, Memento stops it at once and uses nothing from that answer. A suggested message that contains something like a key or a token is not used either.
• An agent is only used in a mode that asks before acting, or that cannot act. One set to accept everything (Claude's “Bypass permissions”, for instance, if it is your default in a terminal) is switched back before Memento says anything to it; an agent with no such mode is not used.
• It does not get the keys of other services that live in your environment: GitHub and npm tokens, cloud credentials, passwords. Only GitHub Copilot receives your GitHub sign-in. Agents installed with npm are installed without running any install script.
• It runs only for the time of one answer, then it is stopped, and quitting Memento stops it too.

Undoing things

A commit, a merge, a discard or a reorganized history can be taken back: the notification that confirms it carries an Undo button, Ctrl Z does the same, and so does Repository → Undo. It stays available for ten minutes.

If the repository moved in the meantime, Memento refuses rather than guess: undoing a commit that another has landed on top of would erase the second one. Past those ten minutes, Repository → Reflog and Repository → Safety net still hold every earlier state.

Branches

The sidebar lists local branches, remote branches grouped by remote, tags and stashes. Double-click a branch to check it out; right-click for everything else: merge, rebase, rename, choose the remote branch it tracks, delete, copy the name, or set an automation rule.

A branch that would conflict if you merged it into yours carries a small mark with the number of files, before you try anything. Hover it for their names. Git works this out in memory: nothing in your repository moves. The same forecast is in the merge window, and on the Pull card when your branch and the remote have both moved.

Merging

Merge into… says how many commits arrive and which files will conflict, then lets you pick how: fast-forward when possible (git's default), always create a merge commit so the merge stays visible in the history, or squash into one change: everything the branch brings is staged as a single change, and the commit box opens with a message listing the commits it replaces. Until you commit it, a banner says a squash is in progress: Continue commits it with that message, Abort takes it back, and nothing automatic commits it for you.

Renaming, and what a branch tracks

Rename… works on any branch, the current one included. Its automation rules and its safety net follow it under the new name. A branch keeps tracking the same remote branch after a rename: Track a remote branch… changes which one Pull brings in and Push sends to, or stops tracking altogether.

Worktrees: several branches at once

Right-click a branch, then Open in a new worktree: it gets its own folder next to the repository, opened in a new tab, so you can work on it without leaving your current branch or stashing anything. Your worktrees are listed in the sidebar; double-click one to open it. Remove this worktree deletes the folder but keeps the branch and its commits, and refuses while the folder still has uncommitted changes.

Comparing two branches

Right-click a branch, local or remote, then Compare with your current branch: the commits each one has that the other doesn't, and the files that merging it would change, with their diff.

Stashes

Stashes are listed with the branch they were taken from, so a stash from three weeks ago is still identifiable. Right-click one for Show its changes, to see the diff before deciding, then apply, pop or drop it. Apply and restage what was staged puts the staged part back in the index instead of mixing everything into unstaged changes. Create a branch from it starts a new branch on the commit the stash was taken from and applies it there, where it cannot conflict.

When you stash, you choose what goes: everything, with or without untracked files; everything while keeping what is staged in place; or only what is staged. In the Changes view, right-click one file or a selection to stash just those.

Ghost branches

When a branch's remote disappears, usually because its pull request was merged and the branch deleted, Memento tells you once, and offers to look at it. It never deletes a local branch for you: it may hold work that exists nowhere else.

A light git-flow

If you turn it on, Start a branch creates feature/…, fix/… or hotfix/… from the right base, and the finish step merges back into the right target. The rules live in the repository, so a teammate running Memento follows the same ones.

Reorganizing commits

Right-click a commit and choose Reorganize the commits after this one, or take only what you have not pushed yet with Branch → Reorganize unpushed commits. This is git's interactive rebase, without the text file.

The commits are listed newest first, as in the history. Drag one by its handle to move it, or focus the handle and use the arrow keys. For each commit:

Nothing is written until you press Apply, and the result can be undone. Commits that are already on the remote are marked pushed: rewriting them means the next push has to replace the remote branch, which Memento offers to do with --force-with-lease, refused if anyone pushed in the meantime.

If replaying a commit conflicts, the rebase stops exactly as it would in a terminal: the Conflicts view opens, and Continue or Abort finish the job. Uncommitted work is stashed and restored on its own. A range that contains a merge commit is refused, with an explanation, rather than quietly flattening it.

Going back to a commit

Right-click a commit, then Reset to here…. Before anything happens, the window says how many commits leave the branch and how many of them are already on the remote. You pick what happens to their changes:

A hard reset never goes without a net: Memento takes a snapshot of your work first, and Undo puts the branch back, your uncommitted files with it, and what was staged as it was. Files git does not track are never touched, except one that the commit you go back to still contains (a .env committed long ago, for instance): git replaces it, so the window names it, your copy goes into the snapshot, and Undo brings it back. If the reset fails halfway, because another program holds a file open, Memento puts your files back as they were.

If some of the commits were already pushed, the next push offers to replace the remote branch safely, refused if anyone pushed in the meantime. Until then, auto-pull leaves that branch alone: it would bring the commits straight back.

Patches

A patch is a file anyone can apply, with or without Memento. Right-click a commit, or a selection of commits, then Save as a patch: the file holds the commits themselves, author, date and message included. Repository → Save changes as a patch does the same for your uncommitted changes (or only the staged ones), as a plain diff.

Repository → Apply a patch… opens one and says what it holds before applying it: commits are recreated on your branch, a plain diff changes your files without committing. A patch that does not apply cleanly changes nothing, and Memento says why. Either way, Undo takes it back.

Finding the commit that broke it

Something worked last week and doesn't today, and a hundred commits came in between. Right-click a commit where it still worked, then Find the commit that broke it, starting here. Memento checks out the commit halfway between that one and your branch. Try it, then answer in the banner: It works, It's broken, or Can't tell if this commit can't be tested. Each answer halves what is left, so ten answers are enough for a thousand commits.

When it is found, the banner names the commit and Show it selects it in the history. Finish and go back, or Stop at any time, returns you to the branch you started from. This is git bisect: a terminal open next to Memento sees the same search, and closing the app midway loses nothing. Your working copy must be clean before you start, since every try checks out another commit. Files you keep out of Git that an older commit still contains, like a .env, are set aside when the search starts and put back when it ends.

Conflicts

When a merge, rebase, cherry-pick or revert conflicts, a banner appears and the Conflicts view opens. Files in conflict are listed on the left; the file itself is on the right, cut into blocks.

Each conflicting block is shown in three columns: yours, the original (the text as it was before either side touched it, taken from the common ancestor), and theirs. Lines a side didn't change are dimmed, so what each person actually did stands out, and when two lines differ by a word or a number, that part is highlighted. In the original, a line marked M or T was changed or removed by mine or theirs. Original in the toolbar hides that middle column if you prefer two. Long stretches of common text between blocks are folded down to the lines around them.

You decide each block in whichever way suits:

• Mine, Theirs, Both or Both, theirs first take a whole side, or both in either order.
• Original drops both changes and keeps the text as it was.
• Line by line: click the lines you want to keep, on either side, then Use picked lines. That is the usual case when two people edited the same function for different reasons.
• Edit: write the result yourself, when neither side is right.

Once a block is decided it folds down to the result, which Change reopens, and the next block left to decide becomes the current one. J and K move between blocks, 1 to 4 keep mine, theirs, both or the original for the current one.

Some blocks have an obvious answer: both sides made the same change, or only one side changed anything. They carry a suggestion, and Resolve N obvious settles all of them at once. Others get a suggestion you apply yourself, never automatically: two sides that only differ by whitespace, that both only added lines at the same place (two new imports, say), or whose changes touch different lines of the original, which Combine them merges so each side keeps what it did. Changes on the same line, or on lines next to each other, stay a conflict.

Undo, or Ctrl Z, takes back the last choice in the file. In this view it never undoes a Git operation: in the middle of a merge, that would undo something other than what you meant.

Preview shows the whole file as it will be written, which is where a Both that keeps two versions of the same line shows up. Your choices are kept per file: switching to another conflicted file and back doesn't lose them, and the list shows how many blocks of each file are decided.

• All mine / All theirs decide every block at once.
• Keep my file / Keep their file take a whole file without reading it. That is the only option for a binary.
• Mark resolved becomes available once every block is decided. The file is staged for you.
• Abort undoes the whole operation.
• Merge tool opens the file in the merge tool from your Git config; when you close it resolved, the file is staged.

Line endings are preserved exactly: CRLF stays CRLF, and a file with no trailing newline keeps none. The diff3 style, which also shows the common ancestor, is understood.

Automation

Repository → Automation settings shows the whole cycle in order, and what each step does. If it isn't on that list, it doesn't run.

The cycle runs every minute by default (anything from 30 seconds to 15 minutes) and keeps going when the window is minimised.

The indicator in the title bar says what is happening right now, "Fetching", "Merging", or simply Auto when the cycle is idle. Clicking it opens a card with the last run and the next one, the list of steps that are actually on, auto-pull as a switch, and buttons to pause, resume or run a cycle immediately. A cycle that could not finish (usually no network) shows there too.

Auto-pull

Fetches, then pulls the current branch with --ff-only. It moves your branch forward when there is nothing to decide, and refuses the moment a decision would be needed.

If your branch has diverged (commits on both sides), it stops and says so, with how many commits each way, and offers to merge the remote. It will not merge or rebase behind your back.

Auto-merge

Pick a source branch and a target in the per-branch table. Whenever the source can merge into the target without conflict, it does.

• You do not have to be on the target. Merging into a branch you are not on happens in a throwaway worktree, so your working copy, your open files and your uncommitted changes are never touched.
• It leaves a trace. Merges use --no-ff, so there is always a commit recording when the branch landed, instead of a pointer that quietly moved and left no evidence.
• A conflict aborts everything. The merge is undone immediately, so there's nothing half done to clean up. A banner then stays until you deal with it, with a button that replays the merge so the conflict resolver opens on it.
• If the target branch is already checked out in another worktree, the merge is skipped rather than forced.

Checking a merge before keeping it

A merge Git calls clean can still break the build. One branch renames a function, the other adds a call to the old name, and they never touch the same line. The only thing that notices is running the project, so you can give auto-merge a command to run: npm test, cargo test, a build script.

Turn it on in Automation settings → Check merges before keeping them. With a command set, a merge goes like this:

1. The merge is built in a throwaway worktree. No branch has moved yet.
2. Your command runs there. Dependency folders from your working copy (node_modules, .venv, venv, vendor) are lent to it through links, since a fresh worktree doesn't have them. They're removed again afterwards; your own folders aren't touched.
3. If the command passes, the target moves to the exact commit that was tested. If it fails, nothing changed, and you get the first lines of the output that look like an error.

A few details that matter in practice:

• A failed check isn't rerun every cycle. It waits for a new commit on either branch, or for you to change the command or the timeout.
• If the target branch receives a commit while the check runs, nothing is overwritten. The merge simply waits for the next cycle.
• The command has a time limit (three minutes by default, up to fifteen). Past it, the check counts as failed.
• If the merge changes your dependencies themselves, the check runs with the old ones, and will likely say so by failing.

Auto-commit

Saves work in progress once nothing has changed for a while (anywhere from one minute to an hour). Commits are labelled WIP … (Memento auto-commit) so they are easy to spot, amend or squash later.

If a pre-commit hook refuses, no commit is forced, the files Memento staged are put back as they were, and the hook's own message is shown once.

Auto-push

Pushes only what cannot be rejected:

• Never when the branch is behind or diverged. Auto-pull deals with that first.
• Never with --force, in any form.
• Branches with no remote yet are published only if you ask for it.
• If the remote rejects the push anyway, nothing is overwritten and git's own message is shown.

Both auto-commit and auto-push take a list of branch patterns, like main, feature/*. An empty list means every branch.

In the background

Closing the window does not quit Memento. It folds into the notification area and keeps running its cycle, so a repository stays watched while you work on something else. Click the icon to bring the window back; right-click it to pause the cycle, open these settings, install a waiting update, or quit for good. Quitting from that menu is the only thing that really stops Memento.

A hidden window is not drawn at all, which is where the saving comes from. The cycle itself keeps its usual pace, because a paused cycle would defeat the purpose. If you would rather closing the window meant quitting, turn off Keep Memento running in the notification area in Automation settings → In the background.

The same panel can start Memento with your session, already folded away, so a repository is watched from the moment you sign in. Not with the Windows portable build, which has no fixed place on disk to point the shortcut at.

What automation cannot do

Without a check command, auto-merge only knows about textual conflicts. It won't lose commits, overwrite anyone or leave a half-finished merge, but it can't tell whether the result still builds. Setting a check covers that, as far as your tests go.

Auto-push has the same kind of limit. Once something is pushed it's on the remote and maybe in other people's clones, and undoing that would take a force-push, which Memento never does by itself.

Working as a team

Memento keeps the shared todo list in the repository itself, in a ref of its own: refs/memento/data, outside refs/heads.

Putting it there is what makes it work:

• The same list on every branch. A file in the working tree follows the branch you are on: the list would change at every checkout.
• Never in a diff. It is not in the working tree, so it never appears in your changes, and never in the history graph either.
• Never a conflict. It is not on a branch, so no merge can conflict with it.
• Still shared. Fetch and push carry the ref along, so teammates see the same board through git alone.

Using the list

• Edit in place. Double-click a todo to change its text or the branch it is linked to.
• Priority. The flag keeps a todo at the top of the list, for everyone.
• Filters. All, Mine (assigned to you, or yours and unassigned) and This branch. In This branch, a new todo is linked to the branch you are on.
• Who finished it. Ticking a todo records who did it and when. If it was yours and someone else finished it, you are told.
• Undo. Deleting a todo, or clearing the done ones, can be undone like any other action: Ctrl Z or the button in the notification.

Todos and branches

A todo linked to a branch shows it as a chip: click it to switch there. A branch that only exists on the remote is checked out from it; one that is gone everywhere stays written, struck through.

The link works the other way too. The commit box lists the open todos of the branch you are on, to tick the ones the commit finishes. Finish offers to mark the branch's todos done, and merging a branch by hand offers the same thing in its notification. Nothing is ticked without you.

Projects gathers your todos from every repository at the top of the page, with a count on each card. Click one to open that repository on its list.

Concurrent edits

Entries merge by id, and within an entry, field by field: each field keeps its most recent change. Two people ticking different items keep both, and one person ticking an item while another renames it keeps both changes too. Deletions leave a tombstone for sixty days, so a teammate who still had the item cannot bring it back on their next sync.

Presence

Each client records which branch it is on, and the sidebar shows teammates' initials next to that branch, outlined green while they're actually there and plain once they've been idle for half an hour. It's written when you change branch, or every ten minutes at most.

When you switch to a branch that someone is on right now, Memento tells you who, so you can talk before you both push to it.

GitHub

Signing in uses GitHub's device flow: a code to type in your browser, no password ever seen by the app. The token is encrypted with your operating system's own key store and never leaves the main process; the interface never touches it.

The GitHub view shows, for the repository you have open:

• The pull request for your current branch, or a one-line form to open it, with the default base filled in.
• Check runs for the head commit, pass or fail per job, clickable through to the run.
• Other open pull requests with their requested reviewers.
• Issues assigned to you.

A green pull request can be merged from there.

Requests are cached for 25 seconds, which keeps the automatic cycle far inside GitHub's rate limit. A repository that is not on GitHub, a missing token or no network give an empty view, never an error.

Notifications

Everything Memento has to say goes into a journal behind the bell in the title bar: the whole session, with an unread count and the severity down the left edge. A desktop notification is raised on top of that only for what needs a person, and only when Memento does not have the focus.

Twelve kinds of event, each set to off, in app, or in app and on your desktop in Settings → Alerts:

The Android app

A phone has no local repository, so the mobile app follows what GitHub knows. But following is not the point: what you cannot do away from a keyboard is finish things, and that is what it is built for.

What is waiting on you

The app opens on an inbox, not on a list of repositories. Reviews people are waiting on, your pull requests that are broken or ready to merge, the issues you were given. It is ordered by urgency rather than by date, and a section with nothing in it does not appear. GitHub's own notification feed is folded away underneath, as a record of what happened rather than a list of what is left.

Branches

Every branch of a repository with its last commit and author, how far ahead and behind the default branch it is, whether its checks pass, and the pull request that carries it. The freshest first. From a branch you can open the pull request it is missing, or delete it once it holds nothing the default branch does not already have. Deleting is only offered in that case, so nothing can be lost.

Pull requests

The description, the conversation and the diff, file by file. Approve, request changes, comment, or merge with a merge commit, a squash or a rebase. Approving your own is not offered, because GitHub refuses it.

Todos and issues

The team todo list is the same one the desktop keeps in the repository, and the phone writes to it: add, rename, assign, attach to a branch, flag as a priority, tick (with your name on it), delete, and clear the done ones. Mine narrows the list to what is yours. Deleting leaves a tombstone, exactly as the desktop does, or the entry would come back at the first merge. If a repository has no shared list yet, the first todo you add creates it. Issues can be read and opened from here too.

Out of coverage

Each screen shows what was last known while the fresh copy arrives, so the app opens on something to read rather than a spinner, whether you're on the metro or just opened it. When a refresh genuinely fails it says so, instead of passing yesterday's list off as the state of the moment. Pull any list down to ask again.

How notifications reach you

Nothing sits in between: the phone asks GitHub itself, every five minutes while the app is open, every time you come back to it, and about every fifteen minutes in the background with the app closed. Nothing about your work passes through anyone else, and there is nothing to host.

Faster than that would need Firebase and a small relay, and the app carries the code for it. It is not switched on: no Firebase project is configured, so that path is compiled out of the build entirely rather than left to fail at runtime. The settings panel says so plainly instead of showing three empty rows.

Fifteen minutes is the floor Android allows for background work, and it stretches further on a low battery. That is the trade: a few minutes of latency in exchange for no third party.

Pushes and branches

GitHub's notification feed never mentions a push; it only covers threads you are subscribed to. To tell you that someone pushed to a branch, Memento reads each watched repository's activity instead. That is one request per repository, which is why the repository list in Settings matters: pick the ones you care about, and only those are checked.

Keyboard and the palette

Ctrl K opens the command palette: every menu action, every setting, every branch and every open repository, found by typing a few letters. Accents are ignored, and each entry shows its shortcut, so the palette teaches them as you go.

Updates

Memento checks this site on startup and every four hours, downloads quietly in the background, and asks before restarting. There is no store and no account in the way. Settings → App shows the installed version and checks on demand.

The Android app does the same, reading a small manifest from this site. It never installs silently, since that would need permissions it has no business holding. It offers the download and lets Android take over.

Privacy

• You don't need an account. Everything works before you sign in, and GitHub sign-in only adds the GitHub features.
• Neither app has analytics or telemetry. Nothing about how you use them is sent anywhere.
• Git runs on your machine, on your repositories, like it does from a terminal.
• The GitHub token is encrypted by the system (DPAPI on Windows, your keyring on Linux) and stays in the app's main process.
• Team data travels inside your repository, to your remote. There's no Memento server involved.
• The website counts visits without cookies, and the legal page says exactly what it records.

When git refuses

git writes for people who already know git. Memento recognises the usual refusals and says what happened instead, with the button that fixes it where there is one. The original message is still there, under the mouse pointer, for when you want it or want to search for it.

Hovering Push or Pull before clicking shows what they are about to do: how many commits, to or from which branch, and which ones. The numbers are those of the last fetch, and the card says so. When both sides have new commits, the Pull card also says which files would conflict.

By default Pull only fast-forwards, and asks before merging anything. In Repository settings → Behavior, Pull can instead merge when both sides moved, or rebase your commits on top of theirs. This sets git's own pull.rebase for the repository, so a terminal does the same; a global pull.rebase=true is followed too. If it stops on a conflict, the Conflicts view opens. Auto-pull always stays fast-forward only.

Troubleshooting

Automatic actions are not happening

Open Repository → Automation settings. The panel says when the last cycle ran and whether it finished; "could not finish" almost always means no network. Check that the rule you expect is switched on, and that the branch matches the patterns you set.

Auto-merge does nothing

Check the target in the per-branch table: a source with no target is off. If the target is the branch you are currently on, a dirty working copy postpones the merge; off-branch merges are not affected. And if the source has nothing new, there is nothing to do.

A merge says it was held back

The check command failed on the merged result, so the target wasn't touched. The notification shows the first lines that look like errors. Run the same command on a local merge to see the whole output. If it failed for a reason that has nothing to do with the code (a missing tool, a test that needs the network), fix that and change the command or its timeout, which makes Memento try again right away.

Auto-commit never fires

It waits for a period with no changes at all, so it will not interrupt you mid-edit. It also ignores files git does not track unless you asked for them. If a pre-commit hook is refusing, the reason appears in the notification centre.

A push was rejected

Someone pushed to the same branch first. Nothing was overwritten. The message says so in plain words and offers to pull and push in one go; auto-pull would do it on the next cycle anyway if it can fast-forward. If instead you had rewritten commits that were already pushed, the offer is to replace the remote branch, and that is refused if someone pushed in the meantime.

Sign-in to GitHub fails

The device flow needs to reach github.com. A VPN that is connected but not actually routing traffic looks exactly like being online and will fail here; the app says so explicitly rather than doing nothing.

Something went wrong and I want the old state

Repository → Reflog. Every move of HEAD is listed, and anything Memento did automatically is a normal commit or ref move like any other. Nothing is special-cased or hidden from git.