Beacon v0.6.1

Shift+Enter breaks the line, @ and # can be typed on any keyboard, and updating on Windows no longer leaves the old daemon behind.

• Shift+Enter starts a new line in the Claude and Codex panels instead of sending a prompt you had not finished. A terminal cannot tell it from Enter, so Beacon now sends each agent the newline it actually reads. A shell is left alone, where Enter running the command is the point — and so is an input method in the middle of composing.
• @, #, brackets and braces can be typed again on Spanish and most other non-US Mac keyboards. They live on the Option key there, and the terminal was treating Option as Meta, so each one arrived as an escape sequence and nothing appeared. Option with an arrow, Backspace or Enter still does what it did.
• Updating on Windows no longer leaves the old session daemon in place. A running program cannot be overwritten there, and the daemon nearly always is running, so the 0.6.0 update could leave a 0.5 daemon beside a 0.6 window and end in "could not reach the session daemon". The installer now moves it aside so the new one can take its place; and if an old daemon is ever found again, Beacon says so and what fixes it. Contributed by jimy-k4.
• Without Beacon's hooks installed, reopening a conversation works. Beacon only learned that Claude Code had saved a conversation from the hooks, so without them every start after the first asked for it as new and Claude Code refused with "Session ID … is already in use". Beacon now looks for the conversation on disk. Contributed by jimy-k4.
• The dimmer text in the dark theme can be read in daylight. The quietest two levels — panel headers, the status bar, placeholders — were well below what body text needs once the screen catches some sun; all four levels are now brighter and evenly spaced, so the order between them stays. Contributed by jimy-k4.

Beacon v0.6.0

Beacon runs on Windows, and Codex runs beside Claude Code — in its own panel, its own conversation, and if you want it, its own checkout.

• Beacon runs on Windows 10 and 11. The whole of it: the session daemon, real terminals, the clip drawer, the hooks that tell a tab what Claude is doing. The window draws its own caption buttons and the installer comes as both an NSIS setup and an MSI. Contributed by jimy-k4, built and used on a real Windows machine, and now checked on every push alongside macOS.
• Codex is a second agent, not a replacement. It gets a panel of its own (⌘⇧O), its own conversations, and can run at the same time as Claude Code in the same project. It starts hidden, so nothing moves until you ask for it. Settings → Codex installs the small plugin that lets it report what it is doing; Codex will not run a hook it has not been shown, so there is one step left to you afterwards, and that screen says so.
• Every session can reach the programs you installed. Started from the Dock, Beacon had nothing on its PATH but the four system directories, and an agent inherits that — so node, cargo, anything a version manager put there, and any hook that needed them, were simply not found. Sessions now run with the PATH your login shell sets. A terminal panel never showed this, because a shell works its own out.
• A project can give each agent a checkout of its own. Two agents editing the same files means the second one to save wins; turning this on puts each in a git worktree instead, on its own branch, and leaves the project directory to you. Off unless you ask for it. The git panel can be pointed at any of them to read what an agent has done — the file tree and the editor always stay on your own copy, so saving always writes where you think it does.
• When the session daemon will not start, it says why. It had been explaining itself perfectly well to a stream pointed at nowhere, while every panel showed the one thing you could already see.
• An agent installed with npm starts. Those are not binaries but scripts that need their interpreter, and Beacon found them and could not run them — which looks exactly like not having installed them.
• The file tree says what each thing is before saying what it is called. A hundred or so endings and the names you know at a glance — package.json is not merely some JSON, and package-lock.json is not merely some package.json. Anything unrecognised gets a plain file, never a blank.
• Reopening no longer shows a panel of shredded text. A terminal was being built at eighty columns and then filled with output that had been wrapped for a different width; it is now built at the width that output was written for. Pressing Resume used to be the way out of it.

Beacon v0.5.2

Resume works on a conversation you have not spoken in yet, the splitters move again, and files appear the moment something makes them.

• Resume no longer answers "No conversation found with session ID". Beacon treated starting a Claude as proof that a conversation existed, but Claude Code writes nothing until the first exchange — so a session you opened and never typed into left nothing to go back to, and asking to resume it replaced the panel with an error. Whether a conversation exists is now decided by something having been said in it.
• A fork you have not typed in yet keeps the history it was forked from. Looking at another conversation and coming back — or a daemon that had been replaced in between — used to start it as an empty conversation wearing the same name, with the history it was forked from silently gone.
• A missing MCP configuration no longer costs you the whole panel. Beacon writes that file once, into the temporary directory macOS sweeps every few days; when it was swept, Claude Code was handed a path to nothing and refused to start at all. It is written again when it is missing, and if it cannot be, the session starts without the clip drawer and says so rather than failing.
• The splitters work again once a panel is hidden. Hiding one changes the shape of the layout, and the splitters were still reporting where they used to be — so a drag resized a split that was not on screen and the panels sat there, unmovable, however hard you pulled.
• Files appear in the tree as they are made. The tree re-read when the window regained focus, which never happens when the thing writing the files is the Claude in the panel beside it, so a new file stayed invisible until you clicked away and back or pressed refresh.

Beacon v0.5.1

Updating no longer greets you with a window that thinks it is offline.

• The first launch after an update stopped saying the daemon went away. An update that moves the protocol finds the previous version's daemon still running and has to swap it, which is expected — but the swap was announced as a failure, and every panel in a window that had not finished opening said so. Nothing took it back, because the notice that clears it only follows a real reconnection.
• A connection that has been replaced can no longer take its replacement with it. A reader notices its stream ended some time after it did, by which point another connection may already be in place; it used to pull that one down too, and one planned swap became a window that stayed offline until it was restarted.
• Beacon no longer starts two daemons at once. The window opening and the reconnect loop could each start one, which left it attached twice and hearing every event two times.
• Not finding the claude command is no longer remembered. Where Claude Code lives comes from your login shell, which is given four seconds to answer and can miss that on a machine that is briefly busy — right after an update, say. The daemon outlives the window, so one missed answer used to mean every session for the rest of the day was told Claude Code was not installed.

Beacon v0.5.0

A project holds several named Claude conversations, and you can tell which one you are in.

• Claude sessions have names and come back. A project is no longer one nameless conversation that grows until most of it is work nobody is doing any more: start a workstream for the thing you are about to do, name it, and come back to it later from the chip in the panel header. Beacon gives each conversation its id when it starts it, so this needs a recent Claude Code — where the flags are missing, the chip is not there and nothing else changes.
• Restarting Claude no longer throws the conversation away. The header button says Resume, and it does: the process starts again and carries on where it was. Starting clean is a deliberate act now, with a name attached.
• Beacon refuses to open one conversation in two Claudes. It asks Claude Code what is running rather than assuming, and offers to fork instead — which keeps the history and leaves the original where it is.
• The usage panel says more, because Claude Code does. How full the context is, in bands rather than a bare number; whether the prompt cache is warm, and what a cold one would cost to rebuild; the model, the effort, the week and the five-hour window. When Claude Code says nothing about something, Beacon says nothing about it either.
• One piece of advice at a time, and never acted on. A large context whose cache has gone cold is worth knowing about at the moment it starts costing something. What to do about it is yours: Beacon does not compact, does not clear, and does not start a session on your behalf.
• Three small agents, offered to the sessions Beacon starts. One searches the repository, one runs tests, one reviews a finished change with fresh eyes — each there to keep a large pile of output out of the conversation doing the work. They are handed to Claude Code per session, so nothing is written into your projects and the agents you already have are untouched. There is a switch in Settings, because their descriptions cost context whether they are used or not.
• The header says when work has been delegated. From outside, a session that has handed a large search to a subagent looks exactly like one that has gone quiet.
• Git handles a conflicted file as one. It is shown separately, kept out of stage and unstage — which used to mark it resolved with its markers still in place — and staging everything refuses to sweep it up. A commit is blocked while conflicts are unresolved, and says so. Every git command now has a deadline, so nothing git waits for can take the panel with it.
• Saving is atomic and refuses to overwrite a file that moved underneath it, which in this application usually means Claude. A clean buffer reloads; a dirty one asks, because one choice loses your typing and the other loses Claude's.
• Quitting with unsaved work asks first. The file tree can show dotfiles, and can move a file somewhere else. Notifications go through macOS directly, so they arrive when Beacon is not the application in front.
• The hooks need installing again for this: open Settings and reinstall them. Beacon now listens for subagents starting and finishing, which is two events it did not register before.

Beacon v0.4.0

Claude can hand you something worth keeping, and it survives the trip to the clipboard.

• Claude can file a clip from inside a session — a command, an address, the body of an email — and it lands in a drawer beside the session with a copy button. Beacon gives each session a small tool of its own for this, so nothing has to be hunted out of a scrolling transcript and selected by hand.
• The drawer keeps a clip book per project: it survives closing Beacon, and one button clears the lot when a clip has served its purpose.
• Accents and dashes reach the clipboard intact. Started from the Dock, Beacon inherited no locale at all, and pbcopy reads a missing locale as Mac OS Roman — so an em dash copied from inside a session arrived as —. Sessions are given a UTF-8 locale now when nothing else has set one.

Beacon v0.3.0

A tab knows Claude is there before you have said anything to it.

• Beacon hears about a Claude session when it starts, not when you send it its first message. Until now the first hook of a session was the one that submits a prompt, so a tab you had just opened said nothing about the Claude sitting in it.
• Resuming or clearing a session takes back what the tab was still claiming. "Waiting for you" and "finished" are never expired on a timer — both can honestly last hours — so a session left at a permission prompt and then resumed used to ask for an answer nobody owed it any more.
• The hooks need installing again for this: open Settings and reinstall them, or Beacon will show them as stale until you do.

Beacon v0.1.0

The first build worth handing to somebody else.

• Workspaces group projects, each with its own colour and icon, so you know where you are before reading anything.
• A real claude session and a real shell per project, in their own PTYs. Beacon runs the CLI you already use rather than reimplementing it.
• Sessions outlive the window: close Beacon and they keep running, open it again and it reattaches to them.
• Layouts are a tree of splits with four presets, and every divider is draggable.
• A file tree with an editor, a .env view that keeps values hidden until asked, and git status, diff, stage and commit.
• Command palette on ⌘K, quick open on ⌘P, and every shortcut is editable.
• Tabs say what Claude is doing — working, finished, or waiting for you — reported by Claude Code rather than guessed from output.
• The title bar shows how much of the five-hour allowance is left and how full each project's context is.
• Light and dark themes, how much of the desktop shows through the window, and whether what shows through is frosted.