What's new in Fleet.

A worker that saves its report outside the project folder now finishes and tells you. When you asked a worker to write its findings somewhere outside the folder it was working in, the worker did the whole job, wrote the file, and then stalled at the very last step. Fleet looked for the report inside the project, could not find it there, and parked the worker for good. The board kept showing it as running, no completion ever arrived, and there was no way to clear it. Around nine finished workers were silenced this way. Fleet now catches an impossible request the moment the worker is created, names the path it cannot use and what would work instead, and every worker that finishes reaches you.

The workspace previews no longer disturb the worker they are showing. Opening Workspaces used to resize each running worker down to the width of its little preview tile, which changed the real session, not just the picture, so every line the worker wrote wrapped after about a couple dozen characters and stayed broken. The tile is now a mirror: it renders the worker at full width and shrinks the whole thing to fit, so the lines stay whole and the session is left untouched.

A message you send while the Captain is busy shows up in the chat. If you typed or sent a voice message mid-turn, it went through but never appeared, because Claude Code records that queued message differently and Fleet was not reading that record. Your message now belongs to the chat where you sent it.

Two quieter reliability fixes under the hood: the one safety stop that guards against shutting Fleet down now recognizes a destructive command written in more orders, and an internal test no longer depends on your recent chat, so the build stops flaking.

Ordinary commands stop being flagged as an attempt to shut something down. Fleet has one safety stop it never lifts and never lets you clear from your phone, because the command it guards against could shut down Fleet itself. It was firing on everyday work: reading a log file, saving a file whose own help text happens to list the word “kill” as an option, a note inside a script. Each one halted a worker until you were back at your desk. Those run now, and the thing the stop exists for is caught in more of its forms than before, including one hidden inside a script or assembled at the last second.

A picture you paste into the chat appears once. Pasting an image drew it twice, once above your message and once again below it, because Claude Code keeps its own second record of every image it takes in and Fleet was showing that record as if it were another message from you. It now belongs to the message it came from.

Remove works on every project, and tells you when it will not. Fleet holds on to a worker's folder while it still contains work that never reached GitHub. On any project Fleet cannot push to, and on every project once you switched off “Draft pull requests,” that folder could never be released and the Remove button quietly did nothing. Remove now gives you its reason, offers a confirmation that names exactly what would be lost, and stays out of the way entirely when there is nowhere for the work to go.

Workers keep a full-size terminal. Opening Workspaces was shrinking every running worker down to the width of its little preview tile, roughly a quarter of a normal terminal. Claude Code lays its screen out against that width, so its own text became unreadable, and the checks Fleet uses to tell whether a worker is stuck or waiting were reading that same scrambled text and raising false alarms for workers that were only thinking.

Fleet notices a worker waiting on you no matter which account it runs under. Its most reliable signal for “this one is blocked and needs an answer” only ever looked at one account, so a worker running under a second one was simply invisible to it and Fleet fell back to guessing from the screen. It now checks every account in use.

Fleet's own notes stay out of your branches. After a run finishes, Fleet writes down what it learned, and when that run happened in its own working folder those notes were committed onto whatever branch was checked out there. Unrelated documentation could turn up inside a change you had open for review. The notes go back to the main project now.

Workers start working again instead of quietly doing nothing. The latest Claude Code reworded the question it asks the first time it opens a folder, so Fleet no longer recognised it, waited, and then typed the worker's instructions straight into that question. The question got answered and the instructions were thrown away, leaving the worker with nothing to do until it timed out. Every scheduled run in a folder Fleet had not opened before died this way. Fleet now answers the question itself, and if it cannot, it tells you rather than typing into it.

Fleet asks you one question, once, when you set it up: do you write code? It only changes what Fleet shows you, never what your workers are allowed to do on their own. You can skip it and change your answer any time in Settings, and if you never answer, the app looks exactly as it does today.

If you write code, Fleet shows you the change first. The worker view opens on the actual diff rather than the plain-English account of it, and everyone else keeps today's order. Nothing is added or hidden either way, only reordered.

The diff is a real viewer now, with a section per file, counts of what moved, line numbers down both sides, colouring that survives the red and green, and a file list you can use to jump around.

The board tells engineers what each worker is measured by: the check it has to pass, how many attempts it has taken, and which agent and model did the work. That last one matters the moment you have more than one kind of worker running.

The proof panel says what actually ran, not just that something did. You get the command, the exit code, when it ran, and the runner's own summary, and when a check fails the error is right there instead of somewhere you have to go and find it.

A worker that failed brings its own output with it, so you stop going to fetch the log. When Fleet no longer has that output, it says so plainly instead of showing you an empty box.

A failing check can no longer show a green “Verified.” A worker that passed once and broke later still read as verified. Fleet now tells “passed before, failing now” apart from “the check is failing,” and keeps both facts.

A cut-off diff no longer looks complete. Long changes get trimmed so the page stays usable, but nothing said so, and you could read part of a change believing you had all of it. It says so now.

If your Captain would not start after the last update, Fleet now repairs it on its own. Version 1.0.18 started refusing to run on an old version of Claude Code, which was the right call, but Fleet installs its own copy of Claude Code once and never updated it. Some people were left with no Captain and no workers, and reinstalling Fleet did not help. Fleet now updates its own copy and starts up, with no restart needed.

And it tells you what it is doing instead of failing in silence. The old failure showed “Not started” and nothing more. A banner at the top of the app now names the problem, shows the repair running, and gives you a one-line fix for the rare case it cannot sort itself out.

Files you pinned survive a cleanup. Clearing the board deletes each worker's folder, and anything you had pinned to the Files tab was sitting inside it, so a cleanup quietly destroyed it. The files even looked like they were still there until you clicked one. Pinned files are now copied somewhere safe before anything is deleted.

A finish check that cannot fail no longer counts as proof. A check ending in something like “| tail -4” always reports success, so two workers were marked done with proof attached having proven nothing. One of them was hiding thirteen real test failures. Checks like that are flagged now, and a person decides.

Workers stop hanging on a password prompt you cannot see. Programs that would ask a hidden question are told upfront not to, so they fail where you can see it instead of stalling, and Fleet no longer reports that silence as a stuck worker.

Another Claude session on your Mac can no longer put words in a worker's mouth. Messages arriving from a different session are refused for workers, your Captain still accepts them, and a worker that tries to send one raises an approval card first.

Fewer false alarms on commands that merely mention “kill.” A script whose text happens to contain the word no longer trips the process-kill warning. Commands that really would end a process still do.

Fleet will not start a worker on a version of Claude with a known approval-box bug. On those versions a command could hide part of itself from the box, so what you approved was not what ran. Fleet now refuses to start the worker instead of showing a badge you could miss.

Smaller repairs: the Files tab says what the tab is for, a verification record can say it could not be determined instead of being forced into a pass or a fail, and test runs stop leaving dead socket files on your disk.

Far fewer approval prompts you should never have seen. Opening a pull request, or running a command that merely had the word “deploy” sitting in a commit message or a filename, was being read as a production deploy. It either interrupted you or parked a worker on a prompt nobody could clear from a phone. Fleet now looks at the command itself instead of the prose around it.

A frozen worker recovers on its own. One that stalled mid-turn used to hold its task forever, and a one-off scheduled run missed during an outage never re-armed. Both come back now without you having to notice. One gap remains: work a worker committed but never pushed anywhere can still be cleared away by Fleet's cleanup, and a fix for that is tracked.

A worker no longer spends its one push on a passing failure. When a draft pull request push hit a temporary error, the attempt was used up and the work quietly disappeared. The skip is recorded and the push is tried again.

Design review sees the whole page. The proof screenshots it judged were being cut off at the bottom of the screen, so a critic was reviewing half a page as though it were all of it. Captures are full-page now, and the critic is told how tall the page is.

The built-in browser stops failing silently on heavy pages. It now waits for the page to commit before running anything against it, so a complex app can be diagnosed and driven instead of returning nothing.

The status labels on the board are pinned by a test, so the words Fleet shows you cannot drift from what the app is actually doing.

The Captain had quietly fallen about ten commands behind Fleet itself. It did not know it could check service health, switch between your accounts, read your settings, watch a worker live, or do anything in the built-in browser beyond opening a page. All of it is documented again, and a check now fails the build if a new command ever ships without the Captain being told about it.

Every lesson a worker wrote down was being thrown away. Workers finish by noting what tripped them up, so the next one does not repeat it, and none of it was reaching the project's notes. Across 71 projects, 618 of 738 of those notes were lost. They are saved now, and a batch of work that produces lessons but files none of them fails loudly instead of reporting a clean run.

A finished worker's proof no longer disappears. Clearing the board or restarting Fleet used to delete the evidence a worker left behind that its work actually passed.

Run the same task on Claude and on Codex from the command line with fleet-ctl spawn --ab. It starts both and prints both worker ids, so you can compare two answers to the same brief.

New tasks now start in the Captain chat. The separate task form is gone; ask the Captain for what you want instead.

Pick different models for the Captain and for workers. Run the Captain on your best model and workers on a cheaper one, or the other way round. Two independent choices instead of one setting for everything.

An HTML file a worker builds now opens as a page. Previously you got the source code. It renders in a sandbox, so a page a worker wrote cannot reach the rest of the app.

You choose whether Fleet sends diagnostics. A card asks once, your answer sticks, and nothing leaves your machine until you say yes.

Approvals waiting on you survive a restart. Quitting Fleet with approvals pending used to drop them and strand the workers behind them. They come back. And a card left over from a previous session now says so plainly instead of quietly doing nothing when you approve it.

Changing the model actually changes the model. Picking a new one in Settings now reaches the Captain that is already running, and the choice survives a restart instead of reverting.

Fewer false alarms on safe commands. Fleet was stopping ordinary commands because a risky-looking word appeared inside quoted text, like a column named created_at. It now reads the command instead of scanning the letters.

Reviews and research finish without being blocked. A worker whose job was to read and report was being stopped by the design-quality check meant for visual work.

Sites that check your browser work in the dock. Fleet was identifying itself with an outdated browser version that some sites reject.

Setup is steadier. Several timing problems during first run could leave onboarding stuck or open a login page twice.

Files you pinned survive a clean-up again. Fleet's routine tidying was deleting pins from the Files tab, and roughly 217 of them were lost. A pin now lives through a clean-up, through a restart, and even when the original file has gone missing.

Fleet tells you when it missed scheduled work. If Fleet was not running when a scheduled run was due, the next launch says so and names the runs that did not happen. Quitting on purpose is treated differently from a crash, so shutting down at night and opening up in the morning raises no alarm.

The chat no longer goes quiet without saying so. It follows the live conversation instead of latching onto the first one it saw, and when it is reading something that has stopped moving it tells you, instead of looking like a lull. Tuned against six days of real conversations: 56 false alarms became 6, and the real hang this fixes is still caught.

A finish check that cannot run at all is now reported as broken, instead of being tried three times and reported as a failure.

A session waiting on a prompt no longer looks like it's thinking. When Claude asks for permission and only you can answer, the session used to sit there looking busy, and the only way to find out was to open the terminal. It now raises a card. This covers prompts from Claude itself and the Captain parked on a dialog. A prompt from a tool running inside a command you already approved, such as npx wrangler login, gh auth login, or an npm y/N, is still not caught. Reported by a beta user.

Two messages sent in quick succession can no longer merge into one. A message typed while the previous one was still going out could be folded into it, sending the agent text you never wrote, or dropped entirely. Sends now happen one at a time, and a message typed in the gap is queued and delivered as its own turn. Reported by a beta user.

Recovering a frozen worker won't take over a branch that is already spoken for: one with an open or merged pull request, or one another live worker is holding. And if gh is missing or signed out, Fleet says so loudly instead of quietly disabling recovery.

Granting the browser session is a deliberate step during setup, instead of a Keychain prompt ambushing you mid-task.

Voice follow-ups work while the Captain is still working.

Your fleet can use sites you're already signed into. When a page sends you to a Google, Microsoft, Okta or GitHub sign-in, Fleet opens it in your normal browser, because those providers refuse to accept a sign-in inside an app. One button brings that session back, and the page loads signed in.

Paste a screenshot straight into the chat. Control-Command-Shift-4 copies an image without saving a file, and Command-V now attaches it.

The chat stays on the newest message, and stops pulling you back to the bottom while you're scrolled up reading, including when you answer from your phone.

The built-in browser can now be driven. Ask your fleet to click a button, fill a field, type, press a key, hover, pick from a dropdown, or wait for something to appear, and it happens in the browser you are watching.

The clicks and keystrokes are real ones rather than simulated, so pages treat them exactly like yours. It works while Fleet is in the background, and it never takes your keyboard away from you.

It refuses rather than guessing. A stale reference to something that has moved, or a button hidden behind an overlay, gets a clear error instead of a click landing somewhere you didn't intend.

One test could corrupt the others, which had been making test results unreliable across the whole app. That's fixed.

Passwords you type into the built-in browser stay private. The browser's page summary could include what you'd typed into an unlabeled field, so a password could reach the model. It can't now.

File names the Captain mentions in chat are clickable and open in Files. This never actually worked before: the feature was wired up but never ran, so nothing was ever clickable.

Sending a message with an image attached shows one message instead of two.

A smoother first run: sign-in, folder trust, and Codex setup are one guided flow instead of scattered prompts.

Open Settings from the menu bar or with Command-comma, the standard Mac shortcut.

Dictate to the Captain with your voice: a mic button and hold-Space push-to-talk in the composer.

Settings is reorganized into clear, labeled sections, so the setting you want is easier to find.

The live preview now follows the right dev-server port, and a new indicator shows when and where a server is running.

The tab for the files your fleet produces is called Files everywhere now (it used to say Artifacts in some places).

Reliability fixes under the hood.

New installs start on Opus 5. Anthropic's newest flagship is now what a fresh install picks by default, at the same cost as the model Fleet reached for before. A model you already chose in Settings is left alone.

An anonymous once-a-day usage ping, so we can count active installs and see which versions people are running. It carries no content and no way to identify you, just a random ID the app makes up for itself. It is on by default and there is a switch to turn it off in Settings.

While the Captain is writing, the chat shows a calm animated wave and a quiet “Composing” label, in place of the old three dots.

A worker that finished its job and is only waiting to be checked is no longer labeled stuck.

The fleet rail on the right keeps showing your workers when the window is narrow: it packs the rows tighter instead of hiding them, so a heading can never sit above an empty list.

When the Captain opens an image, the chat now shows you the picture itself instead of a line of text standing in for it.

A technical notice about image sizing no longer turns up in the chat dressed as something you typed.

Anthropic's Opus 5 is now one of the models you can pick for your fleet. It is their newest flagship, it holds far more of your project in mind at once, and it costs the same as the model Fleet reached for before.

The Captain chat is redesigned: warmer type, a cleaner header, a browser dock that splits into its own panel, and a sidebar you can fold away when you want the room.

Videos a worker hands you now play right in the chat, the same way images and PDFs already did.

A question from the Captain no longer disappears before you get a chance to answer it.

A Codex worker that finished its task now settles properly instead of stranding on the board as stuck.

Fleet's window shrinks further than it used to, so you can sit it beside another app on half your screen.

Switching the Captain to the model it is already on no longer produces a warning saying the change could not be confirmed.

You can now turn design reviews off in Settings, and they no longer hold up work that has nothing to do with design.

First-run setup now shows you the macOS folder-access confirmation, so you can see exactly what Fleet is asking for and grant it in one pass.

The prompt to finish an interrupted setup is clearer, and it sits alongside the update prompt instead of fighting it for the same spot.

The built-in browser reads properly: the active tab and its panel now sit on one distinct surface, so the page you're looking at is obvious.

Remote control no longer mentions Telegram before the setup wizard for it exists, so nothing in the app promises something you can't do yet.

Setup now installs Codex too, so cross-checking your fleet's work with a second model works out of the box.

Fleet now declines new work when your disk is nearly full, instead of taking the job and failing partway through.

Morning scheduled reports now appear in the Files tab automatically, no hunting required.

When workers share a project, one worker's work in progress can no longer be swept away by another's cleanup.

Internal hardening of the channel the Captain uses to direct its workers.

Groundwork for optional usage telemetry. It stays off unless you explicitly turn it on, and nothing is sent today: there is no way to enroll yet.

General reliability improvements across the app.

Fleet Desktop reaches 1.0 and opens to everyone. Give a goal in plain language, watch a fleet of workers take it on, and approve only work that arrives with proof.

Setup now detects your existing Codex wherever it is installed, even when the app is launched from the Dock or Finder.

Installing Codex honestly verifies that it actually runs, with clear guidance if macOS's security scanner interferes with the install.

Codex workers report their status accurately: no more false warm-up timeouts, and their questions reach you instead of being quietly marked done.

A setup worker that gets wedged while preparing a project now clears itself automatically instead of sitting on the board forever.

A worker whose job already finished is never respawned, so a restart can no longer leave duplicate workers on the board.

Workers always launch the newest Claude Code installed on your machine, not an older bundled copy, and the CLI keeps updating itself normally.

Reliability hardening across tests and cleanup paths, based on review feedback.

A guided walkthrough of Settings for first-time setup: skip it anytime, and if you close it midway it picks up where you left off.

The update pill and Settings now link straight to the changelog, so you can see what changed before or after you update.

A bolder look: a stronger anchor icon and a heavier wordmark across the app.

Workers start faster. Each new worker begins from a warm build cache instead of compiling everything from scratch.

Fewer false safety prompts: a command that only mentions a risky phrase inside its data no longer trips the strictest safety gate.

A scheduled run that finished but could not be verified now says exactly that instead of reading as timed out, and gets a clear finish line.

The fuel gauge stays current even when the Captain's own feed is quiet, by using readings from active workers.

Reconnecting to a long-running Captain no longer replays the entire chat history into the conversation.

The design check blocks safely when its bundled reviewer is missing, instead of silently passing work through.

Reliability hardening behind the scenes: checkpoints can no longer sweep credentials into a commit, a folder of credentials no longer makes a checkpoint look dirty, and the Captain starts with its built-in helper loaded.

Start typing anywhere in the Captain chat and it lands in the composer, no click into the box first. Arrow keys move the cursor properly again, and Cmd+K opens search right where you are instead of switching screens.

Scheduled runs now report themselves: a job that finished is marked finished, and a worker stalled by a service error recovers on its own instead of sitting quiet until someone notices.

Plan approvals arrive as a proper card: see what a worker intends to do and approve or decline in place, instead of reading through a wall of text.

The design check can no longer wave work through when its reviewer goes silent: it blocks safely and tells you exactly why it blocked. The check itself also got stricter, with a tightened craft rubric behind it.

Test results are honest end to end: a skipped test is reported as skipped, and a failing check can never read as passed.

The fuel gauge shows the age of a reading it can't refresh, and low-fuel warnings track each account separately, so switching accounts can't silence one.

Images you attach appear once in chat, not twice.

Helpful setup prompts now reach people who installed long ago, not just brand-new installs, and updating no longer loses your place in them.

Workspace cleanup is fenced to exactly the folders it owns, and a reused workspace can no longer be mistaken for one queued for deletion.

A stop button for the Captain: halt it mid-turn when it's headed the wrong way, instead of waiting out the rest of a long answer.

Every worker now runs on a budget: hard caps on the helper agents it can spawn and the web searches it can run, so a big fleet can't quietly multiply behind your back.

Images you attach get their own row in chat above your message, instead of stretching the text bubble into an empty field, and they're still there after a restart.

A turn cut short by a rate limit now says so and recovers right away, instead of sitting there looking busy until a timeout swept it up.

Long conversations scroll with less stutter: the chat no longer redoes the same clock work for every row, every repaint.

Cleanup now reclaims stray workspace copies wherever they landed on your disk, not just the usual spot. One machine got 140 GB back.

Leftover names from the app's own development can no longer surface in anything it shows you.

Typing in the Captain chat is smooth again: the conversation no longer reshuffles under your hands with every keystroke.

When a worker hits your plan's usage limit mid-task, Fleet now says so plainly instead of leaving the turn looking frozen.

Long conversations scroll faster: chat timestamps now render far more efficiently.

Tighter workspace isolation: a worker's build files can no longer end up outside its own sandboxed copy of your project.

Design checks are quicker: an instant automated screen runs first, so the second AI reviewer only weighs in on designs that pass it.

Fleet now recognizes the exact moment a worker is genuinely waiting on your answer and flags it, so nothing sits blocked in silence.

Workers on the same project share one build cache, so big builds stop eating your disk and each new worker starts faster.

Long conversations now replay in full after an app restart instead of cutting off at the last few lines.

Demo builds are now visually unmistakable from the real app, so you always know which one you're looking at.

Fleet warns you when a worker's command-line tools are too old, and automatically sweeps away workers that died without cleaning up.

Attach images and PDFs in chat with real previews. Click any of them to expand full-size.

No more double approval prompts: when the Captain relays a request you've already answered, you're only asked once.

The fuel gauge remembers its last reading, so it shows real usage numbers immediately instead of a refreshing spinner.

Your chat history, including your own messages, fully survives an app restart.

Scheduled runs that finished successfully are no longer occasionally marked as failed.

Get notified the moment the Captain has a reply for you. No more checking back to see if it's done thinking.

Links in chat render as neat chips, with preview cards for pull requests and local dev servers.

Approval cards are clearer and color-graded by risk, so you can judge a request at a glance.

Workers' branches get readable names that say what they're building, instead of random strings.

The chat opens pinned to the newest message instead of somewhere in the middle.

Images you attach stay attached when you switch tabs before sending.

A worker you stop now stays stopped: recovery can no longer accidentally revive it.

Desktop notifications when the fleet finishes a job or needs your input. Walk away and let it work.

Links in the Captain chat now open reliably in your default browser.

Tables in chat no longer squeeze narrow columns down to a single character.

The fuel gauge holds one steady reading per account instead of flickering between sources.

Fleet's build folders are now hidden from Spotlight indexing, keeping your Mac responsive during big builds.

App updates now appear as a small “Update ready” pill in the title bar instead of a pop-up that blocks your work.

First-run sign-in is dependable: retries get a fresh sign-in link, and stray browser windows no longer float over the setup wizard.

A Settings toggle lets the Captain drive your already-signed-in browser when a task calls for it.

Switch which Claude account new workers use, handy if you have more than one subscription.

Fleet staggers heavy jobs so starting several workers at once doesn't overwhelm your Mac.

New Captain sessions start with a briefing from the previous one (active workers, open approvals, recent outcomes), so a fresh session picks up right where the last left off.

Stopping a worker whose task was still queued can no longer tangle the queue.

Stopping one worker can no longer sweep away unrelated queued work.

A safety circuit breaker: a worker that keeps retrying the same blocked action is paused with a single card for you, instead of looping forever.

Fleet now watches your Mac's resources and queues new workers instead of overloading it.

Multi-account support rounds out: remove an account you no longer use, with a smoother add-account wizard.

Pale, unreadable text in the light-mode terminal is readable again.

Fuel gauges mirror your live session in real time: the newest reading always wins, and switching accounts is reflected immediately.

When the gauge is between readings it says “refreshing…” instead of showing stale numbers.

File cards show when each item was posted, and turn amber when stale, so old ones are easy to spot and close.

A worker that finishes without attaching its proof of work gets one automatic reminder before anyone has to chase it.

Design review verdicts are final: no more loops asking you to re-approve the same design.

The scheduler no longer cuts off long research jobs mid-work, and any failure comes with a plain-English notice and a way to resume.

The New Task window fits on smaller screens.

The fuel gauge: a live usage-and-limits monitor in the sidebar, showing your session and weekly pools at a glance.

The Captain gives you a heads-up when fuel runs low, before it becomes a surprise mid-build.

Per-worker memory chips show what each worker is holding onto.

The account menu grew up: your avatar expands in place with Settings, Skills, Schedules, Memory, and Outcomes.

Setting up on a fresh Mac no longer stalls on phone pairing: it skips cleanly on first launch and heals itself later.

The header now reflects your actual Claude plan.

Fleet now bundles the developer tools it needs inside the app and installs them for you, so setup works on a brand-new Mac with nothing pre-installed.

Every step of first-run setup, from installing tools to signing in, now completes on a completely clean machine.

If your browser doesn't open automatically during sign-in, you get a link to click instead of a dead end.

The board no longer piles up: a worker that goes quiet with a dead session clears itself automatically, while freshly started workers are protected.

Drag to resize the Captain's terminal pane. Your chosen height sticks across restarts.

The Captain's attention badge counts down correctly as you clear cards.

Fleet's memory compounds: every project keeps a permanent record of what its workers learned, and new projects start by reading lessons from your past builds instead of re-deriving them.

The built-in design standards got a major update: stricter checks against generic-looking AI design across app, mobile, marketing, and ad work.

Terminals no longer freeze under heavy output: they now render on the graphics chip and stay smooth.

New projects begin with an accurate, brief-informed project guide (the right stack and current versions) instead of a guessed one.

Security hardening: a worker can no longer gain the Captain's control authority, and secrets are kept out of places other processes could read.

The Captain returns to your chosen model automatically after a restart, with your conversation preserved.

The whole top bar is now a drag handle: moving the window no longer means hunting for the tiny strip by the traffic lights.

No more false “Captain failed to start” banner after an app restart.

The safety reviewer got sharper: a command that starts innocent but chains into something riskier now gets full review instead of a free pass.

A slow completion check can no longer freeze stuck-worker detection for everyone else.

Workers show their project's name instead of a raw internal path.

Fewer false “secret detected” prompts on safe commands.

Terminal tiles use less memory across the grid, with full history preserved.

Secrets Manager: paste an API key into a card and it's stored in your Mac's Keychain, never in the chat.

Autonomous disk cleanup keeps old build files from quietly piling up.

The installer is notarized by Apple, so the download opens with no security warning.

Every finished design is automatically screenshotted and scored by an independent AI critic before it reaches you, with no manual step.

The design critic runs reliably in the installed app. Previously it could wave designs through without actually judging them.

The Captain stays under control across app restarts and auto-updates.

The worker grid shows friendly descriptive names, matching the cards and detail view.

The first self-updating release: from here on, Fleet downloads, installs, and relaunches new versions in place.

The build is signed with a hardened runtime, so macOS trusts it out of the box.

Fleet ships with its skills built in, so workers know the house playbook from the first launch.