Features · reman

1

Recall

Type what you mean, not what you remember.

"undo my last commit" finds git reset --soft HEAD~1, though the command never says "undo". reman searches your real history by meaning and by text at the same time, so a typo or a half-remembered flag still lands.

This folder first, then everywhere. A search never dead-ends.
Press ↑ in any shell and start typing. The best match sits right above your prompt.
Never done it? reman says "nothing close in your history" instead of passing off a guess.
An empty search shows what you usually run next here.

reman · search by meaning

Fig. 1Ten things people type, and the command reman ranks first, marked a close match. From a sample history of about 70 everyday commands and 250 scripts from coding agents, checked on every change by a test. reman only ever returns commands you have run.

2

Blanks

Ten copies that differ by one word are one command.

History fills up with near-copies: a commit message, a pod name, a folder. reman folds them into one command with a blank, shows what went in it lately, and puts your cursor right in the blank.

Only data folds: quoted text, paths, numbers, hashes, and generated names like api-7f9c4. docker compose up and down stay two commands.
Enter puts it on your prompt with the cursor inside the quotes. Type, and Enter runs it.
Search for one of its values (fix login) and you get that exact command instead.
Ctrl+G shows every variant on its own line.

reman · ~/work/apitry it

Fig. 2Thirty-eight commits with thirty-eight messages, one line in the finder. Press Enter and type into the blank.

3

Time

Find it by when you ran it.

You don't remember the flags, but you remember it was last week, or the day before the release. End a search with when, and only what ran then is left.

today, yesterday, this week, last week, last month, 3 days ago, last 2 weeks.
A weekday: friday, on fri, since monday.
Only the end of what you type is read as time: echo today is fine is still just text.
yesterday on its own browses that whole day. Agents' reman_search reads it too.

last weekthis week · today is Thursday

reman · finder

Fig. 3Every dot is a run. Pick a search: the days it covers light up, and only what ran then stays in the list.

4

Every run

Every run, and what it printed.

The finder opens in the lines under your prompt, so whatever you were reading stays on screen. It lists your own commands; F3 adds what your agents ran. Press Ctrl+O on a command and you get its whole history: every run, and what that run printed.

Every run. When, how long, whether it worked, the branch, the folder and who ran it. Del Del forgets one run and keeps the command.
What it printed. Your agents' output is kept as they run. For your own, reman shell runs your shell inside a terminal layer of reman's own (ConPTY on Windows) and keeps each command's output the way your terminal drew it: colours gone, a progress bar as it ended, long output whole.
Find it again. reman output --failed, reman output npm test, or by what it said: reman output ECONNREFUSED. Agents read it through reman_output instead of running the command again.
Small and private. Secrets masked, only the end of a long output, only your newest 3000 runs. reman settings can open every new shell inside it.
Your keys. Vim keys are a setting: Esc, then j k to move, dd to forget, q to close.

powershellCtrl+O on npm test

PS C:\code\web-shop>

what it printed

FAIL src/cart.test.ts

● cart › applies the coupon

expected 90, got 100

Tests: 1 failed, 41 passed

─────────────────────────────────────────────

✓ 09-30 16:02 1m 49s you main

✓ 10-01 11:20 1m 55s claude main

✓ 10-01 18:40 1m 52s you main

▌✗1 10-02 14:05 2m 10s you feat/cart

when took who branch

every run of `npm test` run 1 of 4

› npm test ^O back

Fig. 4Under the prompt, not over it: four runs of one test, and what the failing one said.

5

Track record

Reuse the one that worked, not the newest.

Every command carries its history: how often it ran, where, who ran it, whether it succeeded, and how long it usually takes. Of five variants you tried last spring, you see which one held up.

Worked every time, failed every time, or its success rate.
A command that only ever failed never leads a list.
Commands your agents ran are marked, so you know what you typed yourself.
Usually 3m 12s. The time a command takes when it works, so you know whether to wait or get coffee.
Done alerts. A command of yours that ran a minute or more sends a desktop notification when it finishes, saying if that was faster or slower than usual. Set it to 5 minutes, or off, in reman settings.

the card beside every result

npm install

npm: Install Node packages

~ worked 88% of 16 runs · usually 41s · last 2 days ago · by you

in ~/work/web

✓ npm install --legacy-peer-deps

worked every time (2 runs) · usually 38s

Fig. 5In the same folder, the plain command fails now and then; the variant never has.

Windows PowerShell · now

✓ cargo build --release 3m 04s, faster than usual (3m 40s) · in api

Fig. 6You switched to the browser three minutes ago. The build tells you it's done.

6

Before Enter

It tells you it'll fail before you wait for it.

You run the command you remember, and two minutes later it fails the way it failed the last three times. reman checks when you press Enter. If the history here says it will fail, and failing costs you something, it holds the command once and says why.

Only on strong evidence: it failed every time here, or the last three times in a row.
Only when failing costs something: its failures took 10 seconds or more, or it installs, builds, migrates or deploys. A typo that fails in a blink just runs.
What it printed last time, and what worked instead, with what that changes. Alt+F puts it on the prompt.
Enter again runs it anyway. Nothing is ever blocked.
One exact lookup on Enter, about 3 ms; never while you type. PowerShell, zsh and fish.

powershell · ~/work/apiyou pressed Enter once

PS> docker compose up

reman: this failed the last 3 times here, after about 2m each time (it worked 14 times before that)

last error: pull access denied for api, repository does not exist

reman: worked instead -> docker compose up --build (adds --build; Alt+F inserts)

Enter again runs it anyway

PS> docker compose up

Fig. 7Held once, with your line kept on a fresh prompt: two minutes saved, and the fix one key away.

7

Fixes

After a failure, the fix is waiting.

When a command fails, reman prints what you ran next the last time, when that worked, and what it changes. It learns these pairs from you, so it knows your missing upstream and your peer-dependency flag, not just typos. Alt+F puts the fix on your prompt.

Proven fixes first, then the closest command that worked.
What the fix changes, word by word: adds --build, ci → install, gti → git. You judge it at a glance.
The same error from a different command gets what fixed the first one.
With no fix waiting, Alt+F moves a word, and accepts a word of your shell's grey suggestion, as before.
Nothing ever runs by itself. You press Enter.

powershell · ~/work/api

PS> git push

fatal: The current branch feat/search has no upstream branch.

reman: last time this failed you ran -> git push --set-upstream origin feat/search

(adds --set-upstream origin feat/search; Alt+F inserts)

PS> git push --set-upstream origin feat/search

PS> gti status

gti : The term 'gti' is not recognized as the name of a cmdlet

reman: did you mean -> git status (gti → git; Alt+F inserts)

Fig. 8The first fix was learned from what was run right after the same failure; the second is a typo of a command you run every day.

8

Next step

The next step, one key away.

On an empty prompt, Alt+N puts what you'd run next here: the next step of a flow you started, the fix for what just failed, or what you usually run after your last command. It lands on your prompt, never runs. Press it again for the next idea.

Flows. Sequences you repeat (pull, install, migrate, start) are found in your history. Open one in the finder and each next step waits on ↑ and on Alt+N.
Only commands you ran yourself: never an agent's one-off script.
Clearing the screen doesn't count as a step. cls never decides what comes next.
With text already typed, Alt+N keeps its usual meaning.

powershell · ~/work/webfocus here and press Alt+N

press it a few times

Fig. 9After docker compose up -d, three ideas in order: the flow's next step, what usually follows, what you often run here.

9

When it breaks

When it breaks, it knows what changed.

Every run keeps the git branch and commit it ran on. So when a command that kept working starts failing, reman can say more than "it failed": it worked on main and you're on a feature branch now, or new commits came in, or the commit is the same and the change is somewhere else.

Read from the files under .git, never by running git. Worktrees and any spelling of the remote count as one repo.
reman why shows every run since it last worked, with the branch where it changes, and how to compare: git diff main...feat/x.
Flaky, not broken. A command whose result keeps flipping both ways, with no new commit and no install in between, is called flaky when it fails. Nobody changes code over it.
Agents get the same: reman_check says which branch it worked on, and tells them to retry a flaky one before editing.

main

✓✓✓✓

feat/x

✗✗

npm test worked here 4 times, last 2 days ago; it worked on main, you're on feat/x now. Compare them: git diff main...feat/x

flaky✓✓✗✓✓✗✓✗✓flips six times, nothing changed in between: "flaky here, try it again"

a normal day✗✗✗✓✓✓✗✓✓broken, fixed, broken, fixed: you editing code, not flaky

Fig. 10Above, the same test on two branches. Below, two run histories that look alike and aren't.

10

Your folders

Walk back in where you left off.

reman knows what happened in each folder, and when. Open a terminal in a project you left days ago and it tells you what you did there. Go to a folder by what you did in it. Ask it what yesterday looked like.

Last time here. One line, once, when you come back to a folder after a while.
rcd. rcd alembic goes to the folder where you ran it; rcd billing api goes by the folder's name. rcd alone lists where you were lately, and rcd 3 goes there.
Your day. reman yesterday, reman today, reman day monday: what you ran, by project, with failures and what fixed them, and what each agent did there. Good for a standup.
What broke it? After a command that kept working here fails: what ran in this folder since. reman why tells the whole story.
Runbook. reman runbook writes how the project is run, by task, from the commands that worked. A local model (Ollama, LM Studio) can arrange and explain it; it never invents a command.

powershell

PS C:\> rcd alembic

→ C:\code\billing-api (alembic upgrade head, 2 days ago)

reman: last time here (2 days ago): docker compose up -d → alembic upgrade head → pytest -q

PS C:\code\billing-api> reman yesterday

Yesterday, 9:12 to 18:40

billing-api (main) 9:12 to 12:30

docker compose up -d → alembic upgrade head → pytest -q (4x)

✗ docker compose up → ✓ docker compose up --build (fixed)

claude-code ran 38 commands here (3 failed)

web-shop (feat/cart) 14:05 to 18:40

npm run dev → npm test (3x)

✗ npm run lint still failing (2 failures)

Fig. 11Jump to a project by what you did there, and the day before, told back to you.

11

Agents

Your agents stop guessing commands.

Claude Code, Codex and Cursor usually write commands from scratch. With reman they ask first, and reuse the ones that already work on your machine. reman never generates a command; every result is one that really ran.

Connected automatically at install: ten MCP tools, plus a local HTTP endpoint for SDKs and scripts. reman_output tells an agent what a command printed last time, instead of running it again. reman_runbook tells an agent how the project is run before it guesses. reman_running tells it which servers are already up and who started each, so it uses your dev server instead of killing it. reman_check says when a tool isn't installed here, so it doesn't retry it.
Agents see no history until you approve a folder, not even the project they are working in. An agent cannot approve one for itself.
No close match means an empty answer, not the least-bad guess.
What Claude Code and Codex run is recorded too, with how long it took and what a failure printed.
Stuck in a loop? When Claude Code runs a command that fails the same way for the third time, its hook tells Claude right there: running it again unchanged will fail again. reman agents lists every retry loop of the week.
reman_check also says how long a command usually takes, so an agent waits instead of calling it hung.
Secrets are redacted. In strict mode, anything still secret-looking is withheld.

claude code · tool call

▸ reman_search({ "intent": "run database migrations" })

[{
  "command": "alembic upgrade head",
  "run_count": 18,
  "success_rate": 1.0,
  "description": "Upgrade the database to the
                  latest revision",
  "last_run": "6d ago"
}]

Fig. 12What an agent gets back: a real command, with its record.

Claude runs a command

$ cargo build -p api
error[E0425]: cannot find value `cfg` in this scope
(the third time, the same error)

reman, in Claude's context

cargo build -p api has now failed 3 times in a row, the same way each time. Running it again unchanged will fail again: change something first, or ask the user.

Claude

Building again won't help. Let me find where cfg is defined first.

Fig. 13The loop is broken from inside: the note arrives in Claude's own context, next to the error.

12

Sessions

Find the session that did it.

Somewhere last week an agent fixed the migrations. Which chat was that? reman keeps each coding agent's session id with every command it ran, so you can find the session by what it did, and pick it up where it stopped.

reman sessions. Your agents' sessions, newest first: where each worked, what it built, tested, installed or migrated, and how it went. The sed and grep an agent reads files with is left out.
By meaning, text or folder. reman sessions migration last week matches what a session ran, a file it touched, or its folder's name; time words narrow it.
reman resume. Reopens the best match in its own folder: Claude Code, Codex, Gemini CLI and opencode. A number picks another match.

powershell

PS C:\code> reman sessions migration last week

1 claude-code 3 days ago (2h) · 38 commands, 3 failed

C:\code\billing-api

alembic upgrade head (2x) → pytest -q (4x)

ran: alembic upgrade head

resume: claude --resume 4f1c2a7e-…

PS C:\code> reman resume migration last week

reman: claude-code's session from 3 days ago

in C:\code\billing-api

claude --resume 4f1c2a7e-9b3d-4c21-a8e0-6d2f1b7c9e10

Fig. 14Found by what it did, reopened where it worked.

13

Specifications

Fast enough to live on `↑`.

One Rust binary. The whole history stays in memory and the search model stays warm, so the finder answers before you finish typing.

Search by meaning, per keystroke	8 ms
Did-you-mean after a failed command	4 ms
Next-command prediction	0.2 ms
Browse recent history	3.5 ms
The check when you press Enter (one round trip)	3 ms
`Alt`+`N`, the next step	1 ms
`rcd`, `reman yesterday`, `reman agents`	4 to 12 ms
Added to each command you run: PowerShell	no process spawned
Added to each command you run: bash, zsh, fish	5, 2, 5 ms
Search model	bge-small-en-v1.5, runs locally
Where your history lives	~/.reman, on your machine

Median timings on a history of about 6,000 commands and 21,000 runs; the newer rows on one of about 7,700 commands.

Private by default

Your history never leaves your machine; the one request reman makes is a daily check for a new version, which reman settings turns off. Secrets are masked before anything is saved, a command typed with a leading space is never recorded, and Del Del forgets one everywhere.

Every shell, one history

PowerShell, bash, zsh, fish, nushell, xonsh and Command Prompt, plus the commands your agents run, tagged with the agent's name.

One settings page

reman settings, or F10 in the finder: coding tools, shared folders, privacy, done alerts, keys and shells. Saved as you change them; key changes when you press s.

14

Installation

One command. Nothing to configure.

Run the installer below. It downloads the latest release and checks its SHA-256.
Setup wires your shells and connects every coding tool it finds. Each config it touches is backed up first. Coming from Atuin? It imports your history too.
Open a new terminal and press ↑. The first start downloads the search model once, about 130 MB.

$

Or download	file
Windows 10 and 11, x64	reman-windows-x64.zip
macOS, Apple Silicon	reman-macos-arm64.tar.gz
Linux, x64	reman-linux-x64.tar.gz
From source, Rust 1.85 or newer	cargo build --release

Staying up to date. Once a day reman asks GitHub whether a new version is out, and tells you when one is. reman update installs it; reman update --auto on lets reman install new versions on its own. Every release is signed, and reman installs only what carries its signature and matches its signed checksum: never an older version, and never a file changed on the way.

15

Every feature

Everything it does, on one card.

Find it
Search by meaning	`tear down containers` finds `docker compose down -v`. Typed text and typos work too.
Time in a search	End with when: `deploy last week`, `docker yesterday`.
Commands with a blank	Thirty-eight commit messages are one line; Enter puts the cursor in the blank.
Under your prompt	The finder opens below the prompt, your own commands first, agents' one key away.
Every run	When, how long, who, which branch, and what that run printed.
Before and after it runs
Track record	Worked every time, failed every time, or how often. A command that only failed never leads.
How long it takes	Usually 3m 12s; a desktop note when a long command finishes.
Held before it fails	A slow command that keeps failing here waits for a second Enter, with why.
Fixes, learned from you	After a failure, what worked last time and what it changes, one key away.
When it breaks	What changed since it last worked: the branch, new commits, an install. Flaky, not broken.
Your work
The next step	What you usually run next here, from your own habits, on one key.
Flows	Sequences you repeat, walked through a step at a time.
Your folders, your day	`rcd alembic` goes where you ran it; `reman yesterday` tells your day by project.
Runbook	How a project is run, from the commands that worked there.
What it printed	`reman shell` keeps your commands' output; `reman output` finds it.
Your agents
Real commands only	Claude Code, Codex, Cursor and others ask before guessing; ten tools over MCP and HTTP.
Only what you share	No history until you approve a folder. An agent can't approve one for itself.
Loops broken	An agent retrying a command that keeps failing the same way is told to stop.
Sessions	Find the agent session that did it, and reopen it where it worked.
Yours
Your own keys	Every key reman takes can be changed or turned off: `reman settings`, Keys (`F10` in the finder). Open shells take a change at their next prompt. Presets: standard, gentle, vim.
Private	On your machine only. Secrets masked before saving; a leading space is never recorded.
Every shell	PowerShell, bash, zsh, fish, nushell, xonsh and Command Prompt, plus what your agents run.
Updates	Told when a new version is out, or installed on their own with `reman update --auto on`. Signed releases only.
Open source	Apache License 2.0. One Rust binary for Windows, macOS and Linux.

Every key is listed in the finder (F1) and by reman keys, as you have them.

Everything reman does.

Contents

Type what you mean, not what you remember.

Ten copies that differ by one word are one command.

Find it by when you ran it.

Every run, and what it printed.

Reuse the one that worked, not the newest.

It tells you it'll fail before you wait for it.

After a failure, the fix is waiting.

The next step, one key away.

When it breaks, it knows what changed.

Walk back in where you left off.

Your agents stop guessing commands.

Find the session that did it.

Fast enough to live on `↑`.

Private by default

Every shell, one history

One settings page

One command. Nothing to configure.

Everything it does, on one card.

Everything reman does.

Contents

Type what you mean, not what you remember.

Ten copies that differ by one word are one command.

Find it by when you ran it.

Every run, and what it printed.

Reuse the one that worked, not the newest.

It tells you it'll fail before you wait for it.

After a failure, the fix is waiting.

The next step, one key away.

When it breaks, it knows what changed.

Walk back in where you left off.

Your agents stop guessing commands.

Find the session that did it.

Fast enough to live on ↑.

Private by default

Every shell, one history

One settings page

One command. Nothing to configure.

Everything it does, on one card.

Fast enough to live on `↑`.