Changelog

• The sidebar shows one repository at a time again, and you change which from the switcher at the top of it. Listing every repository at once answered which checkout a row was in and cost the whole top of the window to a column of disclosures.
• New session and New team are buttons. They were rows inside two different menus, which made the two things this app is for something you had to read a list to find.
• What is waiting for you in the repositories you are not looking at is on the switcher, as a count on its face and per repository in its menu, so hiding them never hides an agent that needs an answer. Cmd J still goes to any of them and brings the sidebar with it.
• Closed and archived work is the repository you are in, matching the list above it, and the filter's blocked count is what the filter would actually leave behind.
• Make default, Reveal in Finder and Remove are back in the switcher's menu, which is the one place a repository is the subject.
• A repository removed from Fleet while its sessions are still open keeps a row in the switcher, because its worktrees are on disk and that is the only route back to them.

• Go to what is waiting for you. Cmd J walks the sidebar in the order you see it and takes you to the next session blocked on you, and the count in the title bar is now the same verb rather than a number you have to go hunting behind. An agent nested under a team is a legitimate destination, because being nested makes it harder to find by eye, not less yours to answer.
• The chrome above the conversation is thinner. Heights come off a ladder of six rungs now instead of eleven hand-written numbers between 22 and 44, so a pill, a segment and an icon button that meant the same thing stop being three different sizes, and the three bands stacked above every session give their pixels back to the transcript.
• The panel brings the changes forward by itself, once. A turn that lands a diff opens the Changes tab when the session goes idle, never mid-turn, never for an agent, and never over a plan that still owes an answer. Collapsing it after that is the last word.
• A collapsed tool card says how it came out without being opened: what a command returned and the first line when it failed, whether a search found anything, and a glyph in a fixed column so a run of calls is scannable down the side.
• Long reasoning stops burying the reply. Short thinking still reads inline exactly as it did, and only a chain long enough to push the answer off the screen is clamped, with a way to show the rest. Nothing is ever clamped while it is still being written.

• An agent can run on a cheaper model than the one you talk to. Worker model and effort are their own settings because an agent has no composer to change them in, and a round's money is mostly its agents rather than its orchestrator.
• Spending has a cap. A monthly one and a per-round one, both off until you set them, and they refuse new work rather than killing a turn: a spawn is refused, autopilot pauses, and the prompt you type yourself always goes through.
• A refused spawn says in one sentence that nothing the orchestrator can call will raise the cap, so it carries on with the agents it already has instead of spending another turn to earn the same refusal.
• Autopilot paused on budget says it is paused on budget rather than that it gave up on the checks, and it resumes when the window rolls or you raise the cap, with no switching it off and on.
• A spawn naming a model this machine does not report is refused before an agent exists, and the refusal names the ones it does. Nobody can repair an agent after the fact, because it has no picker.
• The update pill refuses to install while agents are working and names the ones that are, then installs once the last one goes idle. Quitting with an update downloaded now actually installs it.
• What's new appears once after an update and not again, and the release notes it shows are the ones the feed carries rather than a link somewhere else.
• The Dock icon counts the sessions blocked on you, including an orchestrator stopped on a question, so the one state you need to act on is legible with the window behind an editor.
• Closing the window and clicking the Dock icon gives back the window you had. It used to build a second copy of everything behind it, which doubled the polling and the notifications with nothing on screen to say so.
• The window comes back where you left it, and on a screen that still exists after you unplug the one it was on.
• Fleet catches up after a sleep. The update check and the pull request poll each get a run on resume, so a laptop opened in the morning is not reporting yesterday.
• The rail narrows. Type to filter it or show only what is blocked on you, and a team stays whole either way, because half a team is not a shape the rail has.
• The rail and the command palette work from the keyboard, and the palette reaches sessions, repositories and the actions the panels already offer.
• A session exports as markdown, reasoning and full tool output included, for when you are working out what went wrong rather than feeding it back to an agent.
• A component that fails to render is a card that says so with a way back, rather than an empty window.

• A team can work across repositories. One feature, one round, agents in as many of your repositories as the work actually needs: change the API in one and consume it in another, coordinated by the same orchestrator.
• Each repository gets its own pull request, and each one links the others in its body, so a reviewer opening either can see the whole change. There is no such thing as a cross-repository pull request, and Fleet does not pretend otherwise.
• The orchestrator brings a repository in by spawning an agent into it, and it can only name repositories you have added to Fleet. It says which ones it intends to touch in its plan, so approving the plan is how you agree to the reach.
• A round is delivered only when every repository has its pull request. If one is refused, the round stays open, the orchestrator is told which repository failed and why, and calling it again updates what already opened rather than duplicating it.
• The team is not reclaimed until every one of its pull requests has merged, because a repository still in review is exactly the one you need the checkout for.
• The rail keeps a cross-repository team together under the repository it was started in, and an agent working elsewhere says so on its row. The board lists every repository in the round with its pull request number, and names the one that has none.
• An agent can only see its own repository, so anything it needs from another arrives in its brief as a fixed interface. Nothing merges between repositories in either direction.

• Fleet has a light scheme. Appearance sits on the General settings page as Dark, Light or System, and System follows macOS while the app is open. Dark is unchanged and stays the default, so nothing moves unless you ask it to.
• Both schemes are contrast-audited, syntax colours included. The last time Fleet shipped a light theme, code on it was close to unreadable; the colours are tokens now and the audit reads both palettes, so that cannot happen quietly again.
• The surfaces come up off black. The rail, the panels and the code blocks sit a few steps apart now instead of a couple of code values, so a card reads as something sitting on the page rather than a region drawn on it, and the borders can stay quiet.
• The accent is violet. It is the fill on a button, a border and a chart bar; links and accented labels take the lighter tint beside it, which is the one the contrast audit now measures.
• The interface is denser. The type scale comes back down to the band a window full of agents wants, the rail is narrower, and Settings finally opens at the same width as the rail it replaces.
• The corners are softer, which is what the lifted surfaces needed: a tight corner on something that reads as material reads as a cut.
• A diff can be read side by side. Split and Unified sit in the file header, the choice sticks, and review notes work the same way in both.
• The Changes tab lists the turns behind the working tree, each with what it changed. A turn with no checkpoint says so rather than reporting that it changed nothing.
• Autopilot has a switch in the session bar, so whether anything is watching the pull request is readable without opening a panel. One that has given up says so instead of sitting there lit.
• Usage reports cost and delivery per repository in one row, so an expensive repository that ships nothing is visible. Both figures count the same sessions.
• The rail footer carries the month's spend beside Usage. A repository answered entirely on Codex shows no figure rather than zero, because unpriced and free are different things.
• A plan that has been round more than once says which revision you are reading.
• The rail lists every repository at once, grouped by name with a count, so which checkout a session belongs to is readable without changing anything. Each row carries its pull request number, coloured by how it is doing.
• Status marks are shapes again rather than glyphs: a round mark for working, a square for anything that needs you or has failed, a hollow ring for idle. A running session pulses.
• The transcript says who is talking. Each block carries a heading, the agent's naming the model, and the agent's reasoning reads inline instead of behind a disclosure.
• Tool calls are cards. The call and its target sit in the head, the output below it on the surface code always gets.
• The composer's controls are one row of pills: which CLI is answering, the model, the effort and the permission mode.

• Signing in at app.tryfleet.dev opens Fleet itself. Signed out is one page with one button, and picking a repository happens inside the app where the picker already lives, on the repository you clicked.
• A workspace that has idled out wakes when you open it. The address you already have is enough, so there is no button to find first and no reload past an error.
• Add repository lists the repositories your installation covers, and a repository you have just connected appears in the rail without a reload.
• Two repositories with the same name are two repositories. A clone is keyed on the remote rather than the bare name, so a/tools and b/tools no longer share one checkout.
• Claude signs in with a credential you paste, on a shell that has no Terminal to hand a login to. One field takes either an API key or an OAuth token and routes on the prefix.
• Going over budget says so, in the words of the thing that refuses it, rather than reading as the edge being down. Raising the budget takes effect on the next press.
• Restore holds after a merge instead of being undone by the next poll, and it gives the session back on a fresh branch cut from the base rather than the one that already landed.
• The interface reads at a browser's distance. The type scale runs a little larger with a heading step of its own, and the empty states offer something to do rather than stating a fact.

• Fleet runs somewhere other than your own Mac. The renderer is the same code either way and only the transport differs, so a workspace on a server is the app you already know rather than a second product.
• Fleet is a hosted web application at app.tryfleet.dev. Sign in with GitHub and a workspace of your own opens in a browser, on its own host, with the session cookie scoped to it.
• Autopilot answers a pull request unattended. A check that went red or a comment a reviewer left becomes an ordinary turn, and Fleet commits and pushes the result. It never raises the permission mode to get its work done, and it stops after three attempts at the same failure rather than looping overnight.
• A session can put the terminal in the window and the conversation in the panel. The agent is untouched: the same permission cards, the same plan gate, the same checkpoints, in whichever column the conversation is in.
• Each provider carries its own colour on the composer frame, at rest rather than only on focus, so which CLI is answering is readable without reading anything.

• The surfaces are darker and calmer. The rail, the panels and the menus sit a step off black now, and the brown is a warm cast on them rather than a colour of its own, which keeps the status colours the loudest thing on screen.

• Fleet drives the OpenAI Codex CLI as well as Claude Code. Pick the provider per session, switch mid-conversation, and the incoming agent is briefed on what it missed.
• One palette, and it is brown. The theme picker, the seven surface schemes and the font pickers are gone, so the app looks the same everywhere and every colour is audited for contrast.
• Create PR now commits what is loose, pushes, and opens the pull request in one press, with a description built from the branch's own commits rather than a template.
• Checks are tied to the pull request Fleet opened rather than to whatever the branch happens to name, and a check going red notifies you once, when it goes red.
• Every turn can be read as its own diff, from the checkpoints either side of it.
• A conflict resolution can be reviewed against both sides it came from, and the snapshot survives a merge that was aborted.
• Settings takes the rail's place and has its own navigation, with diagnostics as one of its pages.
• A new Delivery page answers whether the work landed, beside the page that answers what it cost.

• The plan, the changes, the checks and the terminal are four tabs of one side panel, so nothing has to move out of the way for anything else and the panel collapses to a strip rather than to nothing.
• A plan now reads in its own full-height column instead of a boxed card that scrolled away, and it reopens from the session bar once it has been answered.
• The rail is denser: repository switcher, per-session status and the pull request signal are all readable at a glance.
• Code is readable in every theme. Syntax colours are theme tokens now, so a light scheme no longer paints dark-tuned code onto a pale surface.
• Files can be opened and edited in the panel, and a pull request's checks are visible beside its diff.

• The download can now be measured, so a browser can tell when it has finished. 0.9.1 could arrive half written and still report success, which looked like a corrupted disk image.
• Nothing in the app changed. This build is 0.9.1, delivered properly.

• Fixes a crash on launch. 0.9.0 could not start at all: it read one of its own dependencies the wrong way and stopped before the window appeared.
• If you have 0.9.0, download this build. 0.9.0 cannot update itself, because it never runs far enough to look.

• First public build. Signed with a Developer ID, notarized and stapled, so it opens on a Mac that has never seen this developer.
• Fleet updates itself. It asks once, thirty seconds after launch, and only while the setting is on.
• Settings has the switch, a manual check, and whatever the last check found. The rail offers a restart once an update is downloaded.
• Ships as a dmg to install from and a zip for the updater to apply. Apple silicon only.

Not 1.0.0. electron-updater compares versions and never goes backwards, so the first number a stranger installs should be one there is still room to move away from if the packaging is wrong.