Versioning

What changed

Short release notes, same rule as the rest of the site: only what runs gets in.

  1. v0.8.1

    2026-09
    • On Linux, **when the gated `claude` TYBA started exits with an error or you interrupt it, a second, ungated `claude` no longer starts underneath.** In 0.8.0, any error exit of the gated agent relaunched a raw `claude` in the same pane, with no inbox and no jail, without you typing anything. Now the pane returns to the prompt, with the agent's exit code. `command claude` remains the way to run it without TYBA.

  2. v0.8.0

    2026-09
    • On Linux, **typing `claude` in a TYBA shell now starts the agent with a gate** — no “Reopen managed” button, nothing torn down. TYBA intercepts the command before the agent is born and starts it in the same pane, with the approval inbox, a filtered env and subagent capture; if the folder is inside a git repository in your home, with a jail too. In other folders the gate still applies, and a strip tells you there is no jail there. It covers `claude` with no arguments, in bash and zsh with shell integration on; `command claude` runs it without TYBA. On Windows and for `codex`, the warning with the reopen button stays.
    • **Each approval request now sits in one place for you to act on.** The same request could show up at once in the toast, the inbox and the agents queue, with different buttons in each. The buttons now match everywhere — the queue gained “Always allow” and denying with a note telling the agent what to do — and opening the inbox or the queue takes the toast for a request they already show off the screen. The inbox `1` `2` `3` shortcuts are gone: you decide with the buttons. Along with it, the agents queue no longer approves a red command in a single click: when a red request was resolved elsewhere and the next one from the same session took its row, the confirmation armed for the first carried over to the second.
    • On Linux, **Claude Code's `/agents` now works inside TYBA**: creating or editing a subagent hit a read-only folder and failed. Since an agent definition changes what Claude does, TYBA warns you when a new or edited one shows up in `~/.claude/agents` — the check runs when an agent session starts.

  3. v0.7.0

    2026-09
    • On Linux, a **Claude agent session no longer dies silently on authentication**. Before, when Claude stopped for an expired login, a revoked token, zero credit or an invalid key, the session just sat there with no explanation. Now TYBA tells you: before it starts, if you're logged out; while it runs, if the agent hits an auth error and stalls; and a session that **exited** on authentication shows the reason alongside the resume invite (“run `/login` and resume”) instead of a bare “resume”. Claude Code only.
    • The **tab TYBA opens for you to log into Claude now closes itself** once the agent finishes its work, instead of leaving an orphan tab for you to close by hand. Resuming the conversation still works — the tab goes, the session stays.

  4. v0.6.3

    2026-09
    • On Linux, **Claude Code login persists again when you resume an agent conversation**. An earlier version confined Claude's config folder the wrong way, and the resumed session dropped to the login screen even when you were already logged in — the problem could even reach `claude` run outside TYBA. The credential persists now and the session starts logged in.
    • Three usability fixes. The **new-item-in-`~/.claude` notice** got a close button and stops repeating what you already dismissed — and no longer interrupts for a harmless state file, only for something that can actually run code. **`Ctrl+Alt+arrow`** navigates between panes again even with an agent focused, instead of the key vanishing into it. And the button to **close a running agent session** lost a green highlight that leaked out of place.

  5. v0.6.1

    2026-09
    • On Linux, the **last line of shell output shows up again**. It went missing when the terminal's cell height changed without the app noticing — fractional display scaling, a font swap — and the clip ate the bottom. Now the geometry re-fits before the next paint, and the live band measures the last line the program **drew** rather than where the cursor stopped, so progress bars and spinners are no longer cut off. Along with it, the app now **ships its own terminal font** (JetBrains Mono): text has the same metrics on every machine, instead of measuring with one font and drawing with another on a machine that lacked it — on Linux, this may change the font you saw before.
    • On Linux, **Claude Code login inside an agent session persists again**. The jail mounted Claude's config folder read-only, and writing the credential hit an error Claude swallowed silently — you logged in and the next session asked for `/login` again. Now the jail lets the credential be written, while keeping what grants execution (hooks, plugins, settings) locked, and the login link opens in your browser, outside the jail, with one click. The login relies on how Claude Code stores its credential on Linux; a future version of it may require another adjustment.

  6. v0.6.0

    2026-08
    • TYBA's command line now **completes commands**, not just what you have already run. The first token comes from two places at once: the binaries on your `$PATH`, read from disk by the app, and the aliases, functions and builtins that only that session's shell knows — so `nvm`, `asdf` and `direnv`, which rewrite `$PATH` after the session starts, show up the way they do in your terminal rather than the way the app would guess. After the command come subcommands and flags; arguments come from whoever knows them, such as branch or container names. The order follows what you actually use, not the alphabet. `⌘L` (`Ctrl+Alt+L` off macOS) clears the screen. Like the whole TYBA line, it applies on **zsh and bash** with shell integration on — on fish, PowerShell and cmd the session keeps your own shell prompt.
    • On first run, TYBA **imports the history you already have** — the zsh, bash and fish files are all read, even though the TYBA line itself only runs on the first two — so suggestions start out knowing what you run, instead of waiting for you to type it all again. History search gained scope and filters, so you can look inside one folder or one session rather than the whole pile.
    • **TYBA's command line is on by default.** It used to start off: a fresh install handed you a bare terminal, and seeing what the product promises — blocks, history, command state — meant finding a checkbox in Settings. Anyone who already chose keeps their choice, since `off` remains the only answer that turns it off. On by default means on where it runs: zsh and bash. On Windows the session is still a plain terminal, with no TYBA blocks or history. And what you typed but have not run survives a session switch, instead of vanishing when you come back.
    • **A global agents board**: every agent across every workspace in one place, opened from the command palette and ordered by who needs you first — a pending approval outranks a question, being the only one of the two where the agent is waiting on a risk decision. Inside it, a button walks to the next one asking for attention and cycles, so the second in line is reachable too. And `⌘⇧A` opens the agents queue in the sidebar, with the ones in the current window.
    • Agent state is readable again when the agent **takes over the whole screen** — which is exactly how Claude Code runs. TYBA was only looking at the screen body, which comes back empty by design in that mode, and concluded nothing was happening: the agent looked idle the entire time, and only snapped out of it if some output happened to disturb the screen. The title is still read now, and the state follows it.
    • **Reopening the app offers to resume the agent conversation**, instead of handing back an empty shell where the session used to be. Never automatic: resuming starts a process with context that can act again, and agent action does not begin without you. If the conversation is no longer on disk there is no offer — an offer that leads to an error is worse than no offer at all.
    • **A statistics panel** for what the agents cost you in attention: how many approvals were requested, how many went through on their own, how many you denied, and the median time until your decision. With filters by period and by repository, plus the commands the agent asks for most and how often each one is approved.
    • The file tree now starts on the right, and when its root drifts away from the folder you are working in, TYBA offers to re-anchor instead of leaving you browsing far from the work. Opening the app also stopped hanging: the delay was not slowness, it was macOS freezing the interface to ask for protected-folder permission. Along with it came the scrolling that never settled, the wheel gesture that moved twice as far, command output that got lost under load, and the first Enter of each session, which used to be swallowed.

  7. v0.5.0

    2026-08
    • A new **TYBA command line**, which you turn on in Settings → Code. The shell prompt leaves the screen and the line you type on becomes an editor in the app: what you have already run appears in grey ahead of the cursor, `Tab` or `→` accepts it, and `↑` `↓` walk through history and snippets without leaving the line. It applies to new sessions, on zsh and bash with shell integration on. If anything gets stuck, `Alt+~` inside the terminal hands the shell prompt back right away, without closing the session.
    • With it on, every command you run becomes a **block**: the command, its output, the exit code, how long it took and which folder it ran in, on a card you can copy whole, run again, or mark along with others to copy them all at once. The live output and the card share the same spot, so text no longer changes size or jumps when the command finishes. It is the TYBA line that gives the app the exact boundary of each command — which is why the two come together.
    • The palette searches your command history and your snippets, showing the folder each one ran in — `⌘R` and `⌘⇧R` on macOS, `Ctrl+Shift+R` and `Ctrl+Alt+Shift+R` elsewhere. It does not depend on the TYBA line: it works with your own shell prompt, exactly as it always was.
    • On macOS, the menu bar is TYBA's: File, Edit, View, Session, Window and Help, with what the app actually does. It used to be the framework's default menu, with a Help that led to the framework's own site. The context menu also stopped offering Reload and Inspect Element outside text fields.
    • What you type while a command is running no longer dirties the stored output: pressing an arrow key used to write `^[[A` into it — and that output leaves the screen when you clear it, but not the disk. In bash, a command starting with a space is respected again; with `HISTCONTROL=ignorespace` TYBA was recording the previous command one more time, as if you had run it again.

  8. v0.4.1

    2026-07
    • Switching panes no longer changes how the terminal looks. The unfocused pane was redrawn with heavier text and a wider font, fit fewer columns, and made the agent's TUI reflow on every click — on Linux the difference reached 10% of the width. The rendering is now identical, focused or not.
    • On Linux and Windows, closing the window really quits TYBA. The window used to just vanish: the process stayed alive and invisible, with no way to end it from the interface, and every launch stacked another one — carrying along that session's agents, which kept running with no approval inbox. Closing now takes the agents' process tree down with it. Nothing changes on macOS: the app stays in the Dock, as the platform expects.

  9. v0.4.0

    2026-07
    • Typing `claude` in a plain terminal runs the agent with none of TYBA's protections — no approval inbox, no sandbox, no subagent capture — because the shell started the process, not the app. TYBA now notices and warns you in that session, with a Reopen managed button: it ends only the agent (your shell survives) and starts a new one, gated, in the same folder. If you'd rather carry on ungated, the session is marked as such — TYBA never pretends there is protection there.
    • The Agents panel now works on that raw path too: subagents of a `claude` typed into a shell show up in the tree, read from the transcript on disk. And capture was fixed for Claude Code's real mode, which launches subagents in the background — the panel used to stall, with a finished subagent stuck forever "running" and your own messages turning into phantom entries in the tree.
    • On macOS, the agent is born logged in. The jail was blocking reads of the login keychain, so every new session started by asking you to authenticate all over again.
    • Closing a tab, pane or session with a running agent now asks first, with the option to see what is running before you decide. Closing mid-commit or mid-write used to lose work with no warning at all.
    • The approval inbox gets in your way less: read-only commands and trivial operations go straight through instead of waiting on a click that never added anything. And the approval notice no longer disappears on its own — when it did, the agent sat stuck waiting for an answer you no longer had any way to give.
    • URLs in terminal output are clickable links now, including the ones the program itself marks (OSC 8). Only `http://` and `https://` open, and always in your browser.
    • Settings gained an About section: the version you are running, the exact commit the binary came from, the platform, and a button that copies all of it ready to paste into a report — without carrying along folder paths, account names or anything else of yours.

  10. v0.3.0

    2026-07
    • Agent sessions are no longer a black box: when Claude Code spawns subagents, the Agents panel shows the tree — the orchestrator at the root and every subagent with its type, task, live status and a summary of what it did when it finishes. Today that's a spinner in the TUI; no terminal shows what happens inside.
    • On the first subagent, the session opens a split with its live transcript — what it reads, runs and answers — straight from the file Claude Code writes, without touching the TUI. Close the split or the panel and TYBA respects it, never reopening on its own for that session.
    • Spawning a subagent no longer asks for approval — and that made sessions safer, not less safe: it is now proven that every command run from inside a subagent goes through the same approval inbox as the session. The gate lives where the risk lives: in the commands, not in the spawn.
    • SSH host shells now open even when the server's login shell is fish, csh or tcsh — the pane used to close instantly, with a misleading tmux warning. Internal commands now run through sh -c, so the server's shell no longer parses the bootstrap.

  11. v0.2.0

    2026-07
    • Files panel: browse, view and edit your project inside TYBA, without leaking out to the external editor mid-task. A tree with git decorations, a viewer with syntax highlighting and rendered markdown, editing with create/rename/delete, a name fuzzy finder (⌘P), and a jump straight to the diff. The loop of reviewing and adjusting the agent's work now closes inside the app.
    • Language server in the panel: completion, diagnostics, hover and goto-def for ~15 languages — and the server runs jailed. A language server executes the code of the project it indexes; in an agent worktree that is code the agent wrote, so it runs contained, with no network and no writing outside the workspace. No editor on the market jails the server it runs.
    • You don't install the language server by hand: if it isn't on your PATH, TYBA downloads the pinned build with its checksum verified per release and boots it jailed — and if you already have yours, yours wins. Works on Linux and macOS; on Windows the LSP is left out this version, the rest of the panel works.
    • Remote files over SSH: the same panel in a remote session — browse, edit, see the host's git status — all through the connection that's already open, without installing anything on the server.

  12. v0.1.5

    2026-07
    • Launch configs: lay out your screen — which panes, in which folder, with which agent — save it, and bring the whole thing back with one command. Each agent's prompt arrives typed into the input waiting for your enter, so opening a config never starts work on its own. A remote pane stores only a reference to the saved host, never a credential.
    • Errors now show up as a notice inside the app, with the technical detail readable and the window still usable, instead of a system alert.
    • Dialogs are back to the width they were designed at: all of them were being rendered at the same size, some noticeably wider than intended.

  13. v0.1.4

    2026-07
    • The always-on tunnel is now set up right in the connection form: add it on the host and it opens on every connect — and outside TYBA too (ssh, scp, DBeaver). A tunnel that opens a path back into your machine (-R, -D) asks for a confirmation that spells out, in plain words, who gets to reach you.

  14. v0.1.3

    2026-07
    • SSH is here: register a host once and connect in one click, with the server's Docker containers in the same panel. The registration is written to your ~/.ssh/config, so ssh, scp, DBeaver and VSCode Remote learn about the same host — TYBA does not keep your servers to itself.
    • The remote session stopped dying with the connection. Wi-Fi dropping, sleeping and quitting the app no longer cost you work: the session lives on the server and TYBA reattaches on its own, with the command that was running still running. Only closing the tab ends it.
    • Broadcast: type once, run across a group of hosts. If it fails on any target, you see it — writing to N servers must never swallow an error.
    • Tunnels without memorizing flags: open and close port-forwards in a panel, with their state in plain sight. A host tunnel works outside TYBA too; a session tunnel comes back on its own when the connection reattaches — and if the local port got taken meanwhile, it tells you instead of vanishing quietly and leaving you debugging the wrong app.
    • SSH has not been tested on Windows yet — only on Linux and macOS. It is there and it was built to work; if it doesn't, that's a bug: open an issue.

  15. v0.1.2

    2026-07
    • Windows is here: a real terminal via ConPTY, with a shell picker (cmd, PowerShell or WSL) when you open a session. An .exe installer and an .msi package.
    • The agent cage lands on Windows too — restricted token, allowlisted env, fail-closed. Same rule as the other platforms: with no cage the session is refused, never left loose.
    • The Windows binaries still ship unsigned: SmartScreen shows "Windows protected your PC" — click More info → Run anyway. Signing lands once the certificate is in place, same as macOS.

  16. v0.1.1

    2026-07
    • First installable version — Linux (.deb, .rpm and AppImage). The macOS build ships as soon as the Apple certificate is in place; signing is a condition, not a detail.
    • Agent sessions (Claude Code and Codex) in isolated git worktrees: each on its own branch, none stepping on another.
    • The agent runs inside an OS-level cage — bubblewrap and seccomp on Linux, Seatbelt on macOS. With no cage, the session is refused rather than left loose.
    • Every risky action goes through the approvals inbox. And pushing to main or master is refused by the core — not a preference, a rule in Rust, with tests.
    • Git panel: review the session diff, comment line by line and send the comments back to the agent; commit, push and open a PR without leaving the terminal. Merge conflicts are resolved file by file.
    • A real terminal: Rust PTY, xterm.js with WebGL, splits, tabs and sessions that come back on boot. 17 themes, each with a light pair.
    • Every binary comes out of CI with a checksum and attested provenance. Nothing is built on somebody’s laptop.