Changelog

The canvas is where sessions live now

Foreman had two places to work on a session — the Sessions page and the canvas — and they had quietly stopped being equals. The canvas drawer had grown into the real thing months ago, the same transcript, composer and Diff panel, so the Sessions page was a second route to the same surface that had to be kept in step and sometimes wasn't. It is gone. The canvas is the only session view, the header calls it Canvas, and anything that used to send you to the Sessions page — a schedule's finished run, a review finding's "Fix this", a session picked from the command palette — now opens that session on the canvas with the right tab already showing. Clicking a session node also selects its project, which is what the Git page and the fan-out, bulk and issue dialogs read, so those stop asking you to go and pick a project you were plainly already looking at. The docked preview pane and the terminal rail retired with the page; both have been canvas nodes for a while. Project Review, which used to be labelled just Review, now says what it is.

Drive a laptop's sessions from your phone

The dashboard could only ever show sessions you had shared one at a time from the desktop, which meant deciding at the desk what you might want later. Turn on "Manage this laptop's sessions from the dashboard" — a new switch in the Share dialog, separate from Share Laptop and deliberately not implied by it — and foremanapps.com lists everything running on that machine, live status included, over a single encrypted connection rather than one per row. From there you can open any of them, start a new session in a project you already have, and read your saved handoffs. It cannot run commands, browse files or delete anything: a new session names a project id and the laptop resolves the directory from its own records, so a browser can only start work somewhere you already added, and detaching a session is the strongest thing it can undo. You can also stop a running turn from the phone now, and cancel a background task individually — a turn interrupt cannot reach one of those by definition. Your phone can be notified too, on the same per-event preferences your desktop already uses: a notification names which session wants you and never what it wants, because the wording is composed from the label the server already holds rather than sent from your laptop.

Saved context, on the canvas

The ✦ Memory shelf above each project box held two unrelated things — memories you had saved and Claude Code's own internal memory files — and offered to delete either. It is now ✦ Saved context and holds what you actually own: your saved memories and your handoff digests, newest first. Clicking a handoff opens the load composer straight from the canvas, with a picker for which session to load it into, so continuing yesterday's work no longer starts by hunting for the session that owns the file. Claude's own memory files are no longer listed or deletable from here; they are the CLI's to manage, and offering a delete button for a format we only read was the wrong side of that line.

The context meter says how many turns you have left

A percentage tells you how full the window is but not whether that matters in the next five minutes or the next hour. The meter now learns how fast a session is filling and turns it into "≈N more turns", on the button's tooltip and above the bar, with the measured growth per turn in the breakdown. It appears once there is a real rate to report and stays away when there isn't, rather than turning a single reading into a forecast. The rate is measured per turn rather than per message from the agent, which matters more than it sounds: a turn with six tool calls reports its usage six times, and counting those as six turns would have promised roughly six times the headroom you have. Two figures got more honest alongside it. The window Codex reports is now explained as the effective one — its input limit minus the slice held back for the reply — because a 258k sitting next to a model advertised at 400k reads as a bug when it isn't. And a learned window can now be corrected downward: a direct reading used to lose to whatever larger number had been inferred earlier, so one bad guess stuck forever.

Claude and Codex keep their own session defaults

Session defaults held one record, so it had to be wiped every time you changed which agent starts new sessions — a Claude model id means nothing to Codex, and an effort level like max is not one Codex has. Switching agent therefore threw away the model and effort you had set. The pane now has a tab for each agent, each with its own model, effort, permission mode and credential, and picking the default agent just moves which one is in front. Switch back and forth as often as you like; neither side forgets. Claude-only settings — output style, and whether other sessions may message this one — no longer appear on the Codex tab, where they were controls that did nothing. The handoff digest picker follows the same rule, defaulting to the cheap summarising model on Claude and to the source session's own model on Codex.

Fixes

An AI review's toolbar used to keep its agent, model and file pickers live while the review ran, so changing one mid-run — or the diff simply moving underneath it — left the bar describing a run that wasn't happening; it now states what the running review was actually given, and the file count and line total are frozen from launch. Context loaded into a session that was parked on an approval was sent straight at a CLI that could not read it and was lost; it is queued now, the same as text typed into a session mid-turn. The canvas layout menu gained a "Check laptop connections" button, for when you have just noticed a stale rail and would rather not wait out the heartbeat. A subagent's token usage no longer counts toward its parent session's context meter — it is a separate conversation with its own window, and it made the reading jump and settle back for the length of every Task call. "View this session's changes" in the command palette no longer sits there enabled with no session selected, doing nothing when picked. And the light theme's accent is the same clay as the dark themes', instead of a blue that belonged to no other part of the app.

---

macOS, Apple Silicon. Signed with a Developer ID certificate and notarized by Apple — opens normally with no Gatekeeper warning, and in-app silent auto-update is enabled.

Foreman stops paying for a login shell on every command

Every command Foreman ran on your machine — resolving where claude lives, reading a git status, starting a session — opened a fresh interactive login shell first, because that is the only way to see the PATH your own terminal sees. On a fast Mac that costs about four tenths of a second; on a base M1 it is closer to three and a half, and starting one session runs five of them. Foreman now reads your login shell once and remembers what it contributed, so the commands themselves run through a shell that is roughly forty times cheaper. Nothing about which binary gets picked has changed: your profile is still read, just not from scratch every time. It is re-read whenever you come back to the window and whenever a CLI is installed, updated or removed, so a brew install you ran in your own terminal still counts without restarting the app. Removing a session got quicker too, by doing its cleanup at once rather than one round trip after another.

MCP servers and plugins, for both agents

The MCP pane only ever described Claude. A server you connected there did nothing for a Codex session, and the pane didn't say so — a green "Connected" read as a fact about the machine. Servers are now mirrored into both CLIs when you add one, each row names each agent and shows that agent's own verdict, and Connect signs in per CLI, because the two hold separate tokens and authorizing one genuinely leaves the other signed out. Plugins gained a Codex tab beside the Claude one, with its marketplaces, installs and — through the same config write Codex's own interface uses — its enable and disable switches, which its command line has no equivalent for. Plugins are listed per agent rather than merged: unlike a server, a plugin id names a marketplace the other CLI has never heard of. Adding a server on a machine that only has one of the two CLIs no longer reports a failure for the one that isn't there, a removal that doesn't land keeps its row instead of vanishing optimistically, and a schedule now warns about a sign-in only when it is the agent that schedule will actually run.

Codex sessions have skills

The skill picker was hidden for Codex sessions, on the reasoning that skills were a Claude idea. They aren't: Codex has its own full skills system, sharing the same on-disk shape and the same plugin:skill naming. The picker now offers them, read from Codex itself rather than guessed at from disk — which matters, because the enabled state lives in its config file and several versions of the same plugin can sit side by side with nothing on disk naming the live one. Skills from either agent are still never offered to the other; naming one at the wrong CLI just reaches the model as literal text.

The AI commit message runs on the agent you use

The "Generate commit message" button in both commit composers ran claude, hardcoded — so on a machine that only has Codex it failed with a command-not-found, from a control that looked perfectly available. It now runs the session's own agent, or on the Git page the one your session defaults name. The button's tooltip also says who is about to write it and on which model, rather than leaving you to find out from the result.

See which agent a session is running, and change it where you start work

A session card marked Codex and left Claude unmarked, which only answers the question if you already know the convention — and on the canvas the agent picker didn't exist at all, so anyone working there concluded the Settings pane was the only way to switch. Every session now names its agent, on the sidebar row, on the canvas node and in the session info popover, and the picker moved into the New session menu that the sidebar and the canvas share. The agent menus also mark a CLI that isn't installed on the machine you're pointing at — marked, not blocked, since an unreachable laptop hasn't established anything either way, and a laptop that simply didn't answer is no longer reported as having nothing installed. Session cards on the canvas grew wider to fit all of that without truncating the name after a few characters, and a project box now defaults to four of them per row instead of five, so the box keeps the footprint it had.

Fixes

The Codex model picker in Session defaults sat on "Checking for installed Codex models…" forever on any install where you hadn't yet clicked a machine in the fleet list — it was asking a laptop it had never been given. It now uses the same machine every other settings pane does, and says so plainly when there genuinely isn't one. Uninstalling or updating a CLI also used to leave its model catalog on offer for the rest of the app run, listing models from a binary that was no longer there; the pickers now ask again. And $FOREMAN_PORT is exported in every session rather than only in isolated ones, so the run command we suggest in project settings — npm run dev -- --port "$FOREMAN_PORT" — no longer expands to a bare --port and fails to start in an ordinary session. $PORT is still overridden only in isolated sessions, so a plain npm run dev keeps whatever default your dev server picks.

---

macOS, Apple Silicon. Signed with a Developer ID certificate and notarized by Apple — opens normally with no Gatekeeper warning, and in-app silent auto-update is enabled.

Codex sessions come back with their history

Reload Foreman, reopen a Codex session, and its conversation was simply gone — an empty transcript above a session that was still very much alive. The cause was that Codex refuses to replay a thread another process is already holding, and the session's own process is exactly that, so the replay could only ever fail for the sessions you'd want it for. Foreman now reads the thread's own record off disk, the same way it has always done for Claude, so history comes back whether the session is running or not. It also comes back complete: the old path replayed messages and dropped every command and tool call between them, and those are now there too.

Context and cost figures you can believe

Several numbers were wrong in ways that pointed in opposite directions. A Codex session's context meter was fed the thread's running total rather than the conversation's current size, and counted the cached prefix twice on top of that, so a session with 31k in context could read as over its window; Codex states its real window per model, and the meter now uses it, which makes it the more exact of the two agents. On the Claude side the window was matched against a hardcoded list of the models that existed when it was written — so a Sonnet 5 session was told it had 200k when it has 1M, while every Opus before 4.6 was told the reverse; a pinned build with a date in its id, and Bedrock and Vertex model ids, are all read correctly now. Per-turn footers gained the token counts they always had room for, and stopped printing "$0.00" for Codex turns, which are reported in tokens and no money at all. And a healthy ChatGPT subscription no longer shows a red "No credits remaining" under every usage reading — that line described a pay-as-you-go balance a subscription simply doesn't have.

Choose which agent does the work, wherever you start it

Starting several sessions at once had no agent picker at all, so it quietly launched Claude however your defaults were set — on a Codex-only machine that meant a batch of sessions that couldn't run. The AI review on a session's Diff tab had the same problem for the same reason. Both now let you pick, and the review's picker is worth having on its own: reviewing a diff with the other agent is a genuinely useful second opinion. Switching agent also stopped leaving pieces of the old one behind — a model id or an effort level from Claude means nothing to Codex, and the launch surfaces disagreed with each other about which of the two to clear, so a Claude reasoning level could survive onto a Codex session that has no such setting. The one place that stays Claude-only is the whole-project Review, and it now says so, with the reason, instead of leaving you to discover it.

Install and remove the agent CLIs from inside Foreman

An install had two minutes to finish or Foreman gave up on it and said "check again shortly" — but a large download over a slow link routinely runs past that while working perfectly, and when it landed there was nothing left watching to notice, so the row sat on "Installing…" forever. Installs are now judged on whether they've gone silent rather than on a stopwatch, they show a progress bar and the installer's own latest line while they run, and they're confirmed against the machine at the end rather than trusted to report honestly. Each CLI also gained an Uninstall button, which removes the real binary the way it arrived — Homebrew, npm or the vendor's own installer — while deliberately leaving your sign-in and session history alone. It won't run while a session on that machine is mid-work, it asks first, and where removal would genuinely need administrator rights it hands you the exact command rather than taking them.

Project boxes that fit on the screen, and can be renamed

A project box grew one column per session with no ceiling, so seven unrelated sessions made a box about fifteen hundred pixels wide with the vertical space beside it left empty. Sessions now wrap into a grid, packed so a short one drops into the gap beside a tall one instead of starting a new row below everything, and lineage and fan-out groups stay intact as units. Drag the box's right edge to set how many fit per row; the width is remembered. Projects can also be renamed now — click the name on the box, or use the Name field in project settings. It's a label and only a label: nothing on disk is touched, so two checkouts can share a name and a long directory can have a short one.

Terminals stop leaving dev servers running

Closing a terminal only ever reached the shell, not what the shell was running — so a npm run dev you'd started survived, kept its port, and was reachable only from Activity Monitor. Worse, a terminal's identity lived only in the window, so reloading the app or closing the window orphaned every running command at once with no way back to any of them. All four exits — closing a terminal, reloading, closing the window, quitting — now take the running command with them, on this machine and on any laptop connected to it. Elsewhere: settings that take effect the moment you click them are drawn as switches rather than checkboxes, so they stop looking like something waiting for a Save button that was never there; the Privacy pane's nine-event list folds away while keeping the guarantee that makes it believable on screen; the "New sessions" pane is now "Session defaults" (the old name still finds it); each laptop card shows how many sessions it's carrying and which build it's on; and the session menu's Share and browser toggles no longer slam the menu shut on the first click, which is what had been hiding the new "Show it on the canvas" for an agent browser that was otherwise running invisibly.

---

macOS, Apple Silicon. Signed with a Developer ID certificate and notarized by Apple — opens normally with no Gatekeeper warning, and in-app silent auto-update is enabled.

Point at what's wrong, several things at a time

Commenting on a running page meant one element per turn: you clicked something, wrote a note, sent it, and the agent started work on that while the other four things you'd spotted waited behind it — which is the wrong shape for looking at a screen and finding a list. You can now keep picking. "Add another" stages a comment instead of sending it, a tray at the bottom counts what's waiting and lets you drop any of them, and one Send delivers the lot as a single turn with an optional note framing the whole set. The composer also stopped covering the thing it's about: it now opens anchored under the element you picked, with that element outlined, instead of docking across the bottom half of the frame — flipping above only when there's no room below. Two silent failures went with it. A comment aimed at a session that was mid-turn used to be dropped on the floor, and one aimed at a dormant session went nowhere at all; both now queue and resume the way every other composer in Foreman does, and a send that genuinely can't get through says so and leaves your comments staged rather than eating them. And when several comments carried screenshots, every one of them pointed at the last picture written — each now keeps its own.

Comment on the page your agent is actually driving

The agent browser on the canvas was something you could watch and click, but not talk about: to ask about a specific button you described it in words and hoped the agent found the same one. You can now pick an element straight out of the live view. Hovering highlights what's under the pointer, clicking captures it — tag, CSS path, size, rendered HTML and the computed styles that explain how it looks — and the message tells the agent it's already on that page, so it answers instead of navigating somewhere else and losing what you were pointing at. The pick is a pure read: nothing is injected into the page and nothing is drawn in it, so an agent working in the same tab never sees that it happened and no outline turns up in its own screenshots. If it picked something up while you were typing and navigated away, the message names the page the element actually came from rather than quietly implying otherwise.

The page's console, where the agent can read it

A page an agent was driving could throw on every render with nothing anywhere saying so — the errors were real, in a browser with no DevTools you'd think to open, and the agent had no way to read them either, because a snapshot reports the DOM and not the log. Warnings and errors from the page now collect behind a badge in the browser node's title bar, count up as they arrive, and travel with any comment you send about that page, source location included. Only warnings and errors are kept — the rest is the bulk of a dev server's output and none of it answers "is something broken here" — and a new page starts clean, whether you navigated or the agent opened a tab of its own.

Pin the size the agent measures the page against

The agent browser followed the node it was drawn in, so "check this at mobile" was a hope rather than an instruction — the agent looked at whatever width you happened to have dragged the node to. The node's header now has a viewport control: Fit still follows the node and is still the default, and Mobile, Tablet, Laptop and Desktop pin a real device size, with a second click on the one already pinned turning it on its side. The point is that the agent inherits it — its snapshots and its screenshots are taken at whatever is set here, which is what the browser's own device mode can't do for you, since that resizes what you see. A pinned size letterboxes the view here, and clicks still land where you aim them.

Reuse a commit message you've already written

The messages you write again and again are, by definition, already in the log — but reaching one meant scrolling the graph and retyping it. Both commit boxes, on the session's Diff tab and on the Git page, now have a history button that offers the repo's own recent subjects, filtered live by whatever you've typed. It matches anywhere in the line rather than just the start, since the repeated part is often in the middle; merge, revert and squash commits are left out because git wrote those, not you; and picking one drops it in the box to edit rather than committing anything. Separately, a half-written commit message no longer disappears when you glance at the Chat tab and come back — it's kept per session, and survives a restart.

Conversations that have ended stop looking live

When two sessions messaged each other the canvas drew a blue wire between them for half an hour, which meant a blue wire only ever told you "these two talked at some point recently" — not what a live-looking canvas appears to be saying. A wire that's been quiet for three minutes now cools to grey and fades, and its label says how long ago the last message landed, so a finished exchange reads as finished long before it disappears. The arrival dot stopped replaying, too: it used to travel the wire again every time you left the canvas and came back, so a conversation that ended half an hour ago animated as if it were happening. It now plays for messages that are actually new. Elsewhere, a failure in Foreman's own background work — a failed update check most often — could raise a toast carrying an entire HTTP response body and stretch it down the height of the window; those are now trimmed to something readable, and a routine update check that can't reach GitHub no longer announces itself at all.

---

macOS, Apple Silicon. Signed with a Developer ID certificate and notarized by Apple — opens normally with no Gatekeeper warning, and in-app silent auto-update is enabled.

Every branch shows its CI

The Git page could tell you what your branches were, but nothing about whether they built — you found that out by opening GitHub. The checked-out branch now carries its CI next to its name in the sync bar, every local branch in the drawer carries the same verdict as a dot, and the pull-request list shows each PR's rollup and expands to the named checks behind it, because "1 failed" without saying which job sends you to the browser anyway. Branches that have a PR get this for free, on the same call that lists the PRs; a branch with no PR is asked about when you select it, and there's a "Check CI status" in its right-click menu when you want to re-read one. Worst state wins, so a mostly-green rollup with one red job reads as red, and a check we can't classify counts as pending rather than being quietly dropped — a failure hiding behind a green badge is the one thing this surface must never do. A repo with no CI configured shows nothing at all instead of a reassuring dot it hasn't earned.

Choose what Foreman interrupts you for

Foreman fired six different desktop notifications and there was no way to change any of them short of silencing the whole app in your OS. There's now a Notifications pane in Settings listing each one — a session needing approval, background work finishing, a session erroring, a scheduled run, a chain step, a review settling — with a switch each and a master switch above them. Everything stays on by default, exactly as it behaved before the pane existed; a settings screen isn't a licence to quietly stop telling people things they never asked to stop hearing. Two of those events are new: a session that hits an error used to be the one outcome you most needed to hear about and the only one that waited silently until you came back, and a finished review now says how many findings it came back with. Notifications still stay quiet while Foreman is in front of you, but that's now a toggle too — on a second monitor the window is often focused and nobody is looking at it.

Stop one background task without stopping the session

A Workflow or background Agent outlives the turn that dispatched it, so the Stop button — which interrupts a turn — never reached one. A dispatch that hung could only be cleared by spending a fresh turn asking the agent to kill it, or by killing the session and losing everything else with it. Each running task in the background list now has its own Stop, with a "Stop all" once there's more than one, and stopping one leaves the session and every other task alone. The task closes the same way one that finished on its own does, so the row moves itself from Running to Finished; if nothing happens, the row says so rather than sitting disabled forever claiming it's stopping.

Errors stop taking the app down with them

Anything that went wrong deep in Foreman's own machinery — a stream, a timer, a background poll — arrived as the operating system's own "A JavaScript error occurred" dialog, with a stack trace in it, and the app exited when you dismissed it. Those now surface as a toast in the app's own voice, with the message available to copy for a bug report, and Foreman keeps running. Two specific crashes are fixed outright. Asking for a diff too large to hold in memory — which a checkout onto the wrong branch will produce — used to take the whole app down; the output is now capped, and any view showing a diff that got cut says so instead of presenting a fraction of the change as if it were all of it, which matters most if you were about to send it for review. And closing Foreman while a terminal was still producing output could throw on the way out and show that same dialog as the last thing you saw.

Send several handoffs at once, and get told when to

Loading a handoff into a session sent exactly one, so picking up work that spanned two sessions meant loading one and pasting the other. The load composer now has an "Also send" picker for other saved handoffs and memories to ride along, previewed exactly as it will be sent, with the handoff you clicked Load on kept as the current state and the extras framed as background — two handoffs both claiming to describe the present is worse than one. Separately, a session filling up used to be something you noticed by watching a meter: Foreman now offers a handoff once a session crosses a share of its context window, defaulting to 75%, adjustable or switchable off under Settings › New sessions. It's a share rather than a token count because the window differs by model and by CLI, and it asks once per crossing rather than on every turn afterwards.

Smaller fixes

If your project pointed at a package inside a monorepo, or at a linked worktree, Foreman couldn't tell you were halfway through a merge or a rebase — it looked in the wrong place for the marker files git leaves behind, found nothing, and showed you a clean tree with no conflict banner and no way to continue or abort, on the one checkout where you were actually stuck. Switching projects while the Git page was still fetching pull requests left it blank for up to a minute; it now loads the repo you switched to immediately. And a scheduled run that failed announced itself twice, once as the schedule and once as a generic session error — you now get the one that names the schedule, and turning schedule notifications off actually silences it.

---

macOS, Apple Silicon. Signed with a Developer ID certificate and notarized by Apple — opens normally with no Gatekeeper warning, and in-app silent auto-update is enabled.

The agent browser works on Codex

"Connect to browser" was a Claude-only switch — on a Codex session the control wasn't there at all, because the browser was handed to the agent through a flag only Claude has. Codex takes the same server a different way, so the toggle now means the same thing on either agent, and the browser itself never learns which one is driving it. Approving what the agent does with it works properly too: Codex asks permission for a browser action in a shape nothing was answering, so before this it only ran at all if you had already given the session blanket permission — those prompts now arrive as ordinary approval cards, naming the tool rather than just the server, with "Always allow" offered only where Codex will honour it. Connecting the browser restarts the session, and a Codex session restarted before it had ever taken a turn used to come back unable to run anything; that no longer happens.

Codex transcripts stop hiding MCP tool calls

If you ran a Codex session with any MCP server configured, every call it made to that server was missing from the transcript — no request, no result, no error, just a gap where the agent had done work you couldn't see. Codex reports those calls in a shape of their own that nothing was reading. They now appear like any other tool call, with the arguments the agent sent, whatever the server returned, and failures marked as failures. The agent browser is what made this obvious, but it was true of every MCP server on Codex.

Insights runs on the agent you actually use

The Insights analysis always ran Claude, whichever CLI you had set up — so a Codex user pressed a button that quietly reached for an agent they'd never signed into. It now follows the agent you've chosen as your default. Codex reports what a run spent in tokens rather than dollars, and rather than invent a price for them, the run and the estimate beside the button are shown in tokens too; a run that has never been priced no longer gets quoted a stale dollar figure left over from an earlier Claude run. Those runs also count toward the token totals on the Cost lens now, instead of being spent invisibly.

Insights says what has changed since last time

Running the analysis twice gave you two snapshots and no relationship between them. A second run now shows a line above the findings comparing itself with the previous one — interrupt rate 18% → 12%, and which way that counts — using the numbers each run actually reasoned over rather than recomputing a window that has since moved. It only reports a metric that moved by more than the noise between two overlapping 30-day windows, it stays quiet about readings too thin to mean anything, and if nothing has genuinely moved the line isn't there at all.

Usage analytics is on by default

Product analytics used to be off until you switched it on, and almost nobody did, which meant no way to tell whether people who install Foreman ever get an agent running. It now defaults to on, and the app tells you so once — after your first successful session, not at launch — with a different sentence if you're upgrading, because you were previously told it was off. What can be sent is a fixed list of nine events, enumerated in full under Settings › Privacy, every value a number, a yes/no or one option from a fixed list: there is no free-text field in the format, so your code, paths, prompts and output cannot travel even by accident. One event is new — how far the first-run setup wizard got, so a setup that defeats people can be found rather than guessed at. Turning it off deletes the anonymous install id and discards anything not yet sent. Separately, if you have the cross-device session-detail option on under Account, it now also uploads the daily Insights counters — interrupts, permission answers by tool category, rewinds, fan-out lanes, launch timings, lines changed — which are counts only, with tool names reduced to fixed categories before they are ever written down. That one is still off unless you turn it on.

Smaller fixes

Prompts sent to Claude for a review, an Insights analysis or a fan-out judgement were being flattened to a single line on the way out, so the section breaks and indentation the prompt was built with arrived as ordinary spaces — they now reach the agent intact, which is a quiet improvement to anything those runs produce. The Privacy pane no longer shows the analytics checkbox in the wrong position for a moment while it looks up the real setting, which mattered most to exactly the people who had gone there to check that an opt-out had stuck.

---

macOS, Apple Silicon. Signed with a Developer ID certificate and notarized by Apple — opens normally with no Gatekeeper warning, and in-app silent auto-update is enabled.

Reviews can now go deep

A project review measured your codebase and reported what the numbers showed — and since proving a pinned number takes most of a run, the findings underneath it were often the thin end of the work. There is now a Depth choice on the setup screen. Standard is exactly what you had. Deep treats the metrics as where the review starts: each lens reads the files its own numbers point at, end to end, and reports up to eight findings rather than five. Two further kinds of agent then run once the lenses have settled — one per lens asking the question a lens cannot ask itself, "what did I miss?", and a last one that reads every lens together and reports only what shows up across them, like the file that is both the biggest hub and the one with no test. It costs roughly twice as much, so it is chosen per run.

Tell a review what to pay attention to

Every review graded your project by textbook, because it had never read the project's own documentation. Lenses now read your CLAUDE.md, AGENTS.md, README and any architecture notes before they begin, so a convention you set on purpose isn't reported as a finding and a deviation from a rule you set for yourself counts for more. There is also a Focus box for a sentence of your own — "the daemon boundary, anything crossing it untrusted". It steers what gets examined and how severely it's rated; it never narrows the review, and it can't change how anything is measured.

See what you fixed since the last review

Running a review twice gave you two reports and no relationship between them. A second review of the same checkout now compares itself against the previous one by default. Each finding is marked New or Still open, resolved ones are listed struck through with what was checked to confirm them, the header reads "3 of 7 fixed, 2 new", and every metric shows what it was last time and which way it moved. Only runs of the same checkout at the same scope are comparable, and where the two runs differed in a way that shifts numbers on its own — a different depth, a different set of lenses, a dead-code analyzer that resolved one time and not the other — the report says so instead of presenting it as progress. The exported HTML carries all of it.

Review numbers stop wobbling between identical runs

Two reviews of an unchanged repository could disagree with each other: 30 test files against 50, a busiest module with 85 dependents against 76. Neither run was lying — each had quietly drawn its own population, one counting only the unit-test folder while the other counted every tracked spec, one searching the folders it happened to think of while the other searched wider. Every fixed metric now pins the set of files it runs over as tightly as the command itself, always the whole tracked repository filtered by name, and a review comparing itself to an earlier one is shown the exact pipeline behind each earlier number. A count now moves when the code moved.

Pull-request signals sit on the project, not on a session

A failed build, or a review waiting on you, is news about a repository and a branch — but the dot announcing it had to live on a session, so one got picked, and a session that had never run a turn would light up the moment someone else's push broke the build. Those signals now mark the project itself: the project box on the canvas, and the project's name in the needs-attention list. Dismissing something sticks properly too. The canvas and the fleet list share one set of acknowledgements instead of each keeping its own, so opening an item from the list puts its mark out everywhere, and it stays out across a restart rather than greeting you again the next morning. The counts rolled up onto the sidebar tree now take the colour of the worst thing underneath them, so a red build can't hide behind three finished turns.

A handoff that comes back empty says so

Generating a handoff digest occasionally produced a dialog with no sections in it, no error, and a Send button that did nothing — and pressing Regenerate usually "fixed" it. The digest runs in plan mode, where a model asked for structured prose sometimes files it away as a plan and replies with a one-line note saying where it put it; nothing downstream could tell that from a real answer. The digest is now told not to write files at all, and a reply with no sections in it is reported as a failure, with the Retry button right there, instead of a dialog that looks broken.

---

macOS, Apple Silicon. Signed with a Developer ID certificate and notarized by Apple — opens normally with no Gatekeeper warning, and in-app silent auto-update is enabled.

Sessions stop insisting your login failed

A session that hit an expired CLI login was marked "Auth failed", and that mark was only ever reconsidered when the session next finished a turn. A session you had left idle never produces one — so signing back in fixed the CLI, the app kept saying otherwise, and the warning returned on every launch no matter how often you dismissed it. Verifying a sign-in now clears the mark from that machine's idle sessions too. It stays scoped: verifying Claude says nothing about a Codex session, and a session using its own API key is left alone, since no CLI sign-in would fix that one.

The attention dot lands on the session you were actually working in

When several sessions share one checkout, a pull-request signal — failed CI, a review, a branch ready to merge — is about the checkout rather than any one session, so Foreman marks a single session to carry it. It was picking the oldest record for that folder, which is restore order, not activity: a red CI run would light up a session nobody had opened in weeks while the one doing the work sat unmarked. It now marks the most recently active session instead, and skips sessions with nothing running behind them, where a dot read as "something happened here" when nothing had.

A project's MCP config can no longer run commands on your machine

Foreman's "log in" button for an MCP server built a small script from the server's name. A name is not necessarily yours — claude mcp list includes servers defined by a project's own .mcp.json, so opening a cloned repository could contribute one — and a name containing the right punctuation could break out of that script and run whatever it liked, on macOS, the moment you clicked to sign in to it. Server names are now quoted everywhere they are used, so a hostile one is inert text rather than a command. Nothing about signing in to your own MCP servers changes.

---

macOS, Apple Silicon. Signed with a Developer ID certificate and notarized by Apple — opens normally with no Gatekeeper warning, and in-app silent auto-update is enabled.

Sessions stop insisting your login failed

A session that hit an expired CLI login was marked "Auth failed", and that mark was only ever reconsidered when the session next finished a turn. A session you had left idle never produces one — so signing back in fixed the CLI, the app kept saying otherwise, and the warning returned on every launch no matter how often you dismissed it. Verifying a sign-in now clears the mark from that machine's idle sessions too. It stays scoped: verifying Claude says nothing about a Codex session, and a session using its own API key is left alone, since no CLI sign-in would fix that one.

The attention dot lands on the session you were actually working in

When several sessions share one checkout, a pull-request signal — failed CI, a review, a branch ready to merge — is about the checkout rather than any one session, so Foreman marks a single session to carry it. It was picking the oldest record for that folder, which is restore order, not activity: a red CI run would light up a session nobody had opened in weeks while the one doing the work sat unmarked. It now marks the most recently active session instead, and skips sessions with nothing running behind them, where a dot read as "something happened here" when nothing had.

A project's MCP config can no longer run commands on your machine

Foreman's "log in" button for an MCP server built a small script from the server's name. A name is not necessarily yours — claude mcp list includes servers defined by a project's own .mcp.json, so opening a cloned repository could contribute one — and a name containing the right punctuation could break out of that script and run whatever it liked, on macOS, the moment you clicked to sign in to it. Server names are now quoted everywhere they are used, so a hostile one is inert text rather than a command. Nothing about signing in to your own MCP servers changes.

---

macOS, Apple Silicon. Signed with a Developer ID certificate and notarized by Apple — opens normally with no Gatekeeper warning, and in-app silent auto-update is enabled.

Sessions stop insisting your login failed

A session that hit an expired CLI login was marked "Auth failed", and that mark was only ever reconsidered when the session next finished a turn. A session you had left idle never produces one — so signing back in fixed the CLI, the app kept saying otherwise, and the warning returned on every launch no matter how often you dismissed it. Verifying a sign-in now clears the mark from that machine's idle sessions too. It stays scoped: verifying Claude says nothing about a Codex session, and a session using its own API key is left alone, since no CLI sign-in would fix that one.

The attention dot lands on the session you were actually working in

When several sessions share one checkout, a pull-request signal — failed CI, a review, a branch ready to merge — is about the checkout rather than any one session, so Foreman marks a single session to carry it. It was picking the oldest record for that folder, which is restore order, not activity: a red CI run would light up a session nobody had opened in weeks while the one doing the work sat unmarked. It now marks the most recently active session instead, and skips sessions with nothing running behind them, where a dot read as "something happened here" when nothing had.

A project's MCP config can no longer run commands on your machine

Foreman's "log in" button for an MCP server built a small script from the server's name. A name is not necessarily yours — claude mcp list includes servers defined by a project's own .mcp.json, so opening a cloned repository could contribute one — and a name containing the right punctuation could break out of that script and run whatever it liked, on macOS, the moment you clicked to sign in to it. Server names are now quoted everywhere they are used, so a hostile one is inert text rather than a command. Nothing about signing in to your own MCP servers changes.

---

macOS, Apple Silicon. Signed with a Developer ID certificate and notarized by Apple — opens normally with no Gatekeeper warning, and in-app silent auto-update is enabled.

Sessions stop insisting your login failed

A session that hit an expired CLI login was marked "Auth failed", and that mark was only ever reconsidered when the session next finished a turn. A session you had left idle never produces one — so signing back in fixed the CLI, the app kept saying otherwise, and the warning returned on every launch no matter how often you dismissed it. Verifying a sign-in now clears the mark from that machine's idle sessions too. It stays scoped: verifying Claude says nothing about a Codex session, and a session using its own API key is left alone, since no CLI sign-in would fix that one.

The attention dot lands on the session you were actually working in

When several sessions share one checkout, a pull-request signal — failed CI, a review, a branch ready to merge — is about the checkout rather than any one session, so Foreman marks a single session to carry it. It was picking the oldest record for that folder, which is restore order, not activity: a red CI run would light up a session nobody had opened in weeks while the one doing the work sat unmarked. It now marks the most recently active session instead, and skips sessions with nothing running behind them, where a dot read as "something happened here" when nothing had.

A project's MCP config can no longer run commands on your machine

Foreman's "log in" button for an MCP server built a small script from the server's name. A name is not necessarily yours — claude mcp list includes servers defined by a project's own .mcp.json, so opening a cloned repository could contribute one — and a name containing the right punctuation could break out of that script and run whatever it liked, on macOS, the moment you clicked to sign in to it. Server names are now quoted everywhere they are used, so a hostile one is inert text rather than a command. Nothing about signing in to your own MCP servers changes.

---

macOS, Apple Silicon. Signed with a Developer ID certificate and notarized by Apple — opens normally with no Gatekeeper warning, and in-app silent auto-update is enabled.

Foreman runs on Windows

There is a Windows installer. It carries the same app the Mac and Linux builds do — sessions, the canvas, terminals, the Git page, schedules — with nothing held back or stubbed out. Install it, sign in, add the machine, and a Claude Code or Codex session runs the way it does anywhere else, including the setup wizard installing the CLI for you and walking you through signing in if you don't have one yet.

Underneath, every command Foreman runs on Windows goes through Git for Windows' bash rather than PowerShell, which is what lets one implementation serve all three platforms instead of three that drift apart. Your agent's own tool calls still use whatever shell it prefers — Claude Code reaches for PowerShell on Windows — so nothing about how you work changes.

What a Windows machine needs

Git for Windows, which supplies that bash. If it isn't installed, setup now says so plainly and points you at the download instead of reporting an unrecognised machine with no agents on it, which is what a missing shell used to look like.

The installer is not yet code-signed, so Windows SmartScreen will warn you the first time: choose More info → Run anyway. It installs for your user only, so it never asks for an administrator prompt, and uninstalling leaves your sessions and settings alone.

Windows on ARM is supported through the x64 build, which Windows runs under emulation — there is no separate ARM64 download to choose between.

Linux, one release on

The Linux builds that landed last release have now been run end to end on real hardware rather than just in CI: installing the CLI from scratch, signing in, and running sessions. A handful of things that only a real Linux machine could have surfaced were fixed along the way — a shell command that assumed bash where Debian and Ubuntu use dash, and a global npm install that failed on distro-packaged Node without saying why.

---

macOS, Apple Silicon. Signed with a Developer ID certificate and notarized by Apple — opens normally with no Gatekeeper warning, and in-app silent auto-update is enabled.

Foreman runs on Windows

There is a Windows installer. It carries the same app the Mac and Linux builds do — sessions, the canvas, terminals, the Git page, schedules — with nothing held back or stubbed out. Install it, sign in, add the machine, and a Claude Code or Codex session runs the way it does anywhere else, including the setup wizard installing the CLI for you and walking you through signing in if you don't have one yet.

Underneath, every command Foreman runs on Windows goes through Git for Windows' bash rather than PowerShell, which is what lets one implementation serve all three platforms instead of three that drift apart. Your agent's own tool calls still use whatever shell it prefers — Claude Code reaches for PowerShell on Windows — so nothing about how you work changes.

What a Windows machine needs

Git for Windows, which supplies that bash. If it isn't installed, setup now says so plainly and points you at the download instead of reporting an unrecognised machine with no agents on it, which is what a missing shell used to look like.

The installer is not yet code-signed, so Windows SmartScreen will warn you the first time: choose More info → Run anyway. It installs for your user only, so it never asks for an administrator prompt, and uninstalling leaves your sessions and settings alone.

Windows on ARM is supported through the x64 build, which Windows runs under emulation — there is no separate ARM64 download to choose between.

Linux, one release on

The Linux builds that landed last release have now been run end to end on real hardware rather than just in CI: installing the CLI from scratch, signing in, and running sessions. A handful of things that only a real Linux machine could have surfaced were fixed along the way — a shell command that assumed bash where Debian and Ubuntu use dash, and a global npm install that failed on distro-packaged Node without saying why.

---

macOS, Apple Silicon. Signed with a Developer ID certificate and notarized by Apple — opens normally with no Gatekeeper warning, and in-app silent auto-update is enabled.

Spend figures that are actually your spend

Analytics has been overstating cost, and by a lot. Claude's CLI reports a session's running total on every turn, and Foreman added that figure each time — so a turn's spend was counted again on every turn that followed it, and a session that ran twenty turns reported roughly ten times what it cost. On one real month the page read $12,570 against $1,608 for the same work. Each turn's own increment is now what gets recorded, so the totals, the per-model split, the calendar, the per-turn line in the transcript and the header badge all mean what they say.

The old numbers, gone rather than quietly wrong

Because the inflated figures were only ever stored as sums, there is nothing to recompute them from — and the amount of the overcount depends on how many turns each session ran, so no single correction recovers them. The history recorded before this release is therefore dropped once, on first launch, rather than left standing as numbers we know to be false. There's also a "Clear usage history" at the foot of the Analytics page for whenever you want to start the count over yourself; it clears this device's figures everywhere they're kept — the day totals, the per-session costs on the cards, and the copy your account holds for the cross-device view — so a cleared history stays cleared instead of returning on the next sync.

What the turns actually moved

Cost was the only thing the page counted, which left the biggest lever on it invisible. Tokens now sit beside the money — fresh input, what was served from the cache, what was written to it, and output — along with the share of everything read that came from the cache, which on a warm session is most of it and is the difference between a plausible bill and a shocking one. The counts come from each turn first-hand rather than being inferred from the dollar figure, so a Codex session on a subscription — which is never priced, because it isn't billed per token — finally contributes to this page instead of reading as free.

Background work you can look inside

A session that dispatched background agents told you only how many were running and which tool one of them last used, while they spent real time and real money out of sight. The count is now a list: what each task was asked to do, whether it's an agent or a shell command, the tool it's on, what it has spent, and a clock that ticks rather than jumping between heartbeats. Tasks stay listed for a moment after they finish, with the summary of what they actually did — that used to vanish the instant the task closed — and the list no longer waits for your own turn to end before showing anything, which is when most dispatches are made. A session you stop also stops advertising work that died with it.

Schedules that can reach past one repo

Every scheduled run was pinned to a fresh isolated worktree, which is the right default — it keeps an unattended, auto-approved run away from your working tree and leaves a branch you review and merge — but it also walled off any job that genuinely spans more than one repo. A schedule can now be pointed at the project directory itself instead. That choice is also its permission posture: isolated runs stay sandboxed, while a run in the project directory has the same reach as a session you start by hand and allow everything, and the dialog says so plainly before you pick it. Both modes are badged on the schedule card, so the riskier answer is never the one that shows nothing. Existing schedules are unchanged and stay isolated.

Transcripts that stop thinking

Reopening a session you'd worked in for a while showed "thinking…" under every reply except the last one — turns finished days ago, still animating as though they were live. Replayed history now settles all the way through.

---

macOS, Apple Silicon. Signed with a Developer ID certificate and notarized by Apple — opens normally with no Gatekeeper warning, and in-app silent auto-update is enabled.

Spend figures that are actually your spend

Analytics has been overstating cost, and by a lot. Claude's CLI reports a session's running total on every turn, and Foreman added that figure each time — so a turn's spend was counted again on every turn that followed it, and a session that ran twenty turns reported roughly ten times what it cost. On one real month the page read $12,570 against $1,608 for the same work. Each turn's own increment is now what gets recorded, so the totals, the per-model split, the calendar, the per-turn line in the transcript and the header badge all mean what they say.

The old numbers, gone rather than quietly wrong

Because the inflated figures were only ever stored as sums, there is nothing to recompute them from — and the amount of the overcount depends on how many turns each session ran, so no single correction recovers them. The history recorded before this release is therefore dropped once, on first launch, rather than left standing as numbers we know to be false. There's also a "Clear usage history" at the foot of the Analytics page for whenever you want to start the count over yourself; it clears this device's figures everywhere they're kept — the day totals, the per-session costs on the cards, and the copy your account holds for the cross-device view — so a cleared history stays cleared instead of returning on the next sync.

What the turns actually moved

Cost was the only thing the page counted, which left the biggest lever on it invisible. Tokens now sit beside the money — fresh input, what was served from the cache, what was written to it, and output — along with the share of everything read that came from the cache, which on a warm session is most of it and is the difference between a plausible bill and a shocking one. The counts come from each turn first-hand rather than being inferred from the dollar figure, so a Codex session on a subscription — which is never priced, because it isn't billed per token — finally contributes to this page instead of reading as free.

Background work you can look inside

A session that dispatched background agents told you only how many were running and which tool one of them last used, while they spent real time and real money out of sight. The count is now a list: what each task was asked to do, whether it's an agent or a shell command, the tool it's on, what it has spent, and a clock that ticks rather than jumping between heartbeats. Tasks stay listed for a moment after they finish, with the summary of what they actually did — that used to vanish the instant the task closed — and the list no longer waits for your own turn to end before showing anything, which is when most dispatches are made. A session you stop also stops advertising work that died with it.

Schedules that can reach past one repo

Every scheduled run was pinned to a fresh isolated worktree, which is the right default — it keeps an unattended, auto-approved run away from your working tree and leaves a branch you review and merge — but it also walled off any job that genuinely spans more than one repo. A schedule can now be pointed at the project directory itself instead. That choice is also its permission posture: isolated runs stay sandboxed, while a run in the project directory has the same reach as a session you start by hand and allow everything, and the dialog says so plainly before you pick it. Both modes are badged on the schedule card, so the riskier answer is never the one that shows nothing. Existing schedules are unchanged and stay isolated.

Transcripts that stop thinking

Reopening a session you'd worked in for a while showed "thinking…" under every reply except the last one — turns finished days ago, still animating as though they were live. Replayed history now settles all the way through.

---

macOS, Apple Silicon. Signed with a Developer ID certificate and notarized by Apple — opens normally with no Gatekeeper warning, and in-app silent auto-update is enabled.

A first launch that tells you what to do

A new install opened on an empty fleet, two panes reading "select a project" and "select a session", and the only real next step hidden as a faint link inside a collapsed row — so the first thing a new user did was guess. There's now a first-run wizard with exactly two steps, because there are exactly two things Foreman can't work without: an agent CLI you're signed into, and a folder to work in. Registering this machine happens quietly underneath rather than being homework. It isn't a gate — "Set up later" leaves the app usable with the setup banner up, because installs fail for reasons we don't own, and a modal you can neither finish nor leave is worse than the dead end it replaces. New installs also open in the sand palette the rest of the brand is drawn in; if you've been using Foreman for months, your theme is left exactly as it is.

Signing in without leaving the app

Every sign-in Foreman depends on — claude auth login, codex login, and the OAuth dance an MCP server or a bundled plugin asks for — wants a real terminal, and until now that meant being thrown out into Terminal.app in the middle of setup, which is precisely where people got lost. Those sign-ins now run in a terminal embedded in the panel that asked for them, and the row updates itself when the login lands. If the shell on that machine can't give a TTY, you're shown the command to run by hand instead of a window that quietly does nothing.

Setup that knows Codex exists

The readiness check only ever asked about Claude, so a Codex-only user was told permanently that their machine wasn't set up — with a banner offering to fix something that was already fine. Both CLIs are now checked, listed, and installable side by side, and the app counts itself ready when either one works. Signing in also moves the new-session default off an agent this machine can't run, including re-pointing a session created by the wizard that never got to start; a session with a transcript is never touched, because that history belongs to the agent that wrote it.

Working in half a window

Foreman assumed a wide window: at half a 14" screen the three columns collided, the canvas toolbars ran underneath each other, and settings had no room for a sidebar next to a readable pane. Every view now gives ground in order of what it costs you to lose — the fleet pane falls back to its rail, the sessions list becomes a slide-over, the view switcher keeps all five buttons as icons rather than hiding behind a dropdown, settings turns its sidebar into a strip along the top, and the canvas folds the layout controls you set once behind a ⋯ while leaving the ones you flick on and off out on the bar. The graph's session drawer now docks to whichever edge leaves the canvas the most room, and you can pin it to a side if you'd rather decide yourself. None of this writes over the pane preferences you chose at full width.

Nowhere to go became somewhere to click

Several places said what was missing without offering to fix it: the Git page rendered an empty graph under a faint caption, and the sessions list described a state rather than a next step. Both now explain what a project is and offer the one button that solves it, and removing a project from either the sidebar or the canvas goes through one path that says so out loud when the change couldn't be saved instead of pretending it worked and handing the project back on the next launch.

Cheaper handoffs, and less rummaging afterwards

Handing a session's context to another one ran its summary on your default model, which on a long session cost several dollars a go and could time out just short of finishing. Digests now default to Haiku, which measured at well under a tenth of the cost on a real 380k-token session, and they're given five minutes rather than two — every measured run landed between one and three. A chain link can pick its own summarizer, including "same as the source session", now labelled as the costlier choice it actually is. The handoff itself gained a Files section — which files the session changed, read, or verified — so the session picking it up has pointers instead of a search. Alongside this, new sessions can pick a Claude output style, and browser scratch directories left behind by a force-quit are now reclaimed instead of accumulating under /tmp forever.

---

macOS, Apple Silicon. Signed with a Developer ID certificate and notarized by Apple — opens normally with no Gatekeeper warning, and in-app silent auto-update is enabled.

A browser the agent drives, and you can watch

An agent asked to check its own work on a running site had nowhere to do it, and wiring a browser tool up by hand gave you something you couldn't see. Turn on "Connect to browser" and a Claude session gets its own isolated Chromium — running on whichever machine that session runs on — with a node on the canvas showing what the page looks like right now, live. The stream follows what you're actually looking at: pan the node off screen or collapse it to its title bar and the frames stop while the agent keeps working. When the agent reaches for the browser, the line between it and the session lights up, so you can tell something is happening in there without reading the transcript.

Taking the wheel when the agent gets stuck at a login

The case that stops an agent dead is a sign-in page, and until now that ended the run. The browser node is a real input surface — click, scroll and type into it and the keystrokes go through to the page — so you can sign in by hand and let the agent carry on past it. If you've already signed into the same site in a preview, the key button hands those cookies and stored logins straight over instead, naming the origins it adopted so a dev server that moved from one port to another doesn't look like a mysteriously broken login. Sending them to a different laptop is a thing you're asked about once, since that moves credentials onto a second computer. Running several sessions' browsers at once is a Pro thing; one at a time is free, and the cap never blocks turning a browser off or reopening one you already have.

Pointing at the thing you mean in a preview

A running preview could be looked at but not talked about — describing which button was wrong took longer than fixing it. Previews are now nodes on the canvas alongside your sessions, and you can pick an element in one, write a note, and send it as a turn: the agent receives the element, its selector, the text in it, the styles it computed, a screenshot, and the warnings and errors the page logged, all stated as things already observed rather than as a page it should try to visit. A badge counts those console messages as they arrive, which catches a page that looks fine while throwing on every render. When a project has more than one session, the composer names which one the comment is going to and lets you change it.

The canvas caught up with the Sessions view

The canvas could show you everything and let you do almost nothing, so half of any session's work meant switching views and finding it again. Right-clicking a session card now offers the same four things its gear menu does, worded identically. Each laptop's rail has a device menu behind a right-click or a ⋯ button — reconnect it, open a terminal, get to its attachments, edit or remove the connection — with reconnect there whatever the machine's status, because a relay drop is exactly when you're staring at the canvas wondering why it went quiet. The toolbar gained a filter that matches a session's path as well as its name, which is what tells apart three worktrees of the same project, and a counter that steps you through the sessions wanting attention, coloured by the one it will jump to next.

"Needs you" marks that know when you're looking

A turn finishing raised an attention mark unless that session was the selected one, which was wrong in both directions on the canvas. A session stays selected while it's scrolled clean off screen, so work you weren't watching finished silently; and the canvas drawer shows the same transcript the Sessions view does, so a turn running in front of your eyes raised "needs you" over the very words appearing there. Being watched now means what it sounds like, and the mark clears when you click the card. Alongside this, branch sizes in the Git graph hold up when the branch underneath keeps moving: a ten-commit branch cut off a busy dev used to revert to counting its distance from the trunk once dev gained a commit of its own, and read as forty-six.

---

macOS, Apple Silicon. Signed with a Developer ID certificate and notarized by Apple — opens normally with no Gatekeeper warning, and in-app silent auto-update is enabled.

How much of your plan you've actually used

Claude sessions reported which quota window they were in and when it reset, but never how full it was — so the rate-limit panel showed a dash where the number should be, and you found out you were near a limit by hitting one. Both CLIs are now asked outright, on session start and after every turn, and both answer without running a turn or spending anything. The Usage dropdown and the Analytics strip show a real percentage per window with a bar behind it, green through amber to red, next to the plan they should be read against — twenty percent of a five-hour window is a different amount of work on Pro than on Max. Weekly Opus and Sonnet budgets appear as their own rows on the plans that have them. A window that genuinely hasn't been measured yet still says so rather than showing a confident zero.

Launch pauses that match the account

Foreman pauses new launches while an account is refused, and that pause was reading the wrong signal in two directions. A quota window that had already rolled over could leave its old "blocked" verdict attached to the fresh one, holding the launch and review gates for up to five hours on an account sitting at three percent. In the other direction, a usage reading with nothing to say about status could quietly clear a real block, dropping the badge and letting launches pile onto an account that was refusing them. Both are now settled by which reading a verdict actually came from, so the gate opens when the account opens and not before.

Branch sizes measured against the right branch

The Git graph's branch drawer counted a branch's commits as "everything not on the trunk", which is only correct for branches cut straight off it. A two-commit branch sitting on a thirty-seven-commit release line read as thirty-nine commits of its own, and highlighting it lit up the whole release line underneath. Each branch is now measured against the branch it actually sits on — the deepest one it descends from — falling back to the trunk when there isn't one. Its own remote counterpart is never mistaken for its base, so a branch that hasn't been pushed in a while doesn't suddenly appear to own a single commit.

Talking to one session, not to the project

Every session registered itself under its display name, which defaults to the folder it runs in — so three sessions in one project all answered to the same address, and a message meant for one of them reached whichever the CLI picked. Each session now registers under a name of its own, so an @ mention resolves to the session you chose. What you see is unchanged: the picker and your transcript still show the readable name, with the addressing part kept out of sight.

What the context breakdown was really telling you

Clicking a session's context meter opened a panel headed "Live breakdown" that wasn't live — it comes from a separate one-shot probe that can't see your conversation, so it reported almost no messages and nearly all the window free, sitting directly beneath a meter reading two hundred and sixty thousand tokens. It's now labelled as what it is: the baseline a fresh session in that folder starts with, before anything is said. The two rows that only ever described the probe are gone, and the rest — system prompt, tools, memory files — are the ones worth seeing.

---

macOS, Apple Silicon. Signed with a Developer ID certificate and notarized by Apple — opens normally with no Gatekeeper warning, and in-app silent auto-update is enabled.

Sessions can talk to each other

Two agents working on the same problem had no way to reach each other — you were the wire, copying an answer out of one transcript and pasting it into another. Type @ in the composer now and you get every other Claude session running on that machine, Foreman's own and the ones you started in a terminal; pick one and your message is delivered to it as a real prompt, with the @Label staying readable in your own transcript. What arrives on the other side is drawn as its own card, not as a user bubble — it says who sent it, from which project, and under which permission mode, because a session that suddenly starts working deserves an on-screen answer to "who asked it to?". The canvas draws the traffic as an edge between the two sessions, and when a reply landed in the recipient's own transcript instead of coming back, the edge offers to ask it to send the answer along. Every session can decide what it accepts: the default matches Claude Code's own rule — a message auto-delivers only between sessions running the same permission posture — and you can widen or close that per session from its gear menu, or for everything you create next in Session defaults.

What each session says it's doing

A session card told you "Running" or "Idle" and nothing else, which for a fleet of them is barely more than a light being on. Claude Code can summarise its own state — what it's working on, and what it's waiting for when it's blocked — but only while something is watching for it, so there's now a switch in Appearance that turns that on. Cards and canvas nodes then carry a line in the session's own words, and a blocked one says what it needs from you in amber, which is the thing Foreman genuinely cannot work out for itself: the CLI reports a turn that ended in a question as finished, because it is. It's off by default and says why in the setting itself — the signal is per machine rather than per session, so switching it on covers every Claude session on that laptop and costs each of them a small extra model call at the end of every turn, on your plan.

Attach a file, or paste something enormous

Pasting a long log or a stack trace into the composer buried the conversation in it, and then quietly re-sent the whole wall as context on every turn afterwards. A paste past about twenty thousand characters now becomes an attached file instead, which the agent opens when it needs it and pays for once. Files can be dragged into the composer or picked outright, with image thumbnails; for a session on your own machine nothing is copied at all — the file is referenced where it already lies, so there's no size ceiling and no wait. Sending to another laptop does have to move the bytes, so it's bounded, with a lower ceiling for relay-connected machines where an oversized transfer used to be able to drop the connection rather than just fail. Anything big enough that the agent will only read part of it says so on hover.

Choosing a model without guessing

The model menu was a flat list mixing family aliases with every exact build the CLI knows about, which grew ugly as fast as the model lineup did. It's now one row per family — Fable, Opus, Sonnet, Haiku — where picking the row means "the latest build of it", and expanding it pins a specific version, newest first, with the row holding your current choice already open. "Default" is now labelled "CLI default", since in a menu of model names it read like a model rather than "don't pass one at all". Alongside that, a reasoning-effort level that the newly-picked model doesn't actually offer is cleared instead of being sent anyway, and clicking inside a submenu no longer dismisses the menu you opened it from.

Deleting a session deletes it

Removing a session offered a checkbox to "also delete the on-disk transcript", off by default, which read as the careful choice and wasn't: checkpoints and attachments went either way, and the transcript it spared became unreachable the moment the record pointing at it was gone. There's one road now, and the dialog spells out everything that goes — the conversation, including Claude Code's own history, so claude --resume won't find it in a terminal either, plus every rewind point and any files you attached. Usage and Insights survive, because cost history doesn't depend on the session still existing.

Smaller things

When Foreman's servers rejected this machine's sign-in, the app kept using a stale cached plan and left you looking at features you no longer had; it now clears the cache and signs out properly, so the state on screen is the state you're actually in. The Load Context tabs had the handoff and memory icons the wrong way round.

---

macOS, Apple Silicon. Signed with a Developer ID certificate and notarized by Apple — opens normally with no Gatekeeper warning, and in-app silent auto-update is enabled.

⌘K now knows what Foreman can do

The command palette listed your laptops, your projects, your sessions — and three actions, which meant the one surface built to answer "what can this app do" answered with a list of your own machine names instead. It's now the app's action index: fan-out, bulk sessions, issue intake, schedules, load context, checkpoints, handoff, every view, the theme and layout toggles, adding or sharing a laptop, and every settings pane, each with a line saying what it actually is rather than just what it's called. Actions come first and, on an empty query, in full — opening the palette and typing nothing is a question, and the list is the answer. Search matches across the title, the description and a set of synonyms, so "parallel", "spend" or "rewind" find the right thing without knowing its name. An action you can't run right now stays in the list, dimmed, saying why — hiding fan-out because no project happens to be selected is how you never learn fan-out exists.

Every skill picker offers the same skills

The / picker in the chat composer and the one in the chain, fan-out and bulk dialogs disagreed, and the dialogs were the ones missing things: the CLI's built-in skills — /code-review, /run, /dataviz and the rest — ship inside the binary rather than on disk, so a picker that read your folders could never see them. Foreman now asks the CLI itself for that list, once per machine, in a mode that reads no credentials and starts no turn, so all four scopes — yours, the project's, plugins' and the built-ins — appear everywhere a prompt is composed. The refresh button re-asks rather than reusing the cached answer, which makes it do the one thing you press it after: updating the CLI. Codex sessions now correctly offer nothing, because they have no such mechanism and a / command sent to Codex just arrives as literal text.

The gap between hitting send and the first word

Send a message and the badge said "Running" while the transcript sat completely still — for a cold start or a slow first token that silence ran for seconds, long enough to wonder whether the message had gone anywhere. There's now a pulsing "Claude is thinking…" line the moment a turn goes live, drawn from the same session status the badge reads, so it covers every way a turn starts: the composer, a queued message draining, a chained follow-up, a dispatched review comment, your phone. It gives way as soon as real output arrives, and stays out of the way of a permission prompt or a background task, which say more than it could.

Merge a branch that a session is already using

Dragging one branch onto another in the Git page failed outright when the dragged branch was checked out in a worktree — which is to say, whenever an agent was actually working on it, since git refuses to check the same branch out twice. Foreman now runs the merge or rebase inside that worktree instead, and asks first: the prompt names the directory, names the session sitting in it if one is live, and says plainly that the files there are about to be rewritten and nobody is going to tell the agent. Cancelling closes the menu cleanly rather than leaving it stuck open with an error.

Smaller things

The "Show me" buttons in this modal and the palette can now open the bulk-session and issue-intake dialogs, not just fan-out — the other two were listed and did nothing. Deleting a session from the canvas inspector is a bin icon rather than an ✕ that read like "close this panel", and it says Delete, because that's what it does.

---

macOS, Apple Silicon. Signed with a Developer ID certificate and notarized by Apple — opens normally with no Gatekeeper warning, and in-app silent auto-update is enabled.

See how you work, not just what you spent

The Analytics page could tell you what a month of agent work cost and nothing about how it went. It now has a second lens: Insights, thirty days of your working patterns measured against the thirty before them — how often you stop a turn mid-flight, which tools you keep denying permission to, how many fan-out lanes you actually keep, how long it takes a session to get to its first turn, and what a thousand lines of agent-written code costs you. Every card names its own sample size and says so out loud when there are too few readings to mean anything, because a rate over eleven turns is arithmetic, not a pattern. Above the numbers there's an optional analysis pass that reads them and writes up what stands out — it never runs on its own, it tells you what it will cost before you press it, and every finding it makes has to cite the sessions, metrics and tools it was drawn from. A finding whose citations don't resolve against the real data is thrown away before you see it rather than filtered into something that looks solid, which is the whole reason to trust the ones that survive. When a run turns up something you haven't read, the header says so; when it hasn't, there's no badge at all.

Send a review to the agent that can act on it

Review comments could only be dispatched to a session working the same checkout as the diff — anything else was listed and greyed out, which meant the agent that wrote the code you're reviewing was frequently the one session you couldn't send it to. The picker now offers every session on the same machine, grouped by how close it sits to the diff: this checkout first, then the project's other worktrees, then other projects by name, then sessions started outside a project. Sending across a checkout rewrites every path in the batch absolute, off the repository root rather than the session's folder — the difference matters in a monorepo, where the wrong one names a file that doesn't exist and the receiving agent reports back confidently about nothing. The batch leads with a line saying where those files live and to ask for access rather than guess, and the menu flags a session whose permission mode can't act on a review at all.

Projects on the canvas, laid out in a grid

A laptop's projects ran off in one unbounded row, so a machine with a dozen of them meant scrolling sideways to find anything. Projects now wrap into a grid you set to one, two or three columns, and the choice sticks. Anything you've dragged out of place — a terminal, a panel, a plan card — now remembers its position relative to the box it belongs to rather than to the canvas, so reshaping the layout carries your arrangement with it instead of stranding it. A project with a large memory now gets a scrollable box of a sane height instead of a two-thousand-pixel column that pushed everything else off screen. Sharing this laptop and adding another are both on the canvas now: Share sits at the foot of the machine's own rail and appears only there, and a dashed slot below the last machine adds the next one. Positions saved by the previous version are discarded once on upgrade — the old ones described a layout that no longer exists.

Help decide what gets built next, if you want to

Foreman has never sent anything about how it's used, which is an easy promise to keep and a hard one to build against. There's now a Settings › Privacy pane with a switch that is off until you turn it on, and underneath it the actual list: eight events, each one spelled out in full, and an explicit list of what never leaves your machine — no paths, project names, branches, prompts, output, file contents or cost figures. There's no free-text field in the format, so nothing else can travel by accident. You'll be asked once, after your first session finishes, and the invitation takes you to that pane rather than flipping the switch for you: agreeing to telemetry should mean having read what it is. Say no, or ignore it, and you won't be asked again.

The composer, at any width

The session composer was laid out for a full-width column and met the canvas drawer badly: dragged down to its narrow end, the chips spilled over each other and the send button got squeezed off the row. It now sheds controls by its own width rather than the window's, widest first — the parallel button, then the per-session chips you can set from Settings anyway — and keeps the three things a message actually needs: skill, dictate, send. Alongside it, a handful of Insights fixes worth naming: switching a session's model no longer reads as a completed session, a cancelled first turn no longer poisons the time-to-first-turn figure, and a "new findings" badge you've clicked now actually clears.

---

macOS, Apple Silicon. Signed with a Developer ID certificate and notarized by Apple — opens normally with no Gatekeeper warning, and in-app silent auto-update is enabled.

See how you work, not just what you spent

The Analytics page could tell you what a month of agent work cost and nothing about how it went. It now has a second lens: Insights, thirty days of your working patterns measured against the thirty before them — how often you stop a turn mid-flight, which tools you keep denying permission to, how many fan-out lanes you actually keep, how long it takes a session to get to its first turn, and what a thousand lines of agent-written code costs you. Every card names its own sample size and says so out loud when there are too few readings to mean anything, because a rate over eleven turns is arithmetic, not a pattern. Above the numbers there's an optional analysis pass that reads them and writes up what stands out — it never runs on its own, it tells you what it will cost before you press it, and every finding it makes has to cite the sessions, metrics and tools it was drawn from. A finding whose citations don't resolve against the real data is thrown away before you see it rather than filtered into something that looks solid, which is the whole reason to trust the ones that survive. When a run turns up something you haven't read, the header says so; when it hasn't, there's no badge at all.

Send a review to the agent that can act on it

Review comments could only be dispatched to a session working the same checkout as the diff — anything else was listed and greyed out, which meant the agent that wrote the code you're reviewing was frequently the one session you couldn't send it to. The picker now offers every session on the same machine, grouped by how close it sits to the diff: this checkout first, then the project's other worktrees, then other projects by name, then sessions started outside a project. Sending across a checkout rewrites every path in the batch absolute, off the repository root rather than the session's folder — the difference matters in a monorepo, where the wrong one names a file that doesn't exist and the receiving agent reports back confidently about nothing. The batch leads with a line saying where those files live and to ask for access rather than guess, and the menu flags a session whose permission mode can't act on a review at all.

Projects on the canvas, laid out in a grid

A laptop's projects ran off in one unbounded row, so a machine with a dozen of them meant scrolling sideways to find anything. Projects now wrap into a grid you set to one, two or three columns, and the choice sticks. Anything you've dragged out of place — a terminal, a panel, a plan card — now remembers its position relative to the box it belongs to rather than to the canvas, so reshaping the layout carries your arrangement with it instead of stranding it. A project with a large memory now gets a scrollable box of a sane height instead of a two-thousand-pixel column that pushed everything else off screen. Sharing this laptop and adding another are both on the canvas now: Share sits at the foot of the machine's own rail and appears only there, and a dashed slot below the last machine adds the next one. Positions saved by the previous version are discarded once on upgrade — the old ones described a layout that no longer exists.

Help decide what gets built next, if you want to

Foreman has never sent anything about how it's used, which is an easy promise to keep and a hard one to build against. There's now a Settings › Privacy pane with a switch that is off until you turn it on, and underneath it the actual list: eight events, each one spelled out in full, and an explicit list of what never leaves your machine — no paths, project names, branches, prompts, output, file contents or cost figures. There's no free-text field in the format, so nothing else can travel by accident. You'll be asked once, after your first session finishes, and the invitation takes you to that pane rather than flipping the switch for you: agreeing to telemetry should mean having read what it is. Say no, or ignore it, and you won't be asked again.

The composer, at any width

The session composer was laid out for a full-width column and met the canvas drawer badly: dragged down to its narrow end, the chips spilled over each other and the send button got squeezed off the row. It now sheds controls by its own width rather than the window's, widest first — the parallel button, then the per-session chips you can set from Settings anyway — and keeps the three things a message actually needs: skill, dictate, send. Alongside it, a handful of Insights fixes worth naming: switching a session's model no longer reads as a completed session, a cancelled first turn no longer poisons the time-to-first-turn figure, and a "new findings" badge you've clicked now actually clears.

---

macOS, Apple Silicon. Signed with a Developer ID certificate and notarized by Apple — opens normally with no Gatekeeper warning, and in-app silent auto-update is enabled.

Ask a side question without derailing the session

Half the things you want to ask an agent mid-turn aren't work — what does this file do, why did it pick that approach, what's in this branch — and asking them in the session spends the same context, the same money and the same permissions as the work itself, then leaves the answer buried in the transcript. btw opens a side chat beside the session that forks its context: it can read everything the session knows, but it cannot write a file, run a command that changes anything, or add a turn to the session's own history. It closes when you're done and leaves nothing behind, and it runs on its own model and reasoning effort — set per agent in Session defaults, since a re-read of context you already have is the cheap kind of question and shouldn't cost what the work costs.

Stash, and switch branches anyway

Trying to switch branches with a dirty working tree used to end at the reason it failed, leaving you to go and deal with it somewhere else. Foreman now offers to stash and retry in the same dialog: it sets your changes aside, completes the switch, and tells you the stash is waiting. Stashes are a first-class part of the Git page now — you can stash the working tree with a name of your own, and see, apply, pop and drop stashes from the branch drawer. Popping is never automatic, because the whole point of the stash was that you're on a different branch now.

Finding a commit in a long history

The Git page's one filter box was doing two different jobs — narrowing the graph and looking for a specific commit — and doing neither well. Searching is now its own thing: ⌘F moves you to matches one at a time, with a live count, ↵ and ⇧↵ to step forward and back, and Escape to come back to where you were. Pressing ⌘F again selects the query instead of appending to it, and the count no longer claims your cursor is on the first match before you've stepped to it. Branch labels also got a correctness fix that mattered more than it looks: a commit carrying several branch names (what git switch -c leaves behind) used to take git's first one, which could rename a whole trunk's worth of history after the branch off it — the graph now prefers the branch you pinned, then the repo's trunk, and shows the other candidates rather than confidently picking one.

Keyboard, throughout

Menus were mouse-only, which is a strange thing to discover halfway through a keyboard-driven workflow. Every dropdown in the app now takes arrow keys, Home/End, type-to-jump and ↵ to choose, filter lists take the same navigation, and dialogs and panels close in a predictable order rather than all at once. Committing is ⌘↵ from the message box, with ⇧⌘↵ to commit and push, and ⌘K remains the command palette.

Reviews that two runs agree on

The point of a review is to run it again after a round of fixes and see the numbers move — which only works if the numbers were drawn the same way both times. The dead-code lens was the worst offender and got the most work: it now names whether it ran with the repo's own analyzer config or none at all, verifies every candidate rather than a sample of them, checks packages by what they install as well as by name so a spawned CLI doesn't read as dead, lists the files behind a count instead of asserting it, and makes its chart add up to its own metrics. The dependency and architecture lenses had the same class of drift and were pinned the same way — every manifest in a workspace, not just the root; tests counted as dependents, since a module the suite leans on is genuinely depended on. Picking a scope is easier too: the folder picker has a filter box, and long metric values and chart labels no longer overflow their tiles.

Smaller fixes

The skill picker grew a refresh button and stays reachable when a project has no skills yet, so a skill you just wrote is one click away instead of requiring a session restart. Repos with more than one remote — a fork with both origin and upstream — no longer pick their trunk at random. And the read-only guarantee behind btw was tightened to cover commands that write through a flag, and commands hidden inside a substitution.

---

macOS, Apple Silicon. Signed with a Developer ID certificate and notarized by Apple — opens normally with no Gatekeeper warning, and in-app silent auto-update is enabled.

Project review

Asking an agent "what's wrong with this codebase?" gives you one pass, one opinion, and a wall of prose you have to re-read to find the part that mattered. Foreman now has a Review tab that runs the question properly: pick a repo and up to five lenses — dependency health, test presence, architecture, security and dead code — and each one runs as its own agent lane, in parallel, against the real repo. What comes back is a report rather than a transcript: a headline verdict per lens, a handful of metrics, a chart, and findings ranked by severity that you can filter and open one at a time. The lenses were written to work on any language, not just the TypeScript they were built against, so a Go or Python repo gets the same five questions asked of it.

Numbers that say where they came from

The failure mode of an AI audit isn't being wrong, it's being confidently approximate — a "47 untested modules" that was eyeballed off a file listing reads exactly like one that was counted. Every metric in a review is now stamped as measured or estimated, and a measured number has to carry the command that produced it; anything claiming to be measured without that evidence gets demoted to an estimate before you ever see it. The same rule applies to the lens that leans on an external analyzer: the report tells you which one ran, so you know whether two reports are even comparable. Per-lens cost and duration estimates in the picker come from your own last run of that lens rather than a number shipped in the build, which stops being true the moment you change model.

From a finding to a fix

A finding you agree with is still work you have to describe to somebody. Each one now expands to its evidence and suggested fix with two buttons under it: Copy as prompt, and Start session to fix, which opens a session in the reviewed project with the finding already written as its first turn. The report header keeps Re-run, so re-checking after a round of fixes is one click with the same lenses and the same scope.

Reviews you can send to somebody else

A report that only exists inside the app is hard to act on with anyone who isn't sitting at it. Export writes the whole review — verdicts, metrics, charts, every finding and its evidence — as a single self-contained HTML file with no scripts and nothing to fetch, so it opens in any browser, attaches to a mail or a ticket, and reads the same in a year. Past runs are kept and listed newest-first, each labelled with the project it ran against, and a run interrupted by quitting the app is now reconciled on the next start instead of sitting on screen pretending to still be running.

Reviews that don't crowd out your sessions

Five agent lanes starting at once is a real burst of processes, and the honest risk was that starting a review would make the rest of the app feel stuck. Lanes are throttled by their own limit, deliberately set below the app's session-launch cap, so a review can never be wider than the burst Foreman would allow anyway and can never queue behind your own session starts. Each lens gets only the read-only commands it needs — counting and searching, never writing — and the dead-code lens, the one lens that fetches and runs an ecosystem analyzer, says so on its card before you pick it. Project review is part of Pro, alongside fan-out.

---

macOS, Apple Silicon. Signed with a Developer ID certificate and notarized by Apple — opens normally with no Gatekeeper warning, and in-app silent auto-update is enabled.

A sign-in status you can believe

Foreman reported you as signed in whenever the agent CLI said so — but claude auth status and codex login status only read credentials off disk and never call the API, so a login whose token had quietly expired kept printing a cheerful email and plan while every session it started failed to authenticate. That green tick was the last thing you'd suspect. Foreman now proves the credential instead of trusting it, by running one very small turn against it, and the badge says which it means: verified, stored-but-not-yet-checked, expired, or unreachable when the machine didn't answer at all. A sign-in that has actually broken now raises a banner at startup rather than waiting for you to discover it mid-task, and a machine that was simply never set up gets the ordinary setup prompt instead of an alarm. There's also a Sign out button, which is often the only way to unstick a wedged login. This only ever runs on a subscription: verifying an API key would spend your money to light up a status badge, so those are left alone and judged on the evidence your real turns give for free.

Picking up MCP and plugin changes without restarting the app

A session connects to its MCP servers and loads its plugins once, when its process starts, so authorizing a connector in your browser changed nothing for anything already running. The restart control that fixed this only appeared if the settings pane happened to catch the server flipping to connected between two of its polls — and it only polls while it's open, so the common case, authorizing in a browser and then coming back to Foreman, was exactly the one it couldn't see. The control is now simply available whenever there's something to restart, in both the MCP and Plugins panes, and each session's own menu has a Restart process that resumes the same conversation in a fresh process. Bulk restart still applies to everything on the machine, as asked — it now tells you first when some of those sessions are mid-turn and would lose what's in flight.

Enter sends

Every message in the chat composer needed ⌘↵, which is the wrong shortcut for the box you type in most. Enter now sends, and Shift+Enter or Ctrl+Enter breaks the line; ⌘↵ keeps working, so nothing you already have in your fingers stops. The same goes for review comments, element comments and the deny-reason box. Commit-message boxes deliberately kept the old rule — a commit message is multi-line by convention, and Enter there would commit a half-typed subject line — as did the empty-composer "just reconnect me" keypress, which spawns a process and shouldn't fire from a stray Enter.

Chain a follow-up with no context

Chaining a follow-up session always seeded it with a handoff digest of everything the source session did, which is what you want when the second task builds on the first — and dead weight when it doesn't. Chaining "now run the test suite" onto a long refactor paid for a digest turn and then started the follow-up with a page of context it had no use for. The chain dialog now has a checkbox to turn the handoff off: the link becomes a pure trigger, and the follow-up starts clean in the same working directory with your task as its first turn. Links set up this way are marked on the canvas, since starting cold changes what you should expect from them.

---

macOS, Apple Silicon. Signed with a Developer ID certificate and notarized by Apple — opens normally with no Gatekeeper warning, and in-app silent auto-update is enabled.

A commit graph you can actually follow

Any history with more than two or three branches in flight drew as a knot: every edge curved diagonally across all the rows between a commit and its parent, cutting through the lanes and commit dots in between, and lines were coloured by column — so a branch changed colour when it shifted columns, and an unrelated branch that later inherited the column got the same colour. Branches are now coloured by the line itself, so a branch keeps one colour from tip to base and two lines drawn at the same height never share one. Edges run straight down their own lane and take a single turn at one end, the familiar |/ where a branch rejoins its base, and commits are read in topological order so a branch's commits stay together instead of being scattered by timestamp among every other branch's. Hovering still traces a whole branch and dims the rest — it now lights up the same line your cursor is on.

More than one terminal per project on the canvas

A project on the canvas could open one shell, which is the wrong number the moment you want a dev server running while you type in another. You can now open as many as you need, each its own node with its own shell, placed side by side and numbered in the title — and a number stays with its terminal, so closing one doesn't renumber the rest out from under you.

The canvas remembers how you arranged it

Everything you positioned on the orchestration canvas — popped-out session panels, plan cards, terminals — went back to its computed default spot on the next launch, which got expensive once a project could hold several terminals arranged deliberately. Positions and sizes now persist, and the terminals you left open come back with the canvas. Their scrollback does not: shells are killed on quit, so a restored terminal opens a fresh one at the same directory rather than pretending to be the session you left.

Saved commands for a project's terminals

The terminal's script picker only knew what was in package.json, so the commands you actually retype all day — a tunnel, a deploy, a container shell — lived in your own notes. A project now carries its own list of named commands, editable in Project settings and offered from the same Run… picker in every terminal for that project, docked or on the canvas. There's a button to save whatever the shell is currently running without retyping it. Saved commands are placed at the prompt rather than run on click: a npm run script is knowably safe and an arbitrary saved command isn't, and one keypress is cheap insurance. They live on the project, so they follow it to whichever machine it's on — keep credentials out of them.

Review comments survive, and can go to another session

Staged review comments existed only for as long as the tab was open and only for a session that was currently running: reloading the app dropped the batch, and reviewing work an agent had already finished meant resuming it before you could type a word. Comments now persist, so you can stage them across a restart, and staging no longer needs a live session — the send resumes a dormant one for you. When several sessions share the project you can pick which one receives the batch; sessions working a different checkout are shown but not selectable, with the reason next to them, since the diff's line numbers wouldn't mean anything in their tree. If a comment's diff has moved underneath it, it's re-anchored to the code it was written against rather than silently re-pointed at whatever now sits at that line. And a send that fails now keeps the batch and says what went wrong, instead of clearing a review you paid for.

Fixes

Every way to start a session — new, isolated, bulk, fan out, from an issue — is now one labelled split button in both the sidebar and the canvas project box, rather than a row of unlabelled glyphs that meant slightly different things in each place. Dialogs opened from a canvas terminal's toolbar rendered inside the node, with a backdrop the size of the node and the shell painting over the card; they open properly now. A side drawer no longer paints over the header's own menus. An inline review comment on a file with one very long line no longer stretches past the edge of the panel it's in.

---

macOS, Apple Silicon. Signed with a Developer ID certificate and notarized by Apple — opens normally with no Gatekeeper warning, and in-app silent auto-update is enabled.

Read back through a running session

Scrolling up in a session that was still working didn't hold. Every token the agent produced snapped you back to the bottom, which made reading what it had done ten minutes ago effectively impossible — and it fought the transcript search, dragging you off a match the moment new output arrived. The transcript now follows the tail only while you're already parked at it. Scroll up and it lets you stay; a Jump to latest button appears in the corner, with a dot when output has arrived since you left. Sending a message always takes you back down, because at that point you're waiting for the answer.

Shared sessions in the browser show the work, not just the words

Opening a shared session from a browser gave you the conversation and almost nothing else: tool calls appeared as a bare name, and everything they read, ran or changed was dropped. The transcript there now matches what you see in the app — each tool call collapses to a line naming what it touched, and opens to show the command output, the file it read, or the edit it made as a diff. Every turn carries the same summary of what it changed on disk, expandable file by file. There's also a Changes tab: the session's working tree, where you can stage, unstage, discard, commit, push and switch branch from your phone. Discards and branch switches ask first — the one thing a mis-tap on a phone shouldn't be able to do quietly.

Terminals stay where they belong on the canvas

A project terminal opened on the canvas is drawn as an overlay, and it behaved like one: it painted straight over the app header, over the session drawer, and over the canvas's own toolbars, and panning a terminal past the edge of the canvas left it spilling across the rest of the window instead of being clipped like every other node. It now sits under all of that chrome and is clipped to the canvas edge. Its text scales with the canvas too, so zooming out shrinks the shell along with the nodes around it rather than leaving fixed-size text in a shrinking box — and an expanded session on the canvas now reads at canvas size instead of looking like a window cut out of the drawer.

Your laptop stops flickering offline while it sleeps

A sleeping laptop showed up on the dashboard as a device blinking between online and offline for as long as the sleep lasted. The relay connection couldn't tell a real system sleep from a flaky network, so it kept retrying throughout — and a machine woken briefly by Power Nap gave those retries just enough time to check in before suspending again, each one registering a genuine, momentary "online". Foreman now listens for the actual sleep and wake events: the connection closes cleanly on sleep, the device reads offline for the whole nap, and it reconnects the instant the lid opens rather than waiting out a backoff.

Fixes

Spend recorded slightly ahead of this machine's clock — which happens when a laptop you drive remotely is a few minutes fast — no longer landed in a future day bucket where the daily figure couldn't see it but the total could, making "today" and "this week" fail to add up to the total across a month boundary. A packaged Dev build now keeps its own laptops, sessions and sign-in instead of sharing them with an installed release, so the two can run side by side.

---

macOS, Apple Silicon. Signed with a Developer ID certificate and notarized by Apple — opens normally with no Gatekeeper warning, and in-app silent auto-update is enabled.

Stop cancels the turn, not the session

Stop used to kill the CLI process outright: the agent went away mid-thought, the session dropped to resumable, and picking it back up meant paying to replay the transcript before you could say the one thing you'd stopped it to say. It now interrupts the turn the way the agent's own escape key does. The session stays live, keeps its context, and is ready for your next message immediately — so stopping an agent that's heading the wrong way costs you nothing but the turn it was in. If an interrupt doesn't land, the button turns into Force stop and the old process kill is one press away, rather than being the only thing on offer.

Codex sessions show what they cost

Codex reports tokens where Claude reports dollars, so a Codex session used to sit at a token count while everything around it talked in money — and it was left out of the cost totals entirely. Turns on an API key are now priced from OpenAI's published rates, so Codex sessions carry a real figure and count toward your daily and monthly spend alongside Claude. Where a price would be a guess it still isn't shown: a session on a ChatGPT subscription isn't metered per token, and a model that isn't in the rate table falls back to tokens rather than inventing a number from a stale one.

Cost figures that agree with each other

The cost readouts disagreed depending on where you looked. "This week" and "This month" meant different spans in the app and on the web dashboard, so the same account could show a month smaller than the week inside it; the web dashboard's "This month" reached back into the previous one, disagreeing with the calendar printed directly beneath it. Both now mean the calendar week and the calendar month everywhere. The badge also stopped quietly switching scope — it opened with your fleet-wide total and fell back to this machine's alone after the first turn. Cost per project is now kept as its own running total, so deleting a session no longer takes its spend out of the project breakdown while leaving it in the totals, and the per-model split is accumulated from the same turns as the total instead of being re-derived from whichever sessions still exist. If you drive one laptop from another, that machine's spend is no longer counted twice in your account-wide figures.

Skills where you start work, not just where you continue it

The skill picker only existed in the chat composer, because the list of skills came from a session that was already running. Bulk runs, fan-out and chained follow-ups had no way to reach one — you typed the /name from memory and hoped. All three now offer the picker while you're composing the prompt, reading skills straight from disk. That list is also fuller than the old one: your global skills in ~/.claude were being dropped whenever a project happened to have no .claude/commands directory, which is most of them, and skills from enabled plugins are now included and named the way you invoke them. Bulk task boxes can be expanded too, so a long prompt is readable before you launch twenty of them.

Pro features are labelled instead of silently failing

Features that depend on our servers — driving sessions from your phone, running agents across the laptops you own, and cost across all your machines — now say so where you meet them, with a lock that explains what the feature does rather than only that it's locked. Fan-out and AI review are marked the same way. Nothing you already set up gets taken away mid-flight: a shared session can always be un-shared and a shared laptop always un-shared, whatever your plan says, so a lapsed subscription can't strand you in a state you can't undo.

Fixes

A Codex thread that hits an internal fault now says so in the transcript and settles the session, instead of leaving it stuck at "running" with no reply ever coming. The first-run screen leads with getting one agent going on this machine rather than with connecting a fleet.

---

macOS, Apple Silicon. Signed with a Developer ID certificate and notarized by Apple — opens normally with no Gatekeeper warning, and in-app silent auto-update is enabled.

See what a subagent actually did

When an agent handed work off to a subagent, all you got back was the final report — the tool call sat there as a closed box for however long the run took, and whatever it read, searched or decided was gone. Those cards now open. Inside is the run's own transcript: the prompt it was given, what it said, and the tools it used, attributed to the subagent rather than mixed into the main conversation. A subagent that spawned its own subagent nests the same way. Transcripts are only fetched when you open a card, since a busy session accumulates dozens of them, and a card opened while its subagent is still working says so and re-reads itself when the run finishes rather than freezing on whatever it caught mid-flight.

"Always allow" that means what it says

Allowing a tool for the rest of the session used to remember the tool's name, which is far broader than it sounds: approving one harmless shell command quietly covered every other shell command for that session, including the ones you would never have approved. That's gone. The agent's own rule engine now does the remembering, scoped to the specific command or path it asked about — approve one and a different one still stops to ask. The button says which call it will cover, and when the agent offers nothing narrow enough to remember, it isn't offered at all rather than promising more than it delivers. Two more permission postures joined the picker as well: Auto-decide, which allows what it judges safe and still asks about the rest, and Never interrupt, which — despite the name — is the strictest of them, denying anything that would need approval rather than pausing for you.

Handoffs keep running when you close the dialog

Generating a handoff digest meant sitting and watching it: closing the dialog threw the work away, so you waited on a summary of a conversation you'd already had. The digest now runs in the background. Close the dialog, keep working, and a toast brings you back when it's ready; a small marker on the session shows one is running or waiting for review in the meantime. If the session has moved on since the digest was taken, the dialog says how far and offers to regenerate, because a summary that quietly predates your last few turns is worse than an obviously stale one.

A canvas that stays readable as it fills up

Each machine's row on the canvas is now labelled once down its left edge instead of repeating a truncated laptop name on every project box, and that label is a handle: drag it to move the whole row, machines and all, with the arrangement remembered between launches and a way back if you drag one somewhere silly. Parallel runs got quieter too — once you keep a winner, the lanes that lost fold away behind a "spent lanes" toggle on both the canvas and the sessions list. They're folded, not deleted: their transcripts are the only record of an attempt you paid for, and dropping them would make the most expensive way to do a task look like the cheapest.

More fonts, and an Appearance pane with room to breathe

Two new typeface pairings: Fira Sans with Fira Code, and Space Grotesk with Cascadia Code for something less neutral. The font picker is a dropdown now rather than a grid of cards that dominated the pane — each row still renders in the face it names, because a list of font names tells you nothing — and it shares a line with Text size, with the controls below it stretched to fill the width they were leaving empty.

Fixes

Starting a session from the canvas now uses the defaults you set under New sessions, instead of ignoring your chosen model, agent and permission mode. "This month" in the cost readouts means the calendar month, matching the calendar shown next to it, rather than a rolling 30 days. A whole family of accent-coloured details across the app — badges, markers, inline highlights — were silently rendering in the wrong colour and now don't. Codex sessions get their "Always allow" button back. And dragging a laptop row no longer writes to disk on every frame of the drag.

---

macOS, Apple Silicon. Signed with a Developer ID certificate and notarized by Apple — opens normally with no Gatekeeper warning, and in-app silent auto-update is enabled.

Load a handoff without it running off

Loading a saved handoff or memory into a session used to fire a fixed message the moment you picked one, and that message always told the agent to pick the work up and continue — which is only what you wanted about half the time. Often you're staging context for a conversation you haven't had yet, and the agent charging off before you've said what you actually want is worse than no help at all. There's now a step in between: the message is shown to you first, editable, before anything is sent. A toggle switches it to "load this, don't start working yet", which swaps in wording that says exactly that. Both templates live in Settings under Context, so if you keep rewording the same sentence every time you can just change it once.

Launch again after a fan-out that only half-launched

Racing one prompt across several lanes could stop partway — a rate-limited launch, a laptop dropping — leaving some lanes running and some never started, and pressing Launch again made it worse rather than better. The retry now continues the run you started instead of beginning a new one: lanes that already exist are left alone, only the missing ones are launched, and the form freezes once the first launch goes out, because editing the prompt or the lane count between attempts meant lanes of the same race quietly received different prompts, or the retry reported success while doing nothing at all. When you ask the AI to pick a winner, an answer that could equally name two lanes is now reported as no winner rather than guessed at, since silently keeping the loser is the one outcome worth avoiding. And pinning the winner out onto the canvas no longer makes the race it came from vanish — the group stays put, still explaining the lanes that were spent on it.

Sessions that are still setting themselves up say so

A session running a project's setup script showed up as "Running" with an empty chat, which reads as an agent that has hung. It now says "Setting up…" until the bootstrap finishes, so the wait is visibly the machine's rather than yours. Setup scripts also stopped competing with real launches: a slow bootstrap no longer holds a launch slot that another session is waiting for, and one that fails reports its error straight away instead of queueing that report behind unrelated work. On a remote machine, a setup that hits its timeout now actually stops the command it started rather than leaving it running out of sight.

A heads-up before a schedule fires, not hours after

The schedule dialog already warned you at authoring time about integrations that need an interactive login and about an agent CLI that isn't installed or signed in on the target laptop — the things an unattended run can't fix for itself. GitHub was the gap: a scheduled run that reads issues or opens pull requests would fail at three in the morning and only tell you afterwards. The dialog now checks the target laptop as you write the schedule and says so if GitHub is set up there but signed out. If it isn't installed at all — the normal case for a schedule that never touches GitHub — it stays quiet.

"Show me" links in What's new

The what's-new panel after an update could only describe a feature and hope you went looking for it. Its items can now carry a button that takes you straight there — opening the Git view, a settings pane, or the dialog the note is about — and the panel gets out of the way as it goes, rather than sitting on top of the thing it just pointed at. Links that need something selected to make sense simply aren't offered when nothing is.

Fixes

A dev server that can't start because its port is already taken now says so in the preview panel instead of showing a blank page. The commit graph tells local branches apart from their remote counterparts rather than labelling both the same way. Change badges fill in for sessions that appeared while their checkout was being read, and the refresh spinner stops when the last refresh finishes rather than the first. Starting a session from the canvas surfaces the failure on the card if it doesn't start. The setup wizard clears its sign-in warning once you've signed in, instead of leaving it on screen.

---

macOS, Apple Silicon. Signed with a Developer ID certificate and notarized by Apple — opens normally with no Gatekeeper warning, and in-app silent auto-update is enabled.