Changelog

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.

Unblock an agent from your phone

Sharing a session to your phone let you read along and send messages, but the moment an agent stopped to ask permission it went quiet — and that is exactly the moment being away from the laptop costs you, because the run is now parked doing nothing until you walk back. Approvals, questions and plans now arrive on the phone as cards you can act on: allow or deny a tool call, tap an option to answer a question, or approve a plan and watch it start building. Decisions are deliberately allow-once or deny only — a rule remembered for the rest of a session is too easy to fat-finger on a phone, and unlike the other two there's no taking it back. The relay carries the decision without being able to read it, the same way it already carried the transcript.

A phone viewer that survives a locked phone

Locking your phone or switching apps killed the connection silently, and the viewer sat there showing a conversation frozen at the moment the screen went dark — the only fix was backing out and reopening the session. It now reconnects on its own, and immediately rather than on a timer when you pick the phone back up, refetching everything it missed while it was away. Each shared session also says what it's actually doing — working, waiting on you, or idle — both in the list and at the top of the chat, so you can tell at a glance which agent needs you without opening all of them. The dashboard installs to your home screen as a standalone app, and the list keeps itself current as sessions are shared and laptops come and go.

Keep this Mac awake

A MacBook docked through a KVM would drop mid-session every time you switched inputs: the external display disappears, macOS stops seeing a valid closed-lid setup, and the machine sleeps with your agents still running. A toggle in the header now holds the Mac awake with the lid closed, which is something only a system-wide setting can do — so it explains itself before raising the password prompt rather than springing one on you, and asks once for the install rather than on every switch. Turning it off, or quitting Foreman, puts sleep back exactly as it was, and you can hand the permission back entirely from the same menu whenever you want it gone.

---

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 every turn actually changed

Reading a transcript told you what the agent said it did, not what it did — to find out you left for the diff panel, which only ever showed the state of the whole workspace right now. Each assistant turn now carries its own summary of the files it touched, with the counts on the header and the real diff a click away. It's built on the per-turn checkpoints Foreman already takes, so it works on sessions you ran weeks ago, not just new ones, and it captures everything that landed on disk in that turn's window — including files the agent created outside a tool call. Appearance settings let you keep the block collapsed, expand every level by default, or turn it off entirely if you'd rather the transcript stayed lean.

An API key per agent, and Codex can finally use one

An API key was a property of the machine — one Anthropic key per laptop — which left Codex with no way to run on a key at all, and no way to bill Claude and Codex differently on the same machine. Keys are now per agent, set from that agent's own row alongside its sign-in badge, so a machine's auth reads as one block per agent instead of a single field pretending to cover both. Codex works too, despite ignoring the usual environment variable: an API-key Codex run gets a private home carrying just that credential, with your config, MCP servers, skills and session history linked through from the real one, so resume and fork keep working and your own codex login is never touched. The "Run on" choice between your subscription and a billed key is likewise per agent now, and only appears when that agent genuinely has both.

Cost analytics that count your other machines

Only the daily totals on the analytics page added up across your devices. The most expensive sessions, the per-model breakdown and the session count were quietly this machine's alone, so the more machines you worked on, the more the page under-reported. Turn on "Share session detail across devices" in Account settings and those breakdowns cover every machine you've enabled it on. It's off by default and deliberately narrow about what it sends: each session's cost, turn count and model, plus the last two segments of its directory — never a full path. The page now says which it's showing you, so a number is never ambiguous about whose sessions it counted.

Typing after Stop no longer goes nowhere

Stopping a session killed the process it was talking to, and the composer went quietly inert — you could type a message, send it, and watch nothing happen, with no hint that the session needed reconnecting first. Sending on a stopped session now queues the message, reattaches, and delivers it as soon as the session is listening again. Hitting the send shortcut with nothing typed still does what it always did: just reconnect.

---

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.

Rewind a session to any earlier turn

When an agent went down the wrong path, your options were to talk it back or throw the session away — the files it had changed stayed changed either way. Every turn now leaves a checkpoint behind, and you can restore any of them: from the session's gear menu, or by hovering the turn you want to return to right in the transcript. A restore rewinds both together — the workspace files come back exactly as they were, and the conversation is cut back to that point, so the agent isn't left believing in edits that no longer exist. You see a summary of what would change before confirming, and Foreman quietly snapshots the current state first, so even a restore itself isn't a one-way door. Restoring forward works too: undo a rewind by restoring a later checkpoint. Works with both Claude and Codex sessions in git projects.

New sessions start the way you told them to

The model, permission mode and directives you picked for a new session were plain component state — they reset on every project switch and every restart, so a choice never lived long enough to become a default. Those choices now live in Settings under "New sessions" and persist: every session you launch starts from them, and changing them in the launch menu updates the same record. The session list header slims down to the one choice you actually make per launch — which agent — plus the worktree toggle, which stays per-launch because each isolated session mints its own branch.

Edit each agent's global instructions from Foreman

The instructions file every session reads — CLAUDE.md for Claude, AGENTS.md for Codex — could only be edited by finding it on disk, per machine. Each machine's panel now has an Instructions section where you can read and edit them directly, for every connected laptop, remote ones included. Foreman keeps its rules in a clearly marked block and splices only that block on save, so anything you've written in the file yourself stays untouched.

Pick your text size and typeface

The interface had one type size and one font, take it or leave it. Appearance settings now offer three text sizes — the whole interface scales together, terminal included — and a choice of font pairings (Geist, Inter, IBM Plex, or your system font), each pairing an interface face with a matching code face so diffs and file paths don't look bolted on. Tooltips got the same attention: one consistent, theme-matched style across the app instead of the browser's native bubbles.

A terminal on the canvas

Opening a shell in a project meant leaving the canvas for the docked terminal panel. Each project box can now pop open its own terminal right beside it on the canvas, with the project's run scripts a click away — start, stop and restart without leaving the map of what your agents are doing.

---

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.

Your own memories show up on the canvas again

A memory you saved from the chat didn't appear on the canvas — not until the next time you restarted the app, because the canvas read each machine's memory list once and then held it. It updates as you save now, and as you rename or delete from the Memories tab. Memories saved from an isolated worktree session were worse off: they were filed under the throwaway checkout the session was working in, so they belonged to no project on the canvas at all and turned up under a session-… heading in the Memories tab. They're filed under the project itself now, wherever the session happened to be running. Memories saved before this update keep the path they were stamped with.

Delete a memory Claude wrote

Claude's own memory files were read-only in Foreman — you could open one from the canvas and read it, but clearing out a stale note meant going and finding the file yourself. They can be deleted now, from the same dialog, and the pointer to the deleted note is stripped from the project's MEMORY.md index so Claude stops being told about a file that no longer exists. Deleting any memory — Claude's or your own — now asks first, since there's no undo. If a save or delete does fail, the dialog keeps your file and its buttons on screen instead of replacing them with the error, so you can just try again.

Git errors read like a status line, not a crash

The Git page printed raw git output in full red text, so an ordinary refusal — checking out a branch another worktree already has, say — filled the panel with four wrapped lines and looked like something had broken. Those messages are now a single truncated line, with the whole text on hover if you need it. The same treatment covers the branch, push, merge and commit panels, matching how the diff view has always shown a failed commit.

The dot follows background work to the end

A session that dispatched background work — a workflow, or an agent sent off to run on its own — changed status when that work finished, but never raised the dot that tells you a session wants you. The turn itself had ended long before, so the "finished" signal had already come and gone. Finished background work now lights the same dot and adds the session to your inbox, so it's visible from the list and the canvas rather than only in a desktop notification you may have missed. A turn that failed keeps its red dot: later background work completing won't paint over the fact that something went wrong.

---

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 start immediately again

Starting a session got noticeably slower in 1.1.0 — from the session list, from the canvas, and on every resume — because Foreman checked the state of your MCP servers first, and that check really dials each configured server before anything can begin. It no longer sits in front of your work: the same check now runs when the app launches, whenever you come back to the window, after you log into a server from Foreman, and whenever the MCP pane loads, so stale authentication still gets cleared without any session waiting on it. Changing a model, effort or permission mode mid-session is faster for the same reason, since each of those restarts the agent underneath. If you've just run claude mcp login in your own terminal and want to know right now whether sessions will see the server, the MCP pane has a Recheck button that asks immediately rather than waiting for its next refresh.

The canvas drawer stops wrapping its controls

At its default width the session drawer on the canvas was too narrow for its own toolbars: the model, effort, permission and agent selectors wrapped their labels onto a second line, and the Diff tab's review bar did the same. The drawer now opens wide enough for all of it, and those controls hold themselves on one line regardless of the width you drag it to — narrow the drawer and the surrounding text gives way instead of the buttons.

---

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.

Settings you can reach from anywhere

Adding a laptop, installing an agent CLI, connecting an MCP server or managing plugins all lived in the Sessions view's sidebar — so from the canvas there was simply no way to get at them. All of it now lives in a settings overlay you can open from any view with ⌘, from the command palette, or from the account button in the header. The left nav separates what belongs to Foreman itself — your fleet, your account, your theme — from what belongs to a single machine, with a laptop picker heading that group, so it's always clear which computer you're configuring rather than depending on a switcher that only appeared once you had two. Your Foreman account, relay connection and phone pairing code moved out of the header dropdown and into their own pane, and the setup wizard is now reachable from the Agent CLIs pane instead of only from a failed session.

Stop and restart what a terminal is running

The built-in terminal could start npm run dev but never help you stop it — you were on your own with Ctrl-C, and closing a tab silently killed whatever was in it. Terminals now notice when a command is running and offer Stop and Restart beside it: Stop interrupts the whole process tree so a dev server frees its port and cleans up its workers, escalating only if it ignores that, and Restart waits for the old process to actually exit before running the same command again. Tabs with something running show a live indicator even when they're in the background, and closing one asks first.

The canvas drawer is a full session

Selecting a session on the canvas gave you a stripped-down chat that quietly lacked attachments, message queueing, Stop, quoted replies, saved drafts and load-context — anything beyond typing a sentence meant jumping back to the Sessions view. The drawer now runs the same chat the main view does, so everything works identically in both places, and it gained a Diff tab: you can review, stage, comment on and commit a session's work without leaving the map. Its header picked up the controls that were missing too — rename, context meter, branch switcher, worktree control and the session menu. Expanded session cards on the canvas are now for reading rather than typing: the transcript and its approval, plan and question cards stay, so you can still approve a tool call or answer a question in place, but there's no second composer competing with the drawer's.

MCP servers report their real auth state

A server could sit marked "needs authentication" long after you'd successfully logged in, because Claude's own cache of that state is never cleared on a successful login — and any session already running had connected before the fix, so it couldn't see the server regardless. Foreman now reconciles that cache before every session starts, and when a server's configuration or auth changes it offers to restart the sessions affected, counting every live session on that machine rather than only the ones in the project you happen to be looking at. The Restart action also reaches sessions working in the background or waiting on your approval, which it previously skipped.

---

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 canvas is now the default view

Sessions used to live in a flat list you scrolled and guessed at. The new orchestration canvas lays out your whole operation as a map: each project is a box, each session a card with live status, git changes, and cost, and machines you connect add their projects to the same map. Cards expand in place when you need the full chat and tuck back down when you don't. You can also chain a follow-up onto a running session — when it finishes, the next session launches itself, seeded with a handoff digest of everything the first one did, either automatically or after you review it.

Race the same task across parallel sessions

When the right approach isn't obvious, you can now fan a prompt out to up to four sessions at once, each working in its own isolated worktree on its own branch — optionally with a different model or effort per lane. The group renders as one raced cluster on the canvas; when the lanes finish, a compare view puts the diffs side by side, an optional AI judge weighs in, and one click keeps the winner's branch and discards the rest. Fan-out launches go through the same throttled gate as bulk runs, and the lane cap is enforced in the app itself, not just the dialog.

Turn GitHub issues into sessions

Your repo's open issues are now browsable inside Foreman. Queue the ones worth doing to a per-project triage board — queueing never starts anything — then start each one when you're ready, with one click on your defaults or with per-issue agent, model, and branch choices. The session's first turn carries the issue body and its freshest discussion, the branch is namespaced per issue, and the resulting PR defaults to closing it. Alongside this, a new stage lens groups sessions by what they need from you — a plan waiting for review, changes to look at, still working, or quiet — in both the list and the canvas, with a reload button to refresh git state on demand.

Fresh worktrees boot ready to work

Sessions launched into a fresh worktree used to start in a bare checkout and burn their first turns discovering pnpm install. Each project can now define a setup script and a run script: the setup runs before the agent ever starts (with live output, and a loud error card if it fails), and the run script gets a stable per-worktree port so dev servers from parallel sessions don't collide.

Squash, multi-cherry-pick, and safer history editing

The commit graph gained real history tools: select a contiguous range of commits and squash them into one, or cherry-pick several commits at once. Squash refuses anything unsafe — published commits, merge commits, or a merge sitting above the range — rather than quietly rewriting topology you didn't select. Branch tip labels on the graph are also more accurate, and sessions with very long names no longer break the layout.

A new coat of clay, and simpler sign-in

Foreman's identity is now consistent everywhere: a new app icon, clay-orange accents, a refreshed dark default theme (your old theme choice is untouched), a tightened type scale across the app, and terminal colors that match whichever theme you run. Signing in to Claude also got simpler — Foreman now just uses your machine's own claude login or an API key, shows each CLI's login state as a badge, and no longer offers to store a pasted token.

---

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.

Schedule dialog: themed time & date pickers

The schedule dialog's time and date fields used the OS-native controls, whose light popup clashed with the dark app. They're now custom dropdowns that match the rest of the UI — hour and minute for daily/weekly, and month/day/year plus time for a one-off run — laid out to read as a sentence ("Every Monday at 09:00").

Git confirmations now match the app

Destructive git actions (discard, reset, force-push, cherry-pick, revert, checking out a commit or tag) asked for confirmation through the browser's native popup. They now use the same themed confirm dialog as the rest of the app, with the risky ones flagged in red.

No more phantom error flash when switching model or effort

Changing a running session's model, effort, or permission mode restarts the CLI under the hood. Doing two in quick succession (model then effort) could race the two restarts against each other, and the one that lost briefly flashed a red "Claude CLI exited before starting" error even though the session was fine. Those restarts are now serialized, and a restart we trigger on purpose is never mistaken for a real startup failure.

"Claude is thinking…" no longer gets stuck after a turn ends

Fixed a desync where the status badge correctly read "Idle" but the transcript kept showing a "Claude is thinking…" spinner forever. A late tool result from a background subagent could open a phantom turn that nothing ever closed; on top of the direct fix, the spinner now always clears once the session settles, so a dropped or out-of-order event can't leave it spinning either.

---

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.

Schedule dialog: themed time & date pickers

The schedule dialog's time and date fields used the OS-native controls, whose light popup clashed with the dark app. They're now custom dropdowns that match the rest of the UI — hour and minute for daily/weekly, and month/day/year plus time for a one-off run — laid out to read as a sentence ("Every Monday at 09:00").

Git confirmations now match the app

Destructive git actions (discard, reset, force-push, cherry-pick, revert, checking out a commit or tag) asked for confirmation through the browser's native popup. They now use the same themed confirm dialog as the rest of the app, with the risky ones flagged in red.

No more phantom error flash when switching model or effort

Changing a running session's model, effort, or permission mode restarts the CLI under the hood. Doing two in quick succession (model then effort) could race the two restarts against each other, and the one that lost briefly flashed a red "Claude CLI exited before starting" error even though the session was fine. Those restarts are now serialized, and a restart we trigger on purpose is never mistaken for a real startup failure.

"Claude is thinking…" no longer gets stuck after a turn ends

Fixed a desync where the status badge correctly read "Idle" but the transcript kept showing a "Claude is thinking…" spinner forever. A late tool result from a background subagent could open a phantom turn that nothing ever closed; on top of the direct fix, the spinner now always clears once the session settles, so a dropped or out-of-order event can't leave it spinning either.

---

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.

AI review on the session diff

Hand the diff to a second agent before you read it yourself. Its findings come back as comments on the exact lines they refer to — the same comments you'd write by hand — so you edit the ones that need nuance, delete the ones you disagree with, and send the rest straight back to the agent that wrote the code. One batch, one turn.

• Your model, your effort. Pick both per review, independent of the session's own — a review is a different job from the work being reviewed.
• Choose what gets reviewed. Deselect the files you don't care about, then re-review just the one you fixed. The whole selection still goes in a single pass, so cross-file issues are still found.
• No praise, no summaries. The review only reports things worth changing. If nothing is, it says so.
• Findings it can't pin to a line are shown, not dropped — so a review is never quietly lossy.
• Cancel actually stops it. Started a review on the wrong files? Cancel kills the agent on the spot rather than letting it finish in the background on your bill.

Merge conflicts, resolved in the app

A conflicted merge, rebase, cherry-pick, or revert now shows every conflicted file with the state it's in — and lets you finish it without reaching for the terminal.

• Take a whole side per file, or open a file and go hunk by hunk, keeping either side, both, or an edit you write yourself.
• Sides are labelled Current and Incoming, with the branch or commit git itself named — including during a rebase, where "ours" means the branch you're rebasing onto, not your work.
• Continue the operation once everything is settled, right next to the Abort that was already there.

Scheduled tasks

Foreman can now run an agent for you on a schedule — once at a set time, or on a repeat (every day, or, say, every Monday at 09:00). A scheduled task is just a normal prompt plus a when: point it at a project, write the prompt, pick a cadence, and Foreman launches the session for you when the time comes.

• Runs even when you're away. If a run's time passes while Foreman is closed, it fires the next time you open the app — and is marked "ran late" so you know it caught up.
• Isolated output you review. Turn on "Run in a worktree" and each run lands on its own fresh branch — review the diff and merge it yourself. Nothing touches your main checkout.
• Model & effort per schedule. Choose the model and reasoning effort each schedule runs with, just like a normal session.
• Quiet by default. A run that finds nothing to do finishes silently. You only get a notification when there's an actual change to review — or when a run failed, with the reason (for example, an integration that needs re-authenticating before it can run unattended).
• Run history. Each schedule keeps its recent runs, so you can see how they went and jump back into any of them.

Perfect for a weekly "what's new in the Claude CLI, and should Foreman adopt it?" scan, a nightly repo-health check, or a recurring pass over your issue tracker.

Git & pull-request panel polish

Cleaner layout for the Git and PR panels.

Commit failures no longer dump a wall of text

A failed commit (a lint-staged hook rejecting your changes, for example) now shows a small error card with just the first line, and a Details button that opens the full output — in both the Session Diff panel and the Git tab. No more scrolling past a full raw hook log to find your commit button again.

A connecting laptop now tells you why it dropped

When a laptop you're adding over your account keeps landing on "Disconnected," the card now shows the actual reason — the other machine is offline, isn't sharing, or didn't answer in time — instead of a bare red dot with nowhere to go.

Fixed two related bugs: reconnecting a laptop that isn't currently shared no longer gets stuck on "Connecting…" forever, and a laptop whose sharing was turned off mid-session is now detected right away instead of still showing "Connected" (potentially even after reloading the app) until a background watchdog eventually catches it.

Reconnect the relay without signing out

The Foreman account menu now shows whether this machine's relay link is live, with a Reconnect button. If another laptop can't reach a machine that looks shared, one click rebuilds the connection — no more signing out and back in to unstick it.

More reliable permission prompts

Fixed a case where a session's permission prompt could fail to initialize, and made plan mode stick correctly when a run auto-continues.

Context meter cap corrects itself

The context-usage cap ("Xk / Yk ctx") could get stuck on a stale, too-low number learned earlier in a session's life, even while the popover's own live breakdown showed the real, bigger window right below it. Opening the popover now feeds that same fresh reading back into the cap, so it self-corrects immediately instead of staying wrong until a lucky compaction fixes 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.

AI review on the session diff

Hand the diff to a second agent before you read it yourself. Its findings come back as comments on the exact lines they refer to — the same comments you'd write by hand — so you edit the ones that need nuance, delete the ones you disagree with, and send the rest straight back to the agent that wrote the code. One batch, one turn.

• Your model, your effort. Pick both per review, independent of the session's own — a review is a different job from the work being reviewed.
• Choose what gets reviewed. Deselect the files you don't care about, then re-review just the one you fixed. The whole selection still goes in a single pass, so cross-file issues are still found.
• No praise, no summaries. The review only reports things worth changing. If nothing is, it says so.
• Findings it can't pin to a line are shown, not dropped — so a review is never quietly lossy.
• Cancel actually stops it. Started a review on the wrong files? Cancel kills the agent on the spot rather than letting it finish in the background on your bill.

Merge conflicts, resolved in the app

A conflicted merge, rebase, cherry-pick, or revert now shows every conflicted file with the state it's in — and lets you finish it without reaching for the terminal.

• Take a whole side per file, or open a file and go hunk by hunk, keeping either side, both, or an edit you write yourself.
• Sides are labelled Current and Incoming, with the branch or commit git itself named — including during a rebase, where "ours" means the branch you're rebasing onto, not your work.
• Continue the operation once everything is settled, right next to the Abort that was already there.

Scheduled tasks

Foreman can now run an agent for you on a schedule — once at a set time, or on a repeat (every day, or, say, every Monday at 09:00). A scheduled task is just a normal prompt plus a when: point it at a project, write the prompt, pick a cadence, and Foreman launches the session for you when the time comes.

• Runs even when you're away. If a run's time passes while Foreman is closed, it fires the next time you open the app — and is marked "ran late" so you know it caught up.
• Isolated output you review. Turn on "Run in a worktree" and each run lands on its own fresh branch — review the diff and merge it yourself. Nothing touches your main checkout.
• Model & effort per schedule. Choose the model and reasoning effort each schedule runs with, just like a normal session.
• Quiet by default. A run that finds nothing to do finishes silently. You only get a notification when there's an actual change to review — or when a run failed, with the reason (for example, an integration that needs re-authenticating before it can run unattended).
• Run history. Each schedule keeps its recent runs, so you can see how they went and jump back into any of them.

Perfect for a weekly "what's new in the Claude CLI, and should Foreman adopt it?" scan, a nightly repo-health check, or a recurring pass over your issue tracker.

Git & pull-request panel polish

Cleaner layout for the Git and PR panels.

More reliable permission prompts

Fixed a case where a session's permission prompt could fail to initialize, and made plan mode stick correctly when a run auto-continues.

---

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.

Scheduled tasks

Foreman can now run an agent for you on a schedule — once at a set time, or on a repeat (every day, or, say, every Monday at 09:00). A scheduled task is just a normal prompt plus a when: point it at a project, write the prompt, pick a cadence, and Foreman launches the session for you when the time comes.

• Runs even when you're away. If a run's time passes while Foreman is closed, it fires the next time you open the app — and is marked "ran late" so you know it caught up.
• Isolated output you review. Turn on "Run in a worktree" and each run lands on its own fresh branch — review the diff and merge it yourself. Nothing touches your main checkout.
• Model & effort per schedule. Choose the model and reasoning effort each schedule runs with, just like a normal session.
• Quiet by default. A run that finds nothing to do finishes silently. You only get a notification when there's an actual change to review — or when a run failed, with the reason (for example, an integration that needs re-authenticating before it can run unattended).
• Run history. Each schedule keeps its recent runs, so you can see how they went and jump back into any of them.

Perfect for a weekly "what's new in the Claude CLI, and should Foreman adopt it?" scan, a nightly repo-health check, or a recurring pass over your issue tracker.

Git & pull-request panel polish

Cleaner layout for the Git and PR panels.

More reliable permission prompts

Fixed a case where a session's permission prompt could fail to initialize, and made plan mode stick correctly when a run auto-continues.

---

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.

Pull requests on the Git page

The Git page now lists the repo's recent pull requests — state, draft flag, and review decision at a glance, with the PR belonging to your checked-out branch highlighted. Click any row to open it on GitHub.

Agent CLI panel cleanup

• Installing Codex no longer floods the panel with the package manager's full output — you get a one-line "Installed." and the version updates in place.
• New refresh button (↻) on each agent row — re-check the installed version and sign-in status any time, and after a sign-in Foreman now keeps checking for a full minute instead of once.

Sessions always launch the right binary

Foreman now starts sessions with the exact same binary the Agent CLIs panel detected, instead of trusting the shell's PATH. Fixes the case where the panel said "installed" but new sessions failed with "not found" — most likely on SSH machines.

Stale companion daemon warning

If a shared laptop's Foreman build is older than yours, its row in the Fleet sidebar now shows a "daemon outdated" badge — an out-of-date daemon can silently miss newer features, so now it tells you instead.

What's new polish

These notes no longer show their own authoring instructions at the top. Very meta.

---

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 CLI support

Foreman now manages Codex alongside Claude Code: install, login, version checks, and updates — all from the UI, per machine.

What's new in-app

After an update, Foreman shows you these notes once, right in the app — you're probably reading them there now.

Fixes

• Parallel permission requests no longer overwrite each other — they queue and get answered in order.
• The update banner no longer gets stuck in an error state.

---

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.

Automated build of Foreman — desktop controller for Claude Code agents (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.

Automated build of Foreman — desktop controller for Claude Code agents (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.

Automated build of Foreman — desktop controller for Claude Code agents (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.