Using the harness

Interactive TUI

Running minima with no prompt opens the interactive terminal UI: a scrolling conversation view, an input prompt, and a status bar. Type a message and press Enter to send it; the harness routes it, runs the chosen model, streams the reply, and executes any tool calls (asking permission where required).

The status bar

The bar along the bottom shows, at a glance:

Model — the pinned model, or auto when Minima is routing.
Cost — running total from the cost meter for this session.
Context — percentage of the model's context window used, plus token counts.
State — whether a turn is in flight, plus plan/verification state when plan verification is active.

Keyboard shortcuts

Key	Action
`Enter`	Send the current prompt
`↑` / `↓`	Cycle input history (at the prompt) · navigate items (in a picker)
`Alt`+`←`/`→`	Jump by word (also `Alt`+`B`/`F`)
`Ctrl`+`A` / `Home`·`End`	Line start / start·end
`Ctrl`+`K` / `Ctrl`+`U`	Kill to end / to start of line
`Ctrl`+`W`	Kill the previous word (also `Alt`+`Backspace`)
`Ctrl`+`V`	Paste clipboard (terminal paste also works)
`Ctrl`+`Y`	Copy the last assistant reply
`Ctrl`+`X` `Ctrl`+`E`	Compose the current draft in `$EDITOR` (readline's `edit-and-execute-command`)
`Esc` / `Ctrl`+`C`	Abort the in-flight run (`Ctrl`+`C` twice at the prompt quits)
`Ctrl`+`Z`	Suspend to the shell (`fg` returns)
`Shift`+`Tab`	Cycle permission modes (build → accept → plan → bypass)
`Ctrl`+`L`	Open the model picker
`Ctrl`+`P`	Open the command palette (slash commands)
`Ctrl`+`R`	Toggle route mode (auto ↔ confirm)
`Ctrl`+`E`	Toggle thinking display
`Ctrl`+`T`	Table of contents
`Ctrl`+`G`	Plan Overview
`Ctrl`+`B`	Toggle the task panel
`Tab`	Auto-complete a slash command

ℹ️Note

Scrolling, text selection, and copy are native to your terminal (wheel/trackpad) — the TUI doesn't capture the mouse. In pickers, use ↑/↓ to move, Enter to choose, Esc to dismiss.

Rebinding keys

Ten of the shortcuts above are rebindable in ~/.minima-harness/keymap.toml. It is a global file — a project can never rebind your keys — and it is read once at startup, so restart the TUI after editing it.

[keys]
"thinking.cycle"   = "ctrl+n"        # Ctrl+E by default
"model.picker"     = "alt+m"         # Ctrl+L
"command.palette"  = "ctrl+p"
"route.mode"       = "ctrl+r"
"toc.panel"        = "ctrl+t"
"plan.overview"    = "ctrl+g"
"task.panel"       = "ctrl+b"
"reply.copy"       = "ctrl+y"
"permission.cycle" = "shift+tab"
"editor.open"      = "ctrl+x ctrl+e" # the only action that may be a two-key sequence

Anything you leave out keeps its default. The [keys] header is optional — rows at the top level of the file mean the same thing.

A chord is modifiers joined to one key by +: ctrl (or control) and alt (or option/meta). A printable key needs one of those two, because a bare key would also type into the prompt; shift is accepted only with tab, since a terminal sends the same bytes for ctrl+k and ctrl+shift+k. For the same reason ctrl+i, ctrl+m, ctrl+h and ctrl+[ are refused — those bytes are Tab, Enter, Backspace and Escape.

The editing keys are not rebindable, by design: the readline chords (Ctrl+A/U/K/W/D/V, Alt+B/F), abort (Esc, Ctrl+C), suspend (Ctrl+Z), Enter, Tab and the arrows. Naming one of them is reported and ignored — a keymap that could take away your ability to stop a running agent would leave you no way back.

Two actions on one chord is reported at startup, naming both, and neither wins: the actions involved keep their defaults. The same goes for anything else the file gets wrong — a bad line costs you that one binding, never your startup. /help always prints the bindings actually in effect. To ignore the file entirely, set MINIMA_TUI_KEYMAP=0.

Slash commands

Type / (or open the palette with Ctrl+P) and pick a command:

Routing & cost

Command	What it does
`/model`	Select or pin a model (or `auto` to unpin and let Minima route)
`/cost`	Show cost-meter totals
`/budget`	Show/set the session budget (`/budget set <usd>` · `/budget mode warn\|enforce`)
`/judge [on\|off]`	Toggle LLM quality judging
`/reconnect`	Reconnect the routing client

Planning & verification

Command	What it does
`/plan`	Plan mode (`Shift`+`Tab`) + the planning council (`start` · `status` · `finalize` · `cancel`) — drafts a plan whose steps carry verify checks
`/mode`	Show/set the permission mode: `build` \| `accept` \| `plan` \| `bypass`
`/bp`	Show Plan Overview status
`/why [n\|sha]`	Show the verification evidence behind the plan (or open step `n`'s card). Given a commit hash — seven or more hex characters — it reports which models contributed to that commit, its realized cost, and its gate verdicts instead
`/verify`	Adversarial whole-plan verification pass (refutation sub-agent)
`/audit`	Lint the active plan — non-discriminative checks, missing allowlists, vague steps
`/tasks`	Toggle the task panel (`Ctrl`+`B`) · `/tasks cancel` rejects the list + the plan
`/tree`	Toggle the live sub-agent tree panel

Memory

Command	What it does
`/memory`	Curated memory: `list` · `add <text>` · `pin`/`confirm`/`reject`/`delete <n\|id>` · `dream` — see the memory ledger

History & recovery

Command	What it does
`/undo`	Undo the last change — checkpoint restore + re-prompt (stacks)
`/rewind [n]`	Rewind to an earlier prompt (picker, or `/rewind <n> [convo\|code\|both]`)
`/ckpt`	List git-shadow checkpoints (`/ckpt gc` prunes old runs' refs)
`/new` · `/resume [id]`	Start fresh · resume a previous session
`/name <label>` / `/rename`	Name this session (persisted)
`/session`	Show session info
`/compact`	Summarize old turns to free context

Setup & misc

Command	What it does
`/auth`	Sign in to Mubit & provision this repo's project
`/config`	Show/set API keys (`MUBIT`, `GEMINI`, `ANTHROPIC`, …)
`/perms`	Show current tool permission grants
`/thoughts [on\|off]`	Toggle streaming the model's thinking
`/copy`	Copy the last assistant reply (`Ctrl`+`Y`)
`/editor [text]`	Compose the prompt in `$EDITOR` ($VISUAL first, else `nano`/`vi`/`vim`). It opens empty — the composer has already cleared by the time a command runs — so `/editor some text` seeds it, and `Ctrl`+`X` `Ctrl`+`E` is the path that carries a draft you are already typing. Saving applies; an empty buffer or a non-zero exit (vim's `:cq`) keeps the draft, as with `git commit`.
`/clear` · `/help` · `/tip`	Clear chat · list commands · show a tip
`/quit`, `/exit`	Exit the application

💡Tip

/model auto hands routing back to Minima after you've pinned a model. Shift+Tab cycles the permission modes — plan lets the agent read and design without touching files, accept auto-approves edits, bypass skips prompts entirely (trusted repos only).

Under the hood — what plans, gates, budgets, and memory do internally.
Model routing — auto routing, pinning, and the feedback loop.
Sessions — /new, /resume, /compact.
Tools & permissions — what the agent can do and how grants work.