Tether 0.9.0

Tether 0.9.0

Released 2026-10-30

Highlights

• Connections stay up like plain ssh: a short outage, a Wi-Fi hand-over, locking the screen or the Mac sleeping no longer ends them, so nobody has to sign in again.
• One sign-in per server, however many tabs, file windows, transfers and port forwards want it at once — and a typed password can answer the same server's later sign-ins while Tether runs (Settings ▸ Passwords ▸ Signing In Again).
• A terminal scrolls back, finds (⌘F) and jumps between commands (⌘↑ / ⌘↓) through its whole session, however long, from its recording — without the memory growing.
• The file manager copies, pastes and drags files between servers, terminals and Finder, and searches a folder and everything below it on the server.
• Tether updates itself: Help ▸ Check for Updates… builds the new release in the background and installs it when you quit.

New

• Scrolling back past what is in memory shows the session's earlier output from its recording, however long — hundreds of thousands of lines. It is read in the background (decrypting and decompressing included) a chunk at a time as you scroll, keeping the line you look at in place, in a view over the terminal: the terminal itself is never rebuilt, so what runs in it goes on untouched (its screen, the modes a program set, prompts), and nothing in the earlier output acts as new (terminal queries are not answered, old titles, folders or OSC 52 copies do not replace the current ones). The scroller stands for the whole session: drag it anywhere and that part is shown. Lines wrap exactly as the terminal does, also after a resize or a move to another screen; selected text is kept and copied with ⌘C, Copy or the terminal's new right-click menu (Copy, Paste, Select All); ⌘K shows the cleared terminal. Typing, scrolling down or Back to Live returns to the terminal at once. This also works in tabs brought back after Tether reopened.
• Find in the terminal (⌘F) also looks through the earlier output in the recording, from its end back: the matches nearest to what you see come first, shown and counted while older ones are still looked for ("12+ found · 40 %", how far in its tooltip), marked beside the scroller for the whole session, and ↩ / ⌘G / ⇧⌘G step through them as they arrive — to each next match in the text, in both directions, also where a program redrew its output in place (docker compose, build progress, coding agents). A match in the recording is shown selected and flashes, as one in memory does; ⌘F while scrolled back selects the match on screen at once. Regular expressions and the other options work there too, and a long recording is searched many times faster than it is laid out. Output that cannot be read (encrypted while Tether is locked, or with another key) is left out, shown by a lock in the find bar. The Search window looks through ended sessions' recordings the same way.
• ⌘↑ / ⌘↓ go to the previous or next command however much output lies between (from the recording when it left memory), and ⇧⌘↑ / ⇧⌘↓ select whole commands of any length ("3 commands selected · 52,340 lines"), copied in full with ⌘C or Copy. Commands are noted in the recording (invisibly, with the time), so this works far back and across relaunches; quick repeated presses each count.
• File manager copy and paste across servers: files copied (⌘C, Edit ▸ Copy) in one file manager paste (⌘V) into another server's file manager, a terminal or Finder. On their own server they are copied there (into a terminal: their paths typed); from another server they come through this Mac, the temporary copy removed afterwards; pasted into another server's terminal they go where files pasted from Finder go (Settings ▸ Transfers: the terminal's folder, /tmp, or asked). The work under way shows with a spinner ("Getting 3 items from web-1…"), then how it went ("Pasted 3 items from web-1 into data", with what was renamed or could not be downloaded), and the pasted items are selected; a macOS notification tells how it ended when Tether is in the background. Folders and files can be mixed, many files travel as one packed stream, and nothing is replaced. File manager windows have Transfers (⌥⌘L) in their toolbar too. Dragging files onto another file manager or a terminal does the same; dropped back into their own folder, nothing happens.
• File manager search: the search field (⌘F in a file manager) filters the folder as you type, and ↩ searches it and every folder below on the server — names containing the text, a name pattern (*.log, report-202?.pdf), or files containing the text. Results show which folder they are in, every action works on them (copy, download, drag, delete…), and Show in Enclosing Folder opens their folder. Hidden folders are searched only with hidden files shown; it stops after 1,000 matches or when you press Stop. Uses only find, grep and stat on the server (PowerShell on Windows).
• Tether updates itself: a newer release is downloaded and built in the background (from its source, at low priority; needs Apple's command line tools) and installed with make install when you quit — or now with Restart to Update. Help ▸ Check for Updates… opens the Software Update window: what the new version brings, the download's and the build's progress (with Cancel), and Restart to Update once it is ready; the first time the updated Tether opens, it shows what changed. Settings ▸ General ▸ Updates turns the daily check and the automatic install on or off (both on by default). Without the build tools you get the release page.
• Settings ▸ Passwords ▸ Signing In Again: a password you type (or a saved one unlocked with Touch ID) also answers the same server's later sign-ins while Tether runs — a reconnect after the connection really ended, a further connection for many tabs. It is kept only after the server accepted it, only for that connection (host, port, user and jump host), encrypted by a Secure Enclave key that exists only until Tether quits, and never written anywhere; it never answers sudo, a one-time code or a server's own text, and a saved password remembered this way still asks for Touch ID as set. It is forgotten as soon as a sign-in it answered fails (also when the server hangs up instead of saying no), so a changed password is never retried on every reconnect, and a server's connections sign in one after another, so it is never sent by several at once. Each remembered entry is listed with Forget; choose to forget them 1 hour, 8 hours or a day (the default) after they were typed (using one does not extend it) or only when Tether quits, and optionally when the screen locks. A key's passphrase is remembered the same way, for the key: typed once, it opens that key for every server and tab that uses it while Tether runs, also a jump host and its target using the same key, and it stays when a server turns the key down. See docs/connections-and-passwords.md.
• Help ▸ Connection Log: sign-ins (how long they took, how ssh signed in, and its steps: where it connected, the server's software, which ways of signing in the server offered), connection checks, connections closed and how long they lived, tabs connecting, connected, letting go, trying again and re-attaching (with how many lines were printed while away), sleep and network events with the network interfaces in use, App Lock, port forwards. Each event names its host and tab. Show everything, notices and problems, or problems only; filter by host or kind of event, or search. Copy and Save… take what is shown. In memory only (the last 3,000 events), never a password; also in macOS's log with host names private.
• A shell or tmux session that ends on the server without being asked to says why when the server tells: "the server's kernel ended example-worker for lack of memory at 09:30", low memory, an idle limit (TMOUT), a restart, a signal. One short read-only look over the connection; also in the Connection Log.
• Ending a tmux or screen session whose connection is down reaches the server first (one sign-in if needed); if it cannot be reached, choose End When Connected (done as soon as it can be, also after relaunching; the sidebar shows "Ends when connected", and opening the session or Don't End takes it back) or Disconnect.
• A tab on a system without tmux or screen (its shell ends when the connection drops) offers Keep Shells Running… in its footer: the install command for that system's package manager (sudo apt-get install tmux, brew install tmux on the Mac, …), typed into the terminal for you to run — Tether installs nothing itself. It can be turned off per host.
• Settings ▸ SSH ▸ Multiplexing ▸ Keep connections open after quitting (off by default): relaunching within the time set signs in nobody.
• Docker, Docker Compose and Podman in a terminal show their own symbol on the tab and in the sidebar, moving while they work, with what they are doing in its tooltip (building an image, running services, following logs, inside a container, …), as coding agents do. Settings ▸ Terminal has the switch.
• A failed transfer can be sent again with Retry in the Transfers list: from the start, with free names chosen again, never overwriting anything.
• When Tether stops answering for a few seconds, or takes long to quit, it keeps a record of where it waited (macOS's sample, in ~/Library/Logs/Tether, on this Mac only; the last five) and notes it in Console; a slow tab switch is noted too.

Improved

• Connections: Tether sends no keep-alives by default (your ssh_config still applies; forced ones ended connections after 30 s of silence, also right after waking). Each shared connection holds a silent channel, so it never closes merely because no tab used it for a while, also when every tab was moved to the background and across sleep. Before the Mac sleeps, tmux and screen tabs let go of their server sessions and monitoring pauses, so servers send nothing to a sleeping Mac; after waking or a network change (Wi-Fi to Ethernet, a VPN) each connection is checked over its own link and closed only when it is really dead, and tabs re-attach through the connection that survived. A tmux tab re-attaches after 15 s without an answer (was 6 s), counting only time the Mac is awake and the network is there.
• A server that does not answer is tried once for all its tabs, however many there are, also without connection sharing: its tabs wait together, twice as long after each failed try (2 s, 4 s, 8 s … up to 2 minutes, was 30 s per tab), and try at once when the network comes back, when another tab to that server connects, or when you press Reconnect Now. A new tab to such a server keeps waiting for it instead of giving up after three tries (an unknown host name or a changed host key still end it); a wrong password or a cancelled question pauses only that tab, and the server's other tabs go on with their own sign-ins. Host panels ask such a server less and less often too. Settings ▸ Sessions ▸ Reconnecting sets how long a server is given to answer (20 s, also without connection sharing, where it was ssh's own limit of a minute or more), the first wait and the longest one.
• Settings ▸ Sessions ▸ Connection Health: keep-alives on or off, how long the network may be away before tmux and screen tabs detach, and how long a silent connection is given before it is closed.
• One sign-in per server: the file manager, transfers, port forwards, monitoring and uploads into a terminal's folder use the same connection as the tabs and never sign in on their own; a further connection (many tabs) waits for the sign-in in progress so one typed password answers both, and without connection sharing every tab's own sign-in uses it too. Hosts behind the same jump host sign in to it once, and two names for the same server (aliases with the same host, user, port and jump host) share one connection; direct connections to one address through different jump hosts never do. Port forwards no longer keep a channel that printed every 30 s.
• Keys with a passphrase: many hosts and tabs opening the same key at once ask once; the key prompt names the key file and offers Skip This Key (ssh goes on with the next key or the server's password); a security key waiting to be touched says so, and AddKeysToAgent ask gets Yes and No. Settings ▸ Passwords marks saved passphrases whose key file is gone, and changing a passphrase in Settings ▸ SSH ▸ Keys forgets the old one. See docs/connections-and-passwords.md ▸ Key passphrases.
• File ▸ Save Session… (⌘S) asks what to save: the whole session (everything since it started, however long), only what the terminal holds now, or the last command and all it printed — as text or raw output (with colors). It opens in your Downloads folder; Settings ▸ Terminal ▸ Saving a Session sets what it starts with and another folder.
• ⌘↑ / ⌘↓ go to the command nearest to what is on screen, as in Terminal.app: after scrolling (the wheel, the scroller, a find's match) ⌘↑ goes to the command above and ⌘↓ to the one below; from the prompt, and after typing, ⌘↑ goes to the last command; after the last command ⌘↓ stops on the line being typed on, and past that it beeps. They select the command itself — what was typed after the prompt, wrapped lines included, from its first line — so ⌘C copies just the command, in shells and in programs with a prompt of their own (python, mysql, coding agents); ⇧⌘↑ / ⇧⌘↓ select the command ⌘↑ / ⌘↓ would go to. Commands typed while the connection was away are marked once they are sent, and long lines that wrap differently after a resize keep the command marks and the line you look at on their text.
• Find (⌘F) searches once typing pauses (Settings ▸ Terminal) and no longer slows the terminal while output streams: only the lines that can have changed are looked through again.
• A global search result in a terminal's earlier output opens in that terminal, at the line, with its find bar on the matches (it opened a separate transcript window before), without reading the whole recording first. Global search reads unchanged terminals' text only once, reads recordings line by line and stops when it has enough matches; nothing on disk is read on the main thread while typing.
• A program that redraws its output in place — a build's progress (docker compose build, npm), a screen that refreshes itself (docker stats, a dashboard) — leaves in the scrollback what it shows at the end, not every update on the way; what you see before you run it, clear and Ctrl+L keep the screen above as before, and the recording keeps everything. Settings ▸ Terminal ▸ "Keep every frame a program redraws in place" brings every update back.
• Quieter notices over the terminal: "Reconnected" is a small label for 3 s (why the connection dropped is in its tooltip; a click opens the Connection Log), "Connecting…" shows only when connecting takes more than a moment, and reading earlier output from the recording shows a small spinner beside the scroller.
• Packed transfers are compressed as they flow with zstd, lz4 or gzip — the fastest both ends have — or xz or bzip2 when chosen (Settings ▸ Transfers ▸ Compress packed transfers; or off); compression did nothing before on a shared connection. On a small or busy machine automatic compression uses lz4 or none, and a method chosen in Settings asks first for large transfers (Send Without Compressing / Compress Anyway, remembered for the host if you like). 5 or more files now go as one stream (was 20), Always sends single files packed and compressed too, and progress counts the files' own bytes. A server without tar gets the files one by one, saying so, and a compressor missing on one end is named.
• Transfers say what they are doing: before a large one starts, "Checking 2,000 names on the server…" or "Counting files… 12,345 files, 3.2 GB so far" with Cancel (counting is much faster and off the main thread); packed transfers show each step (asking the server what it has, packing and compressing, sending, unpacking, moving into place, removing temporary files) in the Transfers list and the upload bar over a terminal. A dropped connection says so ("The connection to … was lost"), and a transfer that moves nothing for 2 minutes (10 while still connecting) stops with a clear message.
• Quitting Tether stops running transfers and removes what they had copied so far (partial files and staging folders they made, nothing else); staging folders an interrupted packed download left behind are removed the next time you download into that folder.
• Dragging many files or folders from the file manager to Finder or the Desktop sends them together like any other download — as one packed, compressed stream when there are enough of them, shown as one transfer — and they arrive once it has finished; a cancelled one hands nothing to Finder. Copying says when the items are ready to paste in Finder, also when only some could be downloaded.
• Inspector ▸ Logs: choose Errors or Warnings and Errors and the server sends its last errors (journalctl's priorities, the Windows event levels, log show's errors and faults, dmesg's levels, the usual words in a log file) — not only the errors among its last few hundred lines. A short log sits at the top, the line count says what was asked for, and an empty result says so.
• Clean Up of leftover sessions asks first, names them with when they were last used, and can open them as tabs instead of ending them.
• The command history shows when each command started and ended (to the second, dimmed under the command), loads in the background at launch, and adds each change to a small journal instead of rewriting the host's whole file.
• The transcript window scrolls through every line of what it shows (16 MB at a time, Earlier / Later for the rest), also for sessions with hundreds of thousands of lines; it was cut off at 100,000 lines. Output with very short lines is paged in smaller steps instead of taking gigabytes of memory.
• Recordings are compressed while the Mac is idle (keyboard and mouse left alone for 2 minutes, not in Low Power Mode), one file at a time, stopping as soon as the Mac is used — no longer while a busy terminal writes; only a full storage limit compresses at once. Settings ▸ Recordings shows what waits, when it last ran and what it saved, with Compress Now. Maintenance runs once for many requests, remembers which recordings are already encrypted, masks secrets only in recordings that have some, opens long encrypted recordings faster, and waits ten minutes before retrying when the disk is full.
• Output of a command in a shell nothing else keeps (a plain or local shell, Windows) is written to its recording within seconds, so a crash loses little of it; screen sessions write every 30 s like those (only tmux gives its history back after a crash). Very long sessions of short lines keep a small index, and busy recordings check the storage limit at most once a minute.
• Less writing to the SSD: scrolling back, finding, searching and copying no longer make the recording write early; quiet terminals' recordings are written every 30 s instead of 15 s (5 minutes inside tmux, which keeps the output on the server too; at once when the connection drops, before sleep and when quitting); samples of a long-running command are written every 5 minutes instead of every 30 s; window, tab and session state is written only when it changed and at most every 10 s (at once before sleep and when quitting).
• Tabs use far less memory: a tab off screen for a minute keeps its last 2,000 lines and brings the rest back from its recording when you scroll up, and scrolling back takes at most about 64 MB per terminal. When the Mac runs short of memory, tabs off screen are trimmed at once and copies kept for finding and hidden history views are let go of.
• Much less CPU: a program that redraws all the time (a coding agent's spinner, progress bars, top) is drawn about 15 times a second while you are not typing in it and about 5 while Tether or its window is not in front (was up to 60), every change drawn at once right after a key, a click or a scroll; moving or hiding the cursor no longer lays out the whole window; fast output updates the scroll position once per read; output of tabs off screen is processed a few times a second; tabs off screen pass on animated titles at most once a second, and a stream of bells rings at most five times a second. The moving marks on tabs and the transfers button are animated by macOS at next to no CPU. Scrolling back through a long coding-agent session lays out earlier output off the main thread and no longer freezes the window.
• Less work on servers: the host status bar reads disks every 30 s and GPUs every 10 s, and every 5 s when the host panel is closed (values that do not change are read once); the look at tmux sessions asks ps about the panes' terminals only. With no Tether window visible, monitoring panels stop asking servers, and running commands are looked at every 15 s.

Fixed

• Stricter handling of image escape sequences.
• One server that stops answering no longer holds up the others: its transfers no longer keep other servers' transfers waiting in the queue (for up to ten minutes), coding-agent status on other hosts is no longer delayed by it, and switching networks (Wi-Fi, a VPN) right after waking is noticed even while it is still being checked.
• When a program left mouse reporting on after it ended (it crashed or was stopped), the scroll wheel typed characters like 64;41;22M at the prompt instead of scrolling. Once Tether sees the shell back at its prompt, the wheel scrolls the history and clicks select text again; programs that use the mouse keep it while they run, and Allow Mouse Reporting (⌘R) turned on for a terminal still wins. On this Mac and on servers, in plain shells and tmux.
• Re-attaching to a tmux tab (also after reopening Tether) printed the server's whole history again ("earlier lines may repeat") when the window was not as wide as when the output was written, or when a line was still being written as the connection dropped (a prompt, a progress bar); the place is now found whatever the width. Output added after re-attaching is recorded so that it replays the same at any size (it covered earlier lines and misplaced command marks), long lines printed while away are no longer cut at tmux's width, and "%exit" no longer appears when a tmux tab lets go of its connection.
• Re-attaching to a tmux session with a long history could freeze Tether for seconds to minutes.
• After a relaunch, each restored tmux or screen tab started a new recording and recorded its server history again; a restored tab now goes on with its recording, adds only what the server printed meanwhile, and scrolling back, ⌘↑ and find reach past the relaunch.
• A tab brought back after a relaunch could be ended for good ("the session no longer exists") when tmux could not be asked (another tmux version after an upgrade, or tmux missing) although the session was still running; it now waits for Reconnect and says why. A tmux.conf with destroy-unattached no longer ends Tether's sessions when Tether lets go of them.
• Tabs could be left out of what the next launch brings back: after quitting while Tether was still locked, while restored tabs were still reopening their recordings, or within 10 s of opening a tab before a crash or a forced quit.
• Each window keeps its own sidebar and host panel — shown or hidden, their widths and the host panel's tab — also after relaunching Tether, and a new window opens with them as last left. Before, the sidebar was always shown again, its width was lost, and all windows shared one host panel setting. A new window could also stop remembering its position and size when it took the place of a closed one.
• Password and sign-in prompts: every tab of a server asked separately when its shared connection had ended, or when a transfer or file window started at the same time as a tab; tabs of a server that were all disconnected or in the background asked again after about ten minutes; a slow check of a shared connection could close it while other tabs used it; cancelling a sign-in stopped only some tabs from asking again; a withdrawn background prompt let the server's other background tabs each ask in turn; and without connection sharing, a sign-in that never finished could hold up the server's other tabs for good.
• After the network changed (another Wi-Fi, a VPN), tabs could wait about a minute on a connection that had died with the old network: such a connection is now judged within 10 s (20 s in general, was 45), the tab says it is checking, and the next sign-in follows by itself. Retry and Reconnect Now did nothing while an attempt hung on a dead connection; they now start again at once.
• A tab whose connection dropped was sometimes ended as "Shell exited (code 65280)" instead of reconnecting.
• Quitting left shared connections running for up to ten minutes (they now end at once), and could hang: if Tether has not ended 10 s after ⌘Q, it ends itself (tmux and screen sessions keep running).
• Closing a session that runs in the background could quit Tether, and closing a window with Keep in Background (or Move Tabs to Other Window) could leave it on screen, drawing nothing.
• A password typed into Quick Connect without saving it stayed in memory, unsealed, until Tether quit; it now answers that connection's first question and is dropped after a minute or when the screen locks (after a successful sign-in it is kept only as Signing In Again keeps typed passwords).
• The password window opens centred over the Tether window in front, at its own size, with its field ready to type in.
• A server that asks something before its shell starts (a notice to accept, a menu) had its question hidden behind the connection card; the card now steps aside once the server waits. An account with a restricted shell (rbash) failed to start; Tether now opens a plain login and remembers the host as a limited shell.
• A key's saved passphrase is answered without asking only when the ssh asking marks a server's own questions (OpenSSH 8.4 or later, also the ssh a jump host or ProxyCommand starts from PATH); with an older one such a question is shown with a warning and nothing is saved. The terminal bar fills a saved passphrase only while ssh (8.4 or later), ssh-add or ssh-keygen on this Mac is reading it, checked again right before typing, so a server can no longer obtain it by printing a look-alike prompt.
• A saved or remembered sign-in password is filled in by itself only when the ssh asking marks a server's own questions (OpenSSH 8.4 or later), checked for the ssh that actually asks — also one a ProxyCommand starts from PATH. With an older ssh, a jump host could word its own question as the target's and receive its password; such a question is now shown with a warning instead.
• A key reached through a symbolic link or spelled differently in different hosts kept a separate saved passphrase for each, and key setup with the macOS ssh-agent now also writes IgnoreUnknown UseKeychain, so other ssh builds (Homebrew's) no longer refuse the config.
• ⌘C and ⌘V in the file manager often did nothing: a click selected rows but left the keyboard elsewhere (a Files tab, the terminal beside the host panel's list, or the path field — ⌘V then pasted the copied paths into it), and the list lost the keyboard when the details appeared. A click that moved the mouse a pixel started a drag and selected nothing; the list now takes and keeps the keyboard, and a row dragged a little is selected, as in Finder.
• Files dragged from the file manager to Finder could never arrive when another drag began meanwhile, could arrive with the extension twice (go.mod as go.mod.mod) or lose a leading dot (.env as _env); a copy that left nothing is reported as failed, never as done.
• Free names for a copy follow Finder both ways: the number goes before an extension that reads as one (go 2.mod on the Mac, go-1.mod on a server) and at the end otherwise (v1.2 2, app.log.1-1, .env-1); names at the 255-byte limit are shortened before their extension, also with letters macOS stores in several parts (ç, é).
• Thousands of names at once no longer fail on the server ("argument list too long") or on this Mac (more than 4,096 arguments).
• Cancelling a single-file (scp) transfer did not stop it: it stayed "running" for good and could hold up later transfers. Cancel now ends scp and its ssh, also while waiting for the sign-in, and the next queued transfer starts at once. A cancelled packed transfer stops tar, the compressor and ssh on both sides and removes its staging folder on the server.
• A cancelled, cut-off or interrupted packed upload could leave part of its files at the destination or an empty folder it made, or still be moved into place after a cancel; the server now moves nothing into place unless the whole stream arrived, never writes into a folder that is already there, and leaves nothing behind at any stage (except complete items already moved into place).
• An upload whose name was taken on the server while it waited in the queue could replace that file (it now gets the next free name, and one whose name could not be checked is not sent); two transfers to the same name at the same time could write into each other.
• A packed upload compressed with a program the server has but that cannot compress (BusyBox's xz) failed, and a stream cut off at the end could be taken as complete. Packed transfers to a server whose kind Tether did not know yet (Windows, a network device) are sent file by file instead of failing.
• A transfer that finished just as Tether quit could be removed as unfinished; removing a large cancelled download no longer holds up the window. The upload bar over a terminal no longer stays up after an upload failed before it started.
• Find (⌘F): the first match shown is the upper one on screen, so ↩ / ⌘G goes on to the one below it; ↩ sometimes did not move to the next match (while a long scrollback was still looked through, or after the term was changed); a match under the find bar was not scrolled into sight; the marks beside the scroller drifted where long lines wrap or output was redrawn in place; and matches still in the terminal could be counted twice after a program redrew its screen many times (Save Session wrote those lines twice too).
• ⌘↑ / ⌘↓ went to output lines where Return had been pressed while a program was still printing (also in older recordings), marked a command typed during such output on the wrong line, highlighted the line below a command after a resize, and the highlight slid down by part of a row towards the bottom of the window.
• File ▸ Save Session… (⌘S) and Close Window (⇧⌘W) were missing from the menu, so their shortcuts did nothing.
• A terminal stayed at the size its window opened with when the window was made bigger (full screen, zoom) until another tab was shown, and switching to a tab could hold the window for a moment while its scrollback was wrapped for sizes on the way.
• The tab bar no longer shows a scroll bar when tabs do not fit; the arrows and faded edges show that more are hidden.
• Closed tabs kept their whole scrollback in memory until Tether quit.
• The transcript window's Earlier / Later steps were wrong for long recordings kept in parts.
• Recordings no archived session refers to (left by a crash, or by quitting with restoring turned off) were never masked for secrets; they are now.
• A command-history entry that could not be added completely (a full disk) could hide the entries after it, and state that could not be written (tabs, windows) was dropped instead of being written later.
• make app and make install could package the app built before when the build failed; they stop now.

Notes

• Full-screen programs inside GNU screen sessions still cannot be scrolled with the wheel: screen does not tell the terminal when they start (tmux sessions have no such limit).
• Signing In Again is on after updating, and remembered passwords are forgotten a day after they were typed by default (0.8 kept a typed password for two minutes); turn it off in Settings ▸ Passwords to have nothing kept (a server whose connection ended then asks once more).
• Settings saved by older versions get the new defaults once (keep-alives off, 15 s stall limit) unless you had changed them.
• Shared connections now end when Tether quits; the next launch signs in once per server (sessions on the servers keep running).
• Building from source: make signing-identity (once) signs every build with a local certificate, so macOS keeps folder and keychain permissions across updates instead of asking again after each one.