Versioning

What changed

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

  1. 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.

  2. 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.

  3. 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.

  4. 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.

  5. 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.

  6. 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.

  7. 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.

  8. 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.

  9. 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.

  10. 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.