Using the terminal

One window, three shapes, and a set of behaviors tuned for people who live in a terminal. Everything here works without an account.

The window's three shapes

The chrome adapts to width, not to settings:

Tabs and splits

Tabs hold layouts; splits nest in any direction, so a tab can carry an editor above two logs beside a shell. New tab with the plus button, the context menu, or Ctrl+Shift+T; split with Ctrl+Shift+D (right) and Ctrl+Shift+E (down). Tabs name themselves after the working directory; double-click to rename. All of it is remappable (Keybindings).

Saved layouts

A morning set of panes is worth keeping. Open Ctrl+K over a live session and pick Save this session as a layout: a review card lists the captured tree, one row per pane under its tab and split line, with the pane's target (this machine or a vault host's name), its working directory, and its opening command when there is one. Give the layout a name and save it. A ticked-off pane never reaches the saved item, and a layout needs at least one pane.

The trust toggle on the card, Run the opening commands when this layout opens, is off by default: open a layout and the panes come up without anything running until you decide a layout deserves it. Opening asks the daemon to rebuild the exact tab and split tree, spawn local panes in their directories and dial the hosts, walking you into the session as it comes up. A host your vault does not know or a directory that does not exist here is a named refusal, not a silent hole; a session with that name already running is offered as an attach, not duplicated.

Layouts live in your encrypted vault, the same one hosts and snippets sync through, so they stay on this machine unless Termuna Cloud syncs them. Signed out, the layouts screen says exactly that: these layouts stay on this machine, and everything else works the same. The drawer's layouts screen lists them with their pane counts, targets and last use on this machine; Ctrl+K finds one by name to open.

The command palette

Ctrl+K opens the palette. It reaches every management screen - sessions, agents, MCP servers, SSH connections, settings - which matters most in quake width, where there is no drawer to click. The screens open as views over the grid: the session keeps running underneath, and Esc puts the grid back.

Ctrl+R is the other palette: it searches the commands you have run, on this machine and, with Termuna Cloud, on every other, and Enter types the pick at the prompt without running it. A second Ctrl+R hands the key to the shell. The recording rules, the scope chips and the settings are in Command history.

Saved commands

Commands you keep retyping live as snippets in your encrypted vault, the same vault your SSH hosts sync through. The snippets screen in the drawer holds them: a name, the command (several lines are fine), and an optional note on when it is safe to run. The quickest way in is from a pane: select the text, right-click, and pick Save as snippet. The form opens pre-filled with the selection and a meta line naming where it came from.

To use one, Ctrl+K has a snippets section that filters by name, command and note as you type. Enter inserts the command at the focused pane's prompt and stops there: it never executes. A multi-line snippet types every line but leaves the last one waiting at the prompt, so you still read it before you run it. The same snippets are on the web and phone viewer.

Scrollback and search

Ctrl+Shift+F searches the scrollback. The index is built as output arrives, so search stays instant even at tens of thousands of lines. Scrollback keeps 10,000 lines per pane by default and can be raised to a million (Configuration).

Search every pane

Search has a scope switch: this pane, the pane you are looking at, and every pane, one query across every pane of every session. Dormant sessions are searched too: their persisted scrollback is scanned from disk, so the answer can sit in a session you closed yesterday. Results come back grouped per pane, with each pane's match count and the line numbers beside it. Enter on a result walks into the session and the pane of the match, on the match line.

Three ways in: the pane menu, the Ctrl+K command palette ("search every pane"), and Ctrl+Alt+Shift+F for the every pane scope directly.

Copy, paste, and paste protection

• Copy is Ctrl+Shift+C, paste Ctrl+Shift+V.
• Pasting text that contains newlines asks first: a paste is keystrokes, and the second command would run before you can read the first. Turn this off with warn_on_multiline_paste.
• The trailing newline a copied line drags along is trimmed (trim_paste).
• Double-click selects words; paths and URLs stay whole because separators are configurable.

Pick anything on screen without the mouse

Ctrl+Shift+Space puts pick mode over the focused pane: a short label beside every token on the visible screen, so a URL, a path, a path:line, a git hash, an IP address or a quoted string is a keystroke or two away. Labels come off the home row (a s d f g h j k l), one letter each while there are nine tokens or fewer and two letters past that, handed out nearest the cursor first. The whole line under the cursor is always l, except when a ninth token already holds that letter. The pane keeps running while pick mode is open.

• Type a label. Each letter dims what no longer matches; the labels themselves never move. When one token is left, the label press acts on it at once: a copy, unless pick_default_action says insert (Configuration). Type the label in uppercase to copy it and insert it in one move. Backspace takes a letter back.
• Tab cycles the kind filter: all, url, path, path:line, hash, ip, string, line. It narrows what is reachable without relabelling anything.
• Choose the action with Enter. Once a token is picked out, Enter does the default action, Shift+Enter inserts it at the prompt without running it (it goes in the way a paste does, with no Enter after it), and Ctrl+Enter opens it: a URL in your browser, a path:line in VS Code at that line when the code command is on this machine. Anything else does not open, and the action strip says why instead of leaving a dead key.
• Ctrl+Shift+S saves the token as a snippet, opening the snippet form pre-filled with it, the same as a mouse selection does.
• Esc or Ctrl+C leaves without doing anything.

A copy takes the same route as a program's copy, so it lands on the device you are using. The key that opens pick mode is pick_key, and your own regular expressions can join the built-in kinds through pick_patterns, both under [terminal]. The web and phone viewers label the same tokens.

The clipboard follows you

When a program on a host copies text (the OSC 52 escape sequence, which vim, tmux, neovim and most editors use), Termuna puts it on the clipboard of the device you are actually using: the desktop window if it has focus, otherwise the dashboard tab or the phone you last typed in. If nothing else is attached, it stays on the machine running the daemon, which is what happened before this existed.

• The copied text is sealed on the machine it came from and travels as its own frame on the same encrypted lane as your terminal output. Termuna Cloud stores and forwards ciphertext and cannot read it.
• A program can set the clipboard. It can never read it. Termuna does not answer clipboard read requests on any device, plan or host, because a remote machine asking what is on your clipboard is the one real attack in this feature. When a host asks, the pane says so once per session instead of staying silent about it.
• In a browser tab, your browser requires a click before any page may write the clipboard. When we do not have one, the dashboard holds the text and offers it on a button: nothing is dropped. A second copy replaces the one waiting rather than queueing behind it, because a clipboard has one slot.
• On the phone, a copy that arrives while the app is in the background waits and lands when you come back.
• Per host you can switch it off entirely, and per host you can pin copies to the machine running the daemon. Both live in the host's settings and travel with your vault.

Turn the whole thing off in Settings, Terminal, clipboard: Clipboard follows the focused viewer. With it off, copies land on the machine running the daemon, as before.

When a TUI owns the mouse

A full-screen app that requests mouse reporting - vim, htop, Claude Code - receives your clicks, so local selection stops. That is correct terminal behavior, not a bug, and the status bar says so the first time it happens. Hold Shift to select and scroll locally anyway. Two things always stay local: the right-click context menu, and drag selection outside full-screen apps.

Notifications and progress

For the one command you actually care about, arm the pane: right-click it and pick Notify when this quiets down. The watch is one-shot - it fires once, only if you are not looking at the pane, then disarms. It runs in the daemon, so it works over SSH with nothing installed on the remote host. The notification carries facts only - the pane, the condition, and how long it took - never a line of output. Armed panes wear a corner tag, the tab an at-rest bell, and the status bar counts armed watches ("1 armed"). The global notify_when_done setting is untouched by any of this.

• A command that ran 15 seconds or longer finishing in a pane you cannot see raises a desktop notification, and so does a bell - TUIs and agent CLIs ring one when they need you. (notify_when_done, on by default.)
• notify_on_activity additionally pings on the first output of a quiet background tab (off by default).
• Progress written as NN% in any pane shows up in the status bar (detect_progress).

Sessions and the window

The daemon owns sessions, the window views them. Closing the window ends nothing; the app reopens where you closed it, resurrecting the last session if it had gone idle. Typing exit in the last shell lands you in a fresh shell, never outside a session.

Where you stopped reading

A pane that keeps running while you are away drops you at the bottom when you come back, with no sign of what happened in between. Termuna marks the spot instead: a hairline rule sits in the pane at the row after the last one you actually read, with a count of what ran while you were away underneath it. Ctrl+Shift+J jumps the focused pane back to that rule ("go to where I left off"), and it is also a row in the command palette. It only acts when the focused pane actually has a line to jump to; with nothing to return to, the key falls through to the shell as usual.

The rule is window chrome, not content: it is drawn over the grid and never written into it, so scrollback, search, export and the mirror are exactly what the pane produced. Scrolling past the rule or dismissing it is what clears it - there is no timer.

Each device stamps its own read position: your laptop and your phone each remember what they last showed you, and the rule a screen draws is the one that screen last left. The position rides your account rather than staying on the machine, so a device that comes back finds its own place waiting for it. The web dashboard shows the same moment in its own way: a "where I left off" jump in the session bar with the device that read last named beside it, plus an unread column on the sessions list.

Agent forwarding

A forwarded agent lets a command on a remote host ask your local agent for a signature. It is how you run git pull on a server, or hop from it to a second machine, without ever copying a private key there. Forwarding is off by default and is turned on for one host at a time, on that host's profile in the SSH connections screen, next to the agent it uses.

What leaves your machine. Signatures, nothing else. The private key stays where it lives: your agent, your Secure Enclave, your YubiKey, your password manager. Termuna's daemon answers the remote host's agent channel from your own agent connection and never reads or copies key material.

What the risk is. While a forwarded session is open, anyone with root on that host can use your agent as you, for as long as the session lasts. They cannot take the key, but they can borrow it. That is true of every implementation of agent forwarding, OpenSSH's included, and it is why Termuna makes you turn it on per host.

Termuna narrows that risk three ways:

• Forwarding is per host, never for all of them. A ForwardAgent yes under Host * in an imported ~/.ssh/config is read and not applied: turn it on for each host instead.
• The host is offered only the identities you ticked. The allowlist on the host's profile is optional; without one, every identity your agent holds is offered.
• Every signing request prints a line in the pane while it happens, naming the host that asked and the identity used, so a host that borrows your agent while you are not looking leaves a line you can find later.

Typing from your phone. A pane attached from the phone or the web dashboard runs on your desktop daemon, so the signature is made at your desk. Type git push on a server from the train and the key stays in the laptop's secure storage, the relay carries ciphertext it cannot read, and the remote host holds nothing.

When forwarding does not happen. Each refusal is named in the pane, so you know who said no:

• The server has AllowAgentForwarding no in its sshd_config. The pane says so and names the setting; there is nothing to fix on your side.
• The host key changed since you trusted it. Termuna refuses to forward until you have reviewed the new key.
• The pane redialed after a dropped link. A redial is a new connection and it does not inherit the agent.

Next: Keybindings