Changelog

The major, user-facing features Shelbi has grown, each with the date it landed on main, newest first. This page is hand-curated: it tracks capabilities, not every commit, so small copy edits and cosmetic tweaks are folded away. Entries are prose with code and links where they earn their place.

November 3, 2026

v0.13.3. Remote projects on password-only hosts, desktop windows that reopen where you left them, and no false "needs input".

Remote full window on password-only hosts. A remote project on a host that only takes a password (or a key whose passphrase isn't in the agent) now opens the full native window after one sign-in, instead of falling back to the terminal view. The window's relay shares the SSH connection you just signed into, still with no port forwarding. Cancelling the sign-in shows a Sign In bar rather than asking again, and a connection that can't be made suggests ssh-copy-id (#2127).

Desktop windows reopen where you left them. A window sized to fill the screen reopens at full width. macOS Stage Manager was narrowing it on launch, and the narrower size was then saved over yours. Each window also remembers which display it was on and reopens there when that display is still attached (#2113, #2117).

No false "needs input". A worker that ends its turn while a background command, monitor or subagent is still running stays working. It no longer sends a "finished a turn and needs input" notification or tells the orchestrator the workspace is free. The orchestrator ending a turn still notifies you (#2125).

Task previews read as plain prose. The task description in the desktop's Workspace and Review panels and the TUI's review panel drops markdown syntax: links show their text, and headings, code blocks, mockups and tables are left out (#2124).

Site. shelbi.dev shows the desktop app by default; a visitor who picks TUI keeps it (#2121).

v0.13.2. Remote projects in the native desktop window, a New task dialog, and onboarding for new orchestrators.

Remote projects open natively. Opening a project on another machine in the desktop app now opens the full native window (sidebar, Orchestrator, Issues board, task pane, Workspaces, Activity, Machines and Settings) instead of the far machine's TUI in a terminal. Everything runs over one SSH relay channel per host. The native window needs the same Shelbi version on both machines; otherwise the terminal view opens with a notice naming both versions (#2098).

New task dialog. New issue opens a full dialog in both clients: Title, Workflow, Status, Priority, Description, and "Let Orchestrator write this up". It opens from the board, its n key, and a new New Issue palette command (#2106).

Orchestrator onboarding. A project whose orchestrator was never set up walks through three steps (intro, harness and default model, and the orchestrator's instructions) before launching it. The new-project flow gains an Agent defaults step that picks the harness and model the project's agents use (#2099, #2101).

Command palette. The palette works fully with the mouse in both clients: hover selects, the wheel scrolls, and a click outside closes it. In the TUI, clicking the sidebar's project name opens it, and the sidebar header matches the desktop's (#2093, #2095, #2091).

Polish. Retro Racing S joins the app icons (#2076). New Changelog entries end with their description instead of a list of the links already shown as chips, and existing default templates upgrade on their own (#2104). The TUI Changelog leaves more room between entries (#2105), and the desktop's Jump to bottom arrow is drawn at the right size (#2075).

Merges. Moving a task to done merges when its branch exists only on origin, such as an umbrella advanced only by subtask merges there, and never rewinds origin from a stale local branch (#2110).

November 2, 2026

v0.13.1. SSH passwords in a macOS dialog, and a third app icon.

Remotes that want a password connect. Connecting to a remote (Connect to remote in either client, or opening a remote workspace from the sidebar) no longer fails when the host asks for a password, key passphrase or one-time code. ssh's prompt appears in a native macOS dialog with a hidden field, led by a line naming the host; a new host key asks Yes/No with No the default. The answer goes straight to ssh and is never stored or logged, the connection is reused so it asks once, and background polling never prompts (#2069).

Racing S app icon. Settings ▸ General ▸ App icon offers a third icon, a cobalt tile with a bold italic racing S, and the TUI's General page gains the App icon picker too. Both stripes of the S are white at 90% (#2067, #2072).

v0.13.0. Remote workspaces open from the sidebar, editor and diff tool pickers, and a desktop that looks right on glass.

Remote workspaces open like local ones. Click a workspace on another machine (such as a devbox reached over SSH) and its agent attaches, with Shell, Diff and Editor working the same as on this Mac. Reveal copies the workspace's host:path (#2064). shelbi zen pr-create also works when the workspace's machine has an older gh (#2063).

Pick your editor and diff tool. editor: and the new diff_tool: in ~/.shelbi/config.yaml take either a command or a macOS app, and Settings ▸ General in both clients lists the tools Shelbi detects, plus Browse… and Other command…. A command opens as a pane in the worktree; an app opens in the app (#2034, #2035, #2037).

Run script action. In the workflow editors, a transition's run, ready and ready_timeout move into a Run script action beside its other actions. The YAML is unchanged (#2042).

Desktop. Buttons, fields, chips and cards tint the glass in a translucent window instead of reading as opaque patches, and new installs start at contrast 50, 85% opaque, blur 30 (#2044, #2028). The task pane floats over the board with a drop shadow and rounded top corners, slides out when it closes, and resizes from its left edge (#2029, #2054, #2058). Menus place themselves inside the window, flipping above their button and scrolling when space runs short, and close on a second click or a click outside (#2046, #2052). Workspaces sit flush under their machine's header, and Changelog PR chips draw the pull-request icon (#2048, #2050, #2057).

Polish. Multi-line text areas soft-wrap in both clients (#2038). In the TUI, segmented controls cap the chosen segment as one rounded pill (#2061). On the desktop, slider tracks line up with their labels (#2043). On shelbi.dev, the install command follows the TUI | Desktop switch (#2025).

October 30, 2026

v0.12.0. Settings and a launch screen in the TUI, a per-project Changelog, and tasks you edit in place.

A Changelog for every project. Each project keeps a blog-style record of what shipped. The orchestrator adds an entry after every merge, you read them on the new Changelog page in both clients, and agents and scripts use shelbi changelog (add, list, search, show). The sidebar nav is now Orchestrator, Issues and Changelog (🚀); Activity moves to the command palette beside Machines (#1962, #1995). See Changelog.

A launch screen. Run shelbi outside a registered project with no hub daemon running and the TUI opens Welcome to Shelbi: the projects on this Mac, your recent remote sessions, and Add project and Connect to remote buttons (#1985). shelbi project add still runs the detected setup card.

Settings in the TUI. The TUI gains the desktop's Settings over the same shared models: General and Terminal, Keybindings, Workflows with the Form and Builder editors, Agents, and Workspaces with the add and configure machine forms and their readiness checks (#1902, #1908, #1909, #1910, #1911, #1913, #1915, #1916, #1917, #1920, #1921). The sidebar footer gains Settings and Send Feedback buttons, with About Shelbi, Acknowledgements and a Contact Us dialog to match the desktop (#1933, #1934, #1938, #1940, #1958).

Desktop. Add Project becomes a wizard with a live creation checklist and a workflow summary, after a first-launch check that installs the CLI if it's missing (#1876, #1898, #1900, #1903). Settings ▸ Workspaces lists the pool and its machines, with dialogs to add and configure machines and to create, edit and remove workspaces (#1904, #1905, #1906, #1914). The task detail becomes a floating task pane that shows the agent working the task, and a task's title, body, status, workflow and priority edit in place (#1986, #1989, #1991, #1992).

Shared boards. On a GitHub Issues board, board search also asks GitHub (#1984), and on a shared remote tracker Shelbi starts only the issues assigned to you (#1968).

Polish. In the TUI, the sidebar toolbar sits on the bottom row while Zen is off, its Settings and Send Feedback buttons show no hover text, and toggling Zen no longer prints a status line; the Zen band is the indicator (#2001, #2004, #2007). Segmented controls no longer light up on hover in either client (#2012). On the desktop, picking an app icon no longer shifts the tiles, the project menu is inset from the sidebar edges, and Settings ▸ Shelbi CLI shows the binary in use, read-only, with a Reset for an override (#2003, #2009, #2013).

Steadier dispatch. A workspace left on an orphan branch with no .gitignore (such as docs/planning) no longer refuses its next task over ignored build output like target/ (#2020).

Docs. shelbi.dev's home page and docs gain a TUI | Desktop switch that swaps every illustration, and in the docs the instructions too, for the client you use (#2018, #2022). The guides, concepts, configuration and CLI reference were audited against the real app and corrected, with new pages for the commands that had none (#2021).

October 23, 2026

v0.11.0. The native macOS desktop app, plus steadier handoffs and sessions.

Shelbi has a native macOS app. Shelbi.app is a second client beside the TUI, built with gpui and at feature parity with it: both render the same models, run the same command registry, and attach to the same daemon and sessions, so the TUI, shelbi attach and the app can watch one agent byte for byte. On launch the app finds the shelbi CLI, starts or adopts the daemon, and checks that the versions match, offering a relaunch or an upgrade when they don't. A window shows one project at a time and switches projects in place (⌘⇧N opens another), with the sidebar, the Orchestrator chat, the Issues board with task detail and drag and drop, Activity, Machines, the Workspace view (the agent with your own shell beside it, local or remote), and the Review view (the task panel beside the reviewer, with diff and editor sessions, approve and reject, and the review server's live state). The command palette and the overlays (error log, add project, load for review, reject reason, Zen intro) come along, as do native menus that carry your keys.yaml chords and system notifications for a blocked workspace, a task ready for review, or an orchestrator waiting on you. Terminals are the app's own, drawn over Shelbi's shared emulator with scrollback, selection, find, links and IME. Light and dark follow the system, and the TUI gains the same light theme through a new theme: key (auto, dark or light) in the global config (#1683).

Every view tuned for the desktop. The Issues toolbar gains a search field that narrows cards live by title, id and branch (/ focuses it, Esc clears it) (#1812, #1829). More in the Review and Workspace task panels opens the full task detail over the screen you're on (#1805). Activity paints at once and scrolls at frame rate on thousands of rows (#1818), and the sidebar slides in and out instead of jumping (#1814).

Settings you edit in the app. Settings (⌘,) gets its own sidebar in place of the app's, with General, Keybindings and Terminal pages (#1813). Keybindings is a real editor: click a chord to rebind it, and the change is written to keys.yaml with its comments kept and applies at once (#1817). Terminal sets the font and size, edits the ANSI colors against a live preview (#1816), and picks when the new macOS-style overlay scrollbar shows (#1855). General adds window transparency and a background blur behind it, stored as desktop.window_opacity and desktop.window_blur (#1820).

Workflows and agents, editable in Settings. Settings ▸ Workflows lists a project's workflows and statuses (#1826) and opens a workflow editor with two views: a Form that edits statuses and transitions as rows (#1828), and a Builder that draws the workflow as a graph on a pannable, zoomable canvas, with an inspector for each status and transition, connection handles you can drag between statuses, and reorderable transition actions (#1830, #1832, #1834, #1841, #1842). Edit YAML in either workflow menu opens the file itself for anything the editor can't express (#1840). Settings ▸ Agents shows each agent's preferred runner, the statuses that use it, and whether its files still match what Shelbi ships, and an agent details page edits its name, description, instructions.md and skills (#1852, #1853). Both editors save through new editing models in shelbi-state that patch the YAML in place, so the ## help blocks, comments and notes in your hand-edited files survive a save, and a workflow that open issues still use can't be renamed or deleted out from under them (#1825, #1851).

Installed with Homebrew, signed and notarized. The release now builds, signs, notarizes and staples Shelbi.app, attaches Shelbi-<version>-arm64.zip to the GitHub release, and publishes it as the shelbi-desktop cask in the Shelbi tap. The app is a client of the CLI, so the cask depends on the shelbi formula; name both when you install (brew install jlong/shelbi/shelbi jlong/shelbi/shelbi-desktop), and the app tells you when a newer release is out. It needs an Apple silicon Mac on macOS 15 or later. It ships with the new Command Grille app icon (#1683, #1845).

The first release on Shelbi's own sessions. This is the first tagged release without tmux (see October 12 below), and the session runtime got a round of hardening. A dead session is never read as live or classified from its final frame (#1663), a client never reattaches to a session that has already exited (#1702), a resume prompt is delivered only into a live, ready session (#1689), and the supervisor really relaunches a dead orchestrator and logs restart only once the new one is live (#1690). shelbi daemon stop stops only its own root's daemon, and a session's exit.json now records which signal ended it and who sent it (#1693). The daemon no longer idles out halfway through a quit (#1742). In the TUI, Switch Project now really switches: it rebuilds the views for the target, starts its orchestrator, and paints the target at once instead of freezing on the old project (#1635, #1659, #1661, #1665), and the workspace header reads the same status the sidebar shows (#1660).

Handoffs survive bounces and rewrites. A task bounced back to a reused workspace keeps its push provenance per branch, so the hub no longer refuses the push of a tip it pushed itself, and a real block is raised to the orchestrator once instead of looping quietly (#1844). A worker that amends or squashes an already-pushed commit no longer wedges its handoff, and a blocked push heals itself once the branch is fixed (#1643). A handoff force-push leases against the fresh remote tip and caps its retries (#1583), every move into the handoff status detaches the worktree, not just the ready marker (#1651), and a stale merged PR can no longer finalize a reused branch (#1627). Review slots load the branch as a detached HEAD, so a branch checked out elsewhere never blocks a review (#1743).

GitHub boards spend far less quota. Idle TUI and daemon pollers read the daemon's board index instead of sweeping the whole issue history, which had emptied the REST quota about once an hour (#1741). A rate-limit park only waits for a window reset it can believe, and the board rate-limited event says which limit tripped (#1769). The Activity feed stops refetching done issues and bounds its retries on a failing title fetch (#1631, #1647), and shelbi issue start right after a move no longer trips over its own write (#1634).

Per-worktree markers move to .shelbi/. The ready, review-loaded, push-blocked and transition markers now live in each worktree's .shelbi/ directory instead of .claude/, which is the runner's own config and not Shelbi state. Update any script that watches the old paths (#1609, #1611).

Smaller fixes. A worker's clarification question is stored on the hub in full and attached to its event, instead of being cut at 120 characters (#1703). shelbi zen ci-watch waits for the commit's GitHub Actions run to exist before calling it green (#1655), and shelbi zen probe refuses a branch held by another worktree before any local check runs (#1649). Tracing goes to stderr, so commands that print JSON keep their stdout clean (#1653). The orchestrator's shipped Reporting instructions name the issue, not the workspace, as the subject of each update (#1645), and the TUI palette hides workspaces until you type and gives every action row an icon (#1632, #1640).

October 12, 2026

Shelbi runs its own sessions; tmux is no longer required. Each agent now runs in its own Shelbi session, a small process that owns one PTY and outlives the connection, instead of a tmux pane. Attach to any session from any terminal with shelbi attach <workspace>, rendered full-screen, and detach with Ctrl+] without stopping the agent. The debug surface over sessions is shelbi session (ls, new, kill, send, snapshot); remote machines are managed with shelbi machine (setup, status) and reached through a per-machine shelbi relay. The deb and the Homebrew formula drop their tmux dependency: beyond the shelbi binary itself, a machine needs only git and your agent CLI, plus ssh to reach a remote one. The TUI is an ordinary full-screen program, so it still runs fine nested inside tmux or Screen if you prefer one. The retired tmux-era commands (spawn, archive, tail, merge, popup, and daemon install/uninstall) are gone.

October 5, 2026

v0.10.0. A GitHub Issues board, optimistic kanban, and review-slot hardening.

Shelbi can run your board on GitHub Issues. At onboarding you choose GitHub Issues or the local file system as the issue tracker (#1397), and a GitHub-backed project reads and writes real issues instead of markdown files. The daemon owns a board-index.json it refreshes incrementally over GraphQL, stamped with the repo identity and a schema version and cold-read on a bounded interval, so the TUI and sidebar read the board from a cache instead of blocking on the network (#1229, #1230, #1231, #1232, #1292, #1216, #1188). A single-issue read goes through a REST conditional GET that spends from a request budget (#1302, #1233), every gh child runs under a deadline and is classified by HTTP status (#1299), and a rate-limit or unreachable condition parks the backend and honors the recorded reset time rather than hammering the API (#1221, #1244, #1321). A stale board read never triggers a destructive action. shelbi doctor and shelbi status gained a GitHub section with staleness banners and a points-based budget read, so you can see where your API quota is going (#1235, #1403).

Kanban moves are optimistic. Dragging a card updates the board immediately and persists in the background, so the UI stops waiting on a round-trip before it redraws (#1398). Press o on a card to jump straight to its assigned workspace chat (#1379).

A persistent error log behind the sidebar. View and backend errors that used to scroll past now land in a per-project error log that survives a restart and lights an unread-errors button in the sidebar, so a failure that happened while you were away is still there when you look (#1369, #1395).

Review slots are steadier. Tearing down a review slot now reaps the review dev-server's whole process tree instead of leaking it (#1399), and the reaper never signals the caller's own process group (#1485). A new review.diff_command points the review diff at a revision-range tool of your choice (#1341), the shipped defaults allow a human-authorized rebase (#1377), and review-slot ownership and occupancy are resolved from the assignment overlay rather than a lagging board index, so selecting a serving slot builds its panel instead of relaunching the agent (#1349, #1376, #1373, #1355).

Agents can own custom active statuses. A custom active board status is auto-dispatched from the wake path (#1306), categorized and re-dispatched by its catalog identity (#1305), and a parked gate is dispatched deterministically (#1312). A ready marker routes through an agent-owned active gate before the handoff status (#1309), and such a gate hands its agent a reviewer prompt rather than the developer's (#1311).

Dispatch prompts carry the agent's charter inline. The selected agent's charter is inlined into the startup prompt as the authoritative instruction, delivered exactly once and identically everywhere (#1315).

Zen probes are bounded and louder about failures. The probe runs cargo test with --no-fail-fast and keeps the failing-test output in the probe log (#1483), every probe subprocess is bounded so a wedged child can't hang the suite (#1457), and a new shelbi msrv-check builds the workspace on the declared minimum supported Rust version (#1481). A disk: config block caps the hub checkout's shared Rust target/, cleared before a probe builds, sweeps leaked probe worktrees, and warns on shelbi status when free space drops below the threshold (#1493).

Smaller fixes. The poller refuses a ready handoff on an uncommitted or empty branch (#1507), a re-dispatch no longer tears down a busy prior assignee (#1494), the poller detects a stalled agent inside a live pane (#1325), dispatch events are scoped to a single project and workspace (#1381, #1339), and the resume path answers the resume-from-summary dialog and recovers stranded dev slots on reopen (#1225).

October 2, 2026

Zen only auto-promotes GitHub issues assigned to you. On a GitHub-backed project, Zen Mode's mechanical scan now treats a backlog issue as eligible only when it is assigned to the account Shelbi is authenticated as. Issues an outside contributor opened, or that are assigned to someone else, no longer show up in shelbi zen scan or the heartbeat's zen_eligible count, so Zen never auto-promotes work you did not take on. The authenticated login is read from the daemon's board index, so this adds no per-tick GitHub call, and if the login cannot be resolved the scan returns nothing rather than guessing. To keep the work Shelbi files eligible, any issue created through shelbi issue add or the TUI new-issue flow on the GitHub backend is now assigned to you on creation. Workspace routing (assigned_to) is unchanged and is still never written to GitHub, and the filesystem backend is unaffected. Open issues Shelbi created before this change are unassigned and will stop being auto-promoted; assign the ones you want back with gh issue edit <n> --add-assignee @me.

August 25, 2026

v0.9.0. Multi-runner agents, plus review-slot and orchestrator hardening.

LLM configuration moved from the workspace to the agent, so you can mix and match Codex and Claude per job. An agent now carries its own agent.yaml manifest, and a multi-runner resolution chain picks the runner and model from the agent rather than the workspace it happens to land in (#543). A task or a board status can override the launch for one dispatch (#549), and the reviewer is now medium-agnostic so it runs the same whether the work under review came from Codex or Claude (#571). The practical upshot: point a cheap fast runner at the mechanical tasks and a stronger one at the hard ones, all on the same board.

The orchestrator recovers from its own event drain. The consuming event drain is now deadline-aware and self-healing, so a stalled or wedged drain unblocks itself instead of quietly starving the feed (#580). When a pane exits unexpectedly, Shelbi captures a crash record (the exit code plus a tail of stderr) so a worker that dies mid-task leaves evidence instead of a silent gap (#560).

Config drift heals itself on boot. A version-agnostic validate-and-upgrade sniffer runs on start, flags config that has drifted from the current defaults, and fixes what it safely can. Changes that need judgment are handed to the orchestrator as findings rather than force-written, so your customizations survive (#550, #552, #572).

The review flow stops fighting itself. A hub-side merge is now idempotent, so an already-integrated branch is treated as a success instead of an error (#573), and a PR that GitHub already merged counts as a merge success too (#566). The gated review-to-done merge fires at the move site so accepting a review actually lands it (#558), loading a queued task onto a busy slot shows a picker and evicts cleanly (#564), and a review window whose pane died auto-recovers (#568, #569). The reject dialog gained mouse support and a multi-line reason (#578, #561), and a dispatch guard now refuses to route developer work onto a review slot (#575).

Worker-authored PR bodies. Workers write the pull-request description from an editable per-project template, so the PR a reviewer opens reads like a human wrote it instead of a task dump (#581).

Smaller fixes. The poller auto-reconciles review tasks whose PR was merged on GitHub out of band (#582) and detects a worker's spinner and AskUserQuestion dialog more robustly (#559, #555); the command palette shows a three-state project status indicator with an active pulse (#556, #562); and the launchd install path handles a clean boot-out and restarts an already-running daemon instead of erroring (#570, #565, #547).

August 10, 2026

v0.8.0. A unified event stream and review-slot fixes.

One state-change stream drives signalling. Shelbi used to lean on a 30-second keepalive to keep the orchestrator's view alive; now every signal flows through a single state-change stream, and the keepalive is retired. CI polling is scoped so it watches only what it needs (#521), and unacknowledged follower batches are redelivered after a visibility timeout so a slow or restarted follower can't drop events on the floor (#530).

Review slots stop churning. Serving detection is now poller-driven (#532), a review slot is parked so it no longer thrashes between resume and autoload (#534), and the review window closes once you accept (#531).

Merges land through the PR. Integration goes through the GitHub pull request on a PR-only ruleset instead of a direct push (#536), and a fresh init cleanly splits the committed defaults from your local config, both on first init and on pick-up (#537, #538).

Smaller fixes. The workspace badge is re-derived from live state so it can't go stale (#533), the sidebar docks in the dashboard only rather than following you everywhere (#519), and the docs got an accuracy audit across the CLI, configuration, guides, and Concepts pages (#522–#529).

August 5, 2026

v0.7.2. Honest mid-flight comms and workflow-aware handoffs.

shelbi message tells the truth about delivery. The command used to print a checkmark and exit 0 the instant it wrote the durable record, conflating "queued" with "the worker read it" — and on some hosts the ack never once landed (12 sent, 12 timeouts). Root cause: the worker's ack was gated behind jq, absent on stock macOS and minimal Linux, so the ack block was silently skipped. Now the ack extraction is jq-free and sends over nc (flavour-detected, -N on Linux) or a python3 fallback. The CLI stops over-promising too: a bare push prints queued … not yet confirmed delivered, --wait blocks and exits non-zero on the ack window elapsing, shelbi message status <id> reports the real outcome, and a done task or dead pane is reported undeliverable rather than implying a future pickup.

Handoffs follow the workflow's base branch. The workspace startup prompt hardcoded git rebase origin/main, ignoring a task workflow's git.base_branch. For fan-out workflows whose base isn't main (e.g. feature/{{feature}}), agents that followed it produced wrong-base branches the merge guard rightly refuses. The prompt now rebases onto the workflow's resolved base, mirroring the merge side so the handoff and the merge target agree.

Smaller fixes. task add/task edit no longer hang reading stdin when the body was already supplied by --body/--body-file/-d; the command palette hides the redundant 'Switch Project' entry from its empty-query menu (it still surfaces on typing); and the generated Homebrew formula drops the redundant version stanza that brew audit --strict rejects.

August 4, 2026

v0.7.1. Feature-branch fan-out you can trust.

Subtasks land on their parent branch again. A workflow whose git.base_branch is templated — feature/{{feature}}, update/{{update}}, task/{{task}} — now resolves that base from the task's frontmatter at every step instead of silently falling back to main. A subtask filed without its parent link is refused at dispatch rather than cut from a degraded base, {{var}} placeholders are validated against a workflow's required_params at load, and the finish-flow rebase freshens and restacks against the real origin/<base> — no more branches quietly rebased onto main and polluted with unrelated history. Most important, the handoff-less merge is now gated before a task is marked done: a merge that fails or integrates nothing leaves the task in-progress and emits a merge status=failed event instead of stranding a false done with the work landing nowhere. A pre-merge ancestry guard also stops a wrong-base squash from reverting an already-merged sibling.

Reliability. shelbi daemon restart now recovers a launchd job wedged in the loaded-but-never-spawned state with kickstart -k, the orchestrator's event feed self-drains and emits keepalives so a dead follower can't silently blind it, and a review slot stranded by a quit or restart no longer re-runs the developer on resume.

Interface. The dashboard sidebar and review panel now share one user-adjustable width, Add project moved into the projects sidebar, and an awaiting-input workspace shows a yellow ? badge instead of a speech balloon.

August 1, 2026

v0.7.0. Shelbi Zen ships, and a reviewer to match.

Shelbi Zen is a real autopilot now. Zen can take a handoff branch all the way to main on its own: it runs the project's local pre-merge checks, gates on merge conflicts, diff size, and danger-path edits, then drives the PR create → CI-watch → squash-merge flow to completion. shelbi zen probe self-recovers when the hub's primary checkout is holding the task branch, and it flags the cases that used to slip through — a stale base, an already-merged branch, or a squash-merge that would silently revert a sibling PR. Orchestrator self-review is now codified in the shipped defaults, so the old fresh-context evaluator subagent is retired.

A two-column review interface. Reviewing a task is now a dedicated experience: a left panel with the diff and reviewer actions, a View Diff action alongside Chat with Reviewer, and a reject-reason prompt that opens as a tmux popover with a real textbox and buttons. Queued-for-Review tasks auto-load onto an idle review slot, the Review agent is dispatched there instead of the status's Zen agent, and a review slot stranded by a quit or restart is resumed on the next launch.

The command palette learned about projects. Switch Project is pinned to the top with inline "Switch to X" entries, each project carries a loaded or unloaded status glyph, and a second column lists your other projects — Right to focus it, Up/Down to move, Enter to switch.

A traveling sidebar for window-per-workspace navigation. The dashboard sidebar now travels with you across per-workspace windows, clamped to its canonical width, and self-heals so a render fault or a process exit can't leave it gone. Activity is a plain-language timeline with multi-line wrapping rows, and project config validation errors surface directly in the sidebar.

System configuration ships as a skill. Shelbi bundles a system configuration skill with an inventory and an all-surface lint, and injects the system plugin into the built-in runners so a fresh install carries it.

CLI and reliability. shelbi quit tears down a running project cleanly, and shelbi task edit gains non-interactive flags for title, body, and field substitutions. SSH grew a stabilized managed ControlMaster — keepalive, per-host locking, and mux recovery — and now surfaces the ssh diagnostic behind a blank exit status: 255 instead of swallowing it. The launchd daemon registers idempotently, and the heartbeat and poller are hardened so a busy board or an unreachable machine can't starve them.

July 18, 2026

v0.6.0. Workspaces, project names, and safer worktree integration.

Workspaces are provisioned by the orchestrator, not hand-edited YAML. New commands shelbi workspace add <name> and shelbi workspace rm <name> manage the pool, and a fresh project's workspaces are created through a first-boot interview: the orchestrator asks how many and which naming scheme (phonetic, greek, or toy-story) and creates them on the current machine. shelbi init no longer auto-provisions a pool.

Shelbi no longer overwrites your worktree settings. Its Claude hooks are wired into .claude/settings.local.json — which Claude merges additively — instead of clobbering a committed .claude/settings.json. A pre-existing user-authored file is left untouched; the orchestrator merges the hooks in.

The default-branch commit guard only fires inside Shelbi. The pre-commit guard that keeps agents from landing work directly on the default branch is now scoped to Shelbi-managed panes, so your own commits from a normal shell are never blocked. Its install is disclosed at shelbi init, and shelbi guard uninstall removes it.

Project names can be anything. Name a project ContextStore or My App; Shelbi slugifies it for the on-disk folder and settings file and shows the human-readable name in the sidebar and command palette.

git.branch branch-name templates. The git block gains a branch template key that parameterizes the branch names Shelbi cuts for tasks, rendered with {{var}} substitution, and mutually exclusive with the older branch_prefix. The shipped subtask workflow now cuts its branches from a branch template instead of a prefix. See the git block reference.

Zen gained a fresh-context evaluator gate. Before auto-merging a handoff, Zen spawns a read-only evaluator that checks the diff against the task's acceptance criteria and scope, so a branch that builds but doesn't do what the task asked is caught. Zen integration commits are now authored by you with the worker's real commit message rather than a synthetic bot identity.

Codex orchestrator liveness. The heartbeat keep-alive that nudges a Codex-native orchestrator was restored, and shelbi zen probe now emits a structured JSON error when its own setup fails instead of empty output.

July 15, 2026

v0.5.0. Shelbi runs on Codex, not just Claude. The orchestrator and workers can now run under Codex as a first-class runner alongside Claude. A RunnerAdapter capability model unifies per-runner behavior so dispatch, the board, and supervision treat both the same way, backed by a durable event and wake queue that survives restarts; Claude consumes that same durable feed and acknowledges each item so nothing is dropped or replayed. Where a runner has no lifecycle hooks, Shelbi fills the gap: Codex workers receive orchestrator messages by polling, and an idle Codex orchestrator wakes on board events rather than waiting for a prompt. shelbi status surfaces per-agent integration health and names the fallback reason when a runner is degraded, and switching a project between the Codex-native and legacy runners is a guided migration rather than a hand edit.

A detected getting-started plan. shelbi init now reads the shape of the project and proposes a tailored setup plan instead of a one-size-fits-all default.

CLI version-mismatch detection. The hub daemon warns when a workspace's shelbi CLI version has drifted from the hub's, so a stale binary on a remote machine shows up as a notice instead of confusing behavior.

"Add project" from the palette. A new palette flow adds a project through a details dialog, without dropping back to the wizard.

Auto-resume of usage-limit-stalled workers. A worker parked on an agent usage limit now resumes automatically when its quota window resets, rather than sitting paused until you nudge it.

Sturdier under bad remotes. list and status bound their per-workspace probes so a single wedged SSH host can't hang the whole command.

Zen merge-safety hardening. Zen's PR create and merge steps now match on exact provenance, so they no longer false-fail on Zen's own push or a rebased head, and local checks run under a per-check timeout so a loaded hub fails fast instead of hanging on one wedged check.

July 10, 2026

v0.4.0. A user-owned Zen policy that stays in context. The Zen autopilot policy is now a user-editable zenmode.md file, and the hub re-injects its one-line summary into the orchestrator on a heartbeat cadence, so the policy keeps steering even as the orchestrator's context turns over. See Zen Mode.

shelbi reload <target>. Respawn one pane in place (chat, tasks, activity, sidebar, or workspace <name>) without bouncing the whole hub.

Palette and workspace conveniences. The command palette gains "Edit … Settings" openers, hidden until you query for them, and clicking an idle workspace now opens a user shell in its tmux window instead of doing nothing.

Branches free to merge after handoff. A worker's worktree detaches from its task branch on handoff, so the branch is free to merge and clean up.

A batteries-included default install. shelbi init now sets up the loop most projects want without any YAML editing. Two things landed. First, six agent presets materialize on first load instead of three: the orchestrator, developer, and review roles that run the core loop, plus three specialized reviewers, qa (verifies a change against its acceptance criteria), security (a defensive-only diff review), and adversarial (an automated skeptic that tries to refute the change). The reviewers ship materialized but unwired, so the default board stays a plain developer → review loop and adding a gate is a one-line edit: name agent: qa (or security, or adversarial) on a status. Second, the scaffold ships two workflows instead of one. task is the new review-gated default: branch off main, Backlog → Todo → In Progress → Review → Done, one PR on the In Progress → Review edge, squash-merge to main on accept, with the Review status served on a review-tagged workspace by the Reviewer agent. subtask is a lighter flow for a piece of a parent task: it branches off and merges into the parent's branch, opens no PR, and has no review. Fresh projects get default_workflow: task written in, so the review gate is on out of the box. See the agents concept and the workflows guide.

July 9, 2026

v0.3.0. Kanban polish and safer project names. The kanban card popover gains shortcuts to move a task between columns and scrolls with the mouse wheel, and each column puts a blank row between cards (#340, #341, #343). shelbi task add reads piped stdin as the task body (#337). Onboarding normalizes a project name into the agent-id charset (#347), and the Homebrew install docs gain the brew trust jlong/shelbi step (#346).

v0.3.1 and v0.3.2. Same-day patch releases: launch no longer crashes on an un-normalized project name already on disk (#351).

July 7, 2026

v0.2.0. The headline fix: launching a pane on a remote machine whose login shell is zsh no longer fails at startup. The tmux targets Shelbi passed over SSH were being eaten by zsh's equals-expansion, so remote workspaces died before the agent ever started; they now come up cleanly. The release also closes the loop on packaging: the release workflow now publishes the Debian package to the signed APT repository as part of the tag-triggered pipeline, so apt install shelbi picks up new versions without a manual publish step. And it ships two supervision fixes. The hub poller can now drive a workflow that declares no review/handoff status to completion: when a worker finishes and its status has an outgoing transition that merges, the poller advances the task along that edge (merge, branch cleanup) instead of stranding it in progress. And the hub checkout is guarded against stray commits: a Shelbi-managed pre-commit hook rejects commits made directly on the default branch, backed by dispatch-time branch checks.

v0.1.0, the first versioned release. Shelbi now ships as prebuilt binaries, not just source. Pushing a v* tag runs a release workflow that builds macOS (Apple Silicon and Intel) and Linux x86_64 binaries, publishes them with SHA256 checksums and GitHub artifact attestations, opens a version-bump PR against the Homebrew tap, and produces a Debian package. brew tap jlong/shelbi && brew install shelbi on macOS; a signed APT repository serves Ubuntu. See the install guide for both paths.

July 3, 2026

Usage-limit pause detection. The workspace poller now recognizes when a worker has stalled on an agent usage limit rather than genuinely working, and surfaces a ⏸ pause badge in the sidebar roster instead of leaving the pane looking busy. You can tell at a glance which workers are blocked on quota and will resume on their own versus which need a hand.

Adaptive hub heartbeats. The heartbeat cadence now backs off when the board is quiet instead of firing at a fixed interval forever. It holds at the standard interval (default 3m) while there's supervisable work in flight, then doubles each idle tick, capped at a new max bound (default 60m), once the board goes quiescent, and snaps back to interval on the next real event. The config gains the max field: heartbeat: 3m still works (bare interval, default cap), as does heartbeat: off, and a map heartbeat: { interval: 3m, max: 60m } sets both bounds. Every existing project gets back-off with no YAML edit. Backing off on "nothing supervisable in flight" rather than "no log line" is deliberate: a silently-stuck in_progress task also emits nothing, and the heartbeat sweep is exactly what catches it. See the heartbeat field reference and the events log.

shelbi task resume. A stalled or killed worker no longer has to lose its task. shelbi task resume <task> relaunches the runner in the worker's existing worktree, picking the branch back up where it left off instead of dispatching from scratch.

Crash-safe workspaces. Shelbi now auto-restarts a managed pane if its agent crashes, and re-submits the in-flight prompt after the restart so the worker resumes the task rather than sitting idle at a fresh prompt.

Self-documenting config on .yaml. New config scaffolds ship with their optional sections present but commented, so the file itself documents every knob you can turn. No need to hunt the reference to discover a setting exists. At the same time every config file standardizes on the .yaml extension; existing .yml files are migrated automatically on first load.

Wizard simplified. The onboarding wizard's sole phase is project setup. The orchestrator prompt now reads "You are the Orchestrator" statically, with no legacy name placeholder substitution at render time. ~/.shelbi/shelbi.yaml is now just the per-project last_launched index.

July 2, 2026

Review workspaces. Reviewing a finished task now loads its branch into a dedicated, long-lived review workspace with its own agent, rather than a throwaway top-level clone. The orchestrator dispatches the review onto that workspace, a review queue tracks what's waiting, and the sidebar gains Ready and Queued sections so you can see the pipeline at a glance. The server pane persists across reviews and is reaped on completion.

July 1, 2026

In-repo project config. A project's configuration can now live inside the repo at .shelbi/project.yaml instead of only under ~/.shelbi/, so it can be committed and shared with a team. shelbi project migrate-to-in-repo converts an existing global project in one step, and resolution is mode-aware about which half of the config is user-local versus shared.

June 30, 2026

Two-way worker communication. Workers can talk back to the orchestrator, not just the other way around. A hub-side Unix socket (reverse-forwarded to remote machines over SSH) carries a per-task message log, and hook-capable workers inject those messages via SessionStart + Stop hooks; non-hook runners poll for them in the prompt. On top of it sits a clarification loop (a worker can ask a question and block for an acknowledged answer) plus launchd/systemd supervision so the hub socket survives restarts.

June 29, 2026

Custom agents and configurable workflows. The worker concept was reframed as a workspace that runs a named agent, and dispatch resolves which agent to run from the task's workflow status, so different columns can hand work to different agents, each with its own context and a shared preamble. A shelbi agent CLI quartet (list/show/new/edit) manages them. Kanban columns are no longer hardcoded either: workflows/statuses.yml defines the status identity the board and CLI render from.

shelbi open and marker-free project resolution. The pane-lifecycle entry point is now the top-level shelbi open <workspace> (was shelbi workspace open): same behavior, focus a workspace pane and create it if it doesn't exist yet, under a shorter name. Shelbi also stopped dropping a .shelbi/project marker into each repo to identify the active project; resolution now scans ~/.shelbi/projects/*.yaml, collects each project's local work_dir, and matches the current directory against them (deepest match wins). Less stray state on disk; the project YAML is the single source of truth.

June 25, 2026

Hub heartbeats. The hub-side workspace-state poller appends a periodic <ts> project=<name> heartbeat line to ~/.shelbi/events.log, giving the orchestrator's events tail --follow watch a guaranteed recurring trigger when the board is otherwise quiet. Cadence is set per project via the heartbeat key in project.yaml: 45s, 3m, 1h, or "off" to disable; default 3m. Bare integers (heartbeat: 180) are rejected at load time, so a missing-unit typo can't silently land as seconds. Emission is debounced against any other write to the events log, so active boards don't see padding. Heartbeats also pause while the hub is offline. A quick TCP probe of 1.1.1.1:443 gates each due tick and emission resumes once connectivity is back, so a coffee-shop wifi drop doesn't fill the feed with no-op lines the orchestrator can't act on anyway. Heartbeats are filtered out of the TUI activity feed by default (they'd produce one "nothing happened" row every few minutes) but show up verbatim under shelbi events tail. See the events log for the line shape and rationale.

June 24, 2026

Zen Mode. An opt-in autopilot that lets the orchestrator promote and merge low-risk work without waiting on you. A per-action confidence bar, configurable project checks, danger-path guards, and a dry-run preview keep it honest, and the ZEN ON pill in the sidebar (toggle with Alt+Z) makes the state unmistakable. Zen auto-disables after an orchestrator crash so it never runs unsupervised. Drive it from the CLI with shelbi zen on|off|pause|status.

June 23, 2026

The first public cut of Shelbi: an open-source agent orchestrator for the terminal, built on tmux. You talk to one orchestrator agent; it delegates work to worker agents running in tmux panes, locally or over SSH, and reports back. This landed the full local-to-remote loop end to end.

Onboarding. A first run with no projects drops you into a two-phase, idempotent wizard that walks each project through setup. It auto-fills from your environment (repo path, default branch, GitHub URL) and suggests a worker count from available RAM. shelbi with no arguments launches the sole project's TUI, or a fuzzy picker when there's more than one.

The TUI. A two-pane ratatui dashboard: a sidebar with Chat/Tasks navigation, a live worker roster with state badges (working, awaiting input, awaiting permission, review-ready, idle), and a Ready for Review queue; beside it a content pane that swaps between the orchestrator chat, a five-column Kanban (Backlog → Todo → In Progress → Review → Done), a Machines view, and a Review list. Ctrl+P opens a Nucleo-backed fuzzy command palette as a tmux popup for jumping between projects, workers, and views.

Orchestration. Move a card to Todo and the orchestrator takes it from there. It watches the column and, as soon as a worker frees up, checks out the highest-priority unblocked card on a fresh branch in that worker's own worktree and starts the runner. depends_on blocks a task until its dependencies land in Done. Finished work lands in Review and the worker stops; activating a review checks the branch out, spawns a fresh agent pane to interrogate the diff, and lets you merge into the default branch, or push and open a PR with --pr.

Anywhere tmux runs. Workers run on the hub or on any machine reachable over SSH with tmux and an agent CLI installed. Shelbi drives panes with tmux send-keys + capture-pane, transparently prefixed with ssh host -- for remotes; a poller reads each pane's shelbi:<state> title marker into worker status, which is what lights up the sidebar badges. Agent runners (claude, codex, or any interactive CLI) are pluggable and declared per project.

State you can read. No daemons, no servers, no database: every project, task, log, and worker status is a markdown or YAML file under ~/.shelbi/. The same shelbi CLI the orchestrator drives (task, merge, reload, events, …) is the one you can run yourself.

The website and docs. A Next.js marketing site and a contentlayer-backed MDX documentation set (Getting Started, Concepts, and a CLI reference for every shelbi subcommand) ship alongside the release.

Install from source with ./scripts/install.sh (builds --release, drops the binary at $HOME/bin/shelbi, ad-hoc re-signs on macOS).