v0.9.2

CodeWhale for VS Code v0.9.2

Install: download brotherwhale-vscode-0.9.2.vsix from the assets below, then:

code --install-extension brotherwhale-vscode-0.9.2.vsix --force

SHA-256 checksums are in checksums.txt.

---

Everything here works on engine v0.10.2 or newer. One reading needs a Codewhale build newer than any tagged engine release: the cost and context figures move while a turn runs only once the engine emits a priced usage receipt, and until then they settle when the turn ends, as before.

New Features

• The status bar says how full the context window is — Context 42% sits beside the session cost and token counts, with the exact token readings on hover. From 80% it turns emphatic — the same threshold the terminal UI uses — because a nearly full window is what decides whether the next turn still fits. A route whose window cannot be bounded shows no reading rather than a zero it cannot prove.

• Cost and context follow a turn while it runs — The status bar used to sit still for a whole turn and then jump at the end. It now rises with each model call. Coming back to a conversation that is still working shows what it has spent so far, rather than the settled total it had when you left.

• Guidance you sent mid-turn says whether the model actually read it — When a turn ended before the engine took your guidance, the words stay where you typed them and the badge reads not delivered, so a turn that finished early cannot look like the model was told something it never saw.

• A reopened conversation shows its guidance again — Saved conversations mark the prompts that went into a running turn, read from the engine's own turn records rather than guessed from position, so a compacted history no longer badges its ordinary questions.

Bug Fixes

• The engine's own notes stay out of your conversation — Opening a saved conversation printed the bookkeeping the engine writes for the model: the date, workspace and permission lines above every prompt, a compaction's handoff note as an enormous message nobody had typed, and runtime notices attributed to you. Those blocks are recognised and kept out, while a message that merely quotes one stays yours.

• Long questions reload whole, and a condensed answer no longer repeats the question — A reopened question was cut off at 280 characters, and a turn whose answer had been condensed into a summary printed its own question back underneath as the answer.

• Copying a reply copies it — Copying an answer out of the conversation put the caret in the input box and copied nothing: VS Code 1.143 restores the last focused element before it replays a copy, and in this panel that element is the composer. The conversation now takes focus on a press inside it, which leaves your selection alone; buttons, links and the focusable tool blocks keep their own focus, and taking focus draws no ring.

• A paste that carries both words and a picture keeps the words — Copying a region of a page, a card or a document often puts a picture of it on the clipboard beside the text, and the picture won. Words now paste as text, while screenshots and images copied on their own still arrive as images.

Upstream TUI PRs

• Codewhale#7074 — merged 2026-10-25, not yet in any engine release. feat(runtime): show a turn's cost and context while it runs — the usage receipt each model call emits now names that call's own price and the prompt size the provider billed, which is what lets the cost and context chips move during a turn instead of settling at the end.

v0.9.1

CodeWhale for VS Code v0.9.1

Install: download brotherwhale-vscode-0.9.1.vsix from the assets below, then:

code --install-extension brotherwhale-vscode-0.9.1.vsix --force

SHA-256 checksums are in checksums.txt.

---

Everything here works on engine v0.10.0 or newer. The review commands read the engine's Context Lens routes, which arrive with that release — the floor this extension already documents — and on anything older they say the routes are missing rather than reporting that you have nothing to review; /memory show, search and get are unaffected.

New Features

• The memory the model proposes is now yours to decide on — Codewhale never writes a memory by itself: a note the model offers arrives as a candidate and waits for you. /memory pending lists what is waiting, and /memory approve <id>, reject <id> and forget <id> decide it — approving is what puts a note into what the model is given from then on, while declining leaves it stored and out of context. A prefix that could mean two entries is refused rather than guessed, because the wrong guess here is an approval; and no decision rewrites what a model has already been told, so each command says it applies from then on. /memory show, search and get keep listing what is already kept, which is why a candidate never appeared there.

v0.9.0

CodeWhale for VS Code v0.9.0

Install: download brotherwhale-vscode-0.9.0.vsix from the assets below, then:

code --install-extension brotherwhale-vscode-0.9.0.vsix --force

SHA-256 checksums are in checksums.txt.

---

Everything here works on engine v0.10.0 or newer. The MCP panel needs the management routes that release introduced — the layer each server belongs to, the configuration revision every edit presents, and the review of the servers other tools on this machine left behind; the rest is client-side and lights up on v0.10.1.

New Features

• MCP servers are managed from the chat window — The Activity tab has an MCP panel: every server the engine knows about, grouped by where it is configured (project, global, plugin), with its live connection state. Turn one on or off, connect it and see the tools it offers, remove it, or add a server from a form — the suggested ones (Hugging Face, GitHub, Chrome DevTools, Playwright, container-use) fill it in for you. Review imports lists the servers other tools on this machine already have, so you can approve or decline them one at a time; nothing is imported until you say so, and an imported server arrives switched off. The engine owns the config file and is its only writer: entries belonging to a project or plugin are shown but marked as managed elsewhere, and an edit made in another window is refused rather than overwritten. /mcp opens the panel, /mcp list prints the servers in the conversation, and the copy that used to send you to VS Code settings — where nothing about MCP could be edited — is gone.

Bug Fixes

• Diff in a session opened from the Sessions rail opens a diff again — Clicking Diff there opened the file instead, as if you had pressed Open.

• A change's +/− counts read the same in a saved session as in its thread — The same edit used to report different numbers depending on where you read it.

• A saved session shows the diffs its thread shows — Rows whose patch could not be rebuilt showed their size with no Diff next to them at all. A session the engine still holds now takes those patches from the engine's own records for the calls that made them; anything left over says why on hover instead of the button quietly going missing.

• A conversation that contains a picture opens again from the Sessions rail — It failed with "Failed to load session" and cleared the view. The same conversation opened fine as a thread.

• A dialog no longer closes when your press slips off it — Holding the mouse down inside one of the pop-ups (adding an MCP server, a task draft, a Fleet run, the route-change question) and releasing it after the pointer left the panel closed the dialog and threw away whatever had been typed. A click is reported against the nearest common ancestor of where the press began and where it was released, so a press that left the panel and came up over the dimmed area — a drag that slipped past the edge, a text selection pulled past the field, a release outside the window — looked exactly like a click on the backdrop. The press is checked too now, so only a gesture that both began and ended on the backdrop dismisses.

• A tool call reads the same while it runs as it does after a reload — A row drawn live used the raw engine name, so an MCP call showed mcp__github__search_code as it ran and "github / search code" once the conversation came back from history — the same call, two names, on every kind of tool. Both paths use the same label now: a call reads "Run command" or "github / search code" throughout, and the MCP label spaces each part properly, so the tool half no longer reads search_code beside a spaced server name.

• Guidance sent mid-turn carries your pictures — While a turn is running the composer guides that turn instead of starting a new one, and an image attached to the box was left behind: the words went to the model and the picture stayed in the composer, unmentioned. A guided message now carries what is attached, exactly as a normal send does — a screenshot reaches the model as a picture — and a guidance the engine refuses hands back both the words and the picture. An image with no text at all is a complete steer too; the guide button used to stay dim over it.

v0.8.6

CodeWhale for VS Code v0.8.6

Install: download brotherwhale-vscode-0.8.6.vsix from the assets below, then:

code --install-extension brotherwhale-vscode-0.8.6.vsix --force

SHA-256 checksums are in checksums.txt.

---

Everything here works on engine v0.10.1 except the workspace-trust banner, whose engine half is still open upstream — on an engine that predates the route the banner simply stays hidden, and the rest of this release is unaffected.

New Features

• An untrusted workspace says what it is skipping, and takes one click to trust — Without project trust the engine quietly leaves out the folder's skills, commands, hooks, MCP servers and project context; a banner above the conversation now names what is being skipped and records the decision in one click, through the engine rather than by editing your config, and a grant the engine did not actually record is reported as a failure. Trust starts from your next turn — except for project MCP servers, which only connect when a session begins, so the confirmation offers a restart.

Bug Fixes

• A window VS Code does not trust says why, and recovers on its own — There the engine cannot start at all, and the sidebar used to come up dead with only "failed to connect", naming neither the cause nor the way out. It now offers the action that opens VS Code's Workspace Trust editor and re-binds the panel as soon as you grant trust — once per restricted stretch, rather than a toast on every retry.

• Tool calls stay on screen after a reload — Reloading the window or restarting the engine rebuilt the conversation with every tool call missing, and a session that only ran commands came back empty. Both ways the engine records a finished call are read now, so a call returns with its arguments, its result, and the change cards a command's own writes hang off.

• A workspace can start again after another workspace's engine dies — The engine keeps a single record of which process holds it, shared by every workspace, and an engine killed outright — a window reload, a crash — leaves that record behind; a window on a different workspace then refused to start over it until the file was deleted by hand. The extension now clears such a record on macOS and Linux as well as Windows, and only when the process it names is provably gone — a record naming a running CodeWhale, yours or another window's, is left exactly where it is — and the startup error names the file to delete, whatever platform you are on.

Upstream TUI PRs

• Codewhale#6959 — open, unmerged. feat(api): read and write a workspace's project trust over the Runtime API — the engine half of the trust banner: a route reading a workspace's trust verdict on /v1/workspace/status and one recording the decision. Until an engine carries it the banner stays hidden, and everything else in this release works without it.

v0.8.5

CodeWhale for VS Code v0.8.5

Install: download brotherwhale-vscode-0.8.5.vsix from the assets below, then:

code --install-extension brotherwhale-vscode-0.8.5.vsix --force

SHA-256 checksums are in checksums.txt.

---

Everything here is client-side and works on engine v0.10.1; none of it waits on an engine build.

New Features

• The Skills panel groups by where a skill lives, filters as you type, and folds — The panel listed your skills and the shipped ones apart, which left its most common question unanswered: is this one mine and global, or does it belong to the project I am in? It groups by scope now — Project (the skill's SKILL.md sits inside the workspace) and Global — with the engine's own bundled set kept as a third group of its own, so Global means what you installed globally rather than everything outside the project. A box above the list filters by name and description as you type, inside the panel and without asking the engine for anything. Each group folds from its heading, and the folds are remembered the way the panel's other layout choices are: a group you keep shut stays shut when the window is reopened. Client-side entirely. The engine's listing carries each skill's real path but no scope, so the panel splits on containment against the workspace the engine itself reports — the same workspace the listing was produced from; a skill with no path, or a workspace that cannot be named, is grouped as global rather than guessed into the project. Bundled wins over scope in that check, so a bundled copy sitting in the global directory is never reported as something you installed.

• A file picked in the Explorer can be attached to the conversation — Right-click a file in the Explorer and choose CodeWhale: Attach to Conversation: the chat comes into view and the file lands in the composer as an attachment, exactly as if it had been dropped there (images still get their thumbnail and their up-front validation, everything else rides the same @path mention). It is a command rather than a drop because VS Code never hands an in-window drag to a webview: for a drag that began in its own DOM — an Explorer row, an editor tab — pointer events are held off the webview element for the whole drag (that is what makes a file dropped over a webview open in an editor group), so the chat sees no dragover, no drop, and not even the drag-over highlight. Measured, not assumed: with the drop listeners installed and logging to the console, a Shift-held drag from the tree produced no event in the webview and no message in the extension host, while the same file dragged in from Finder attached normally. Only a drag that starts outside this window reaches the composer, and nothing about that has changed.

Bug Fixes

• A dropped file the webview cannot read says so — Chromium can hand the webview a File whose bytes it will not serve — the drag's source is gone, or the OS declines the read — and that failure arrives asynchronously, on a promise the drop handler cannot see. It was reported as nothing at all, which is indistinguishable from the drop never arriving: the composer stayed empty and said nothing. It posts an error now, named The dropped file's contents could not be read.

• A ticked “always allow” survives the rail redrawing under it — Ticking the remember box on a rail card and then taking a moment before clicking Allow could lose the tick: the rail is rebuilt on every thread-list publish, each rebuild makes a fresh box, and the choice lived only in the DOM. It is the sweep's own repaint that made this likely, since a waiting thread now redraws the rail about every 30 seconds. The tick is kept with the card and put back on each rebuild.

• A waiting background thread reaches the rail even when nothing is watching it — The Threads rail showed a waiting thread once and then went quiet: later approvals and questions raised no count on the card and nothing on the toolbar's Agent label, and the request only appeared if you opened that thread. The background sweep that exists to find attention nothing is watching was doing its job — it fetched the summary and armed a watch — but it published nothing, on the assumption that the watch it armed would cover it. It cannot: a watch is opened at the thread's live edge, so a request that was already pending when the watch opened is history which that stream never replays. The two halves together left such a request invisible to the rail forever. A sweep that finds someone waiting now paints the rail (and, because a sweep skips the branch-line fetch, fetches those rows' session ids first so painting it does not strip the rail's fork lines); a sweep that finds nobody waiting still leaves the rail alone, so the list is not rebuilt under the pointer every 30 seconds for no reason.

• Background attention is back on the surfaces you already read — A thread waiting on your approval or input shows it on its own rail card (grouped under Needs you) and in the toolbar's Agent label, which names the longest-waiting thread and counts the pending items. The VS Code notification this shipped with is gone, and with it the brotherwhale.backgroundThreadNotifications setting — a popup is not where a queue belongs, and the two surfaces it duplicated are the ones that stay in view. They react immediately now: the watch on that thread delivers the request, and the rail is repainted from it in the same breath.

• “Always allow” no longer leaves a turn stuck on an approval — Ticking the remember box on an approval and allowing recorded the decision in the engine as a session grant for that tool and call family, but this client still mirrored the behaviour that predated it: it flipped its own copy of the thread to Full Access. Those two had drifted apart. Full Access means “never ask again” to anything that reads the thread, and one of those readers is the very guard that decides whether to show you an approval — so the client stopped drawing the dialog while the engine kept prompting for every call the grant did not cover, and the turn sat there with nothing to click until you reopened the thread and its pending approvals were read back from the engine. The mirror is gone: a grant is the engine's own state, it never moves the posture (the engine is explicit that a mid-turn posture change used to fail the very call it was approving), so the thread stays on Ask and later requests reach you again. A grant also covers less than its name suggests — the tool and a call family for that conversation, so a different command still asks — and the checkbox now says so (“Always allow calls like this in this conversation”) instead of promising the whole thread.

• A background thread waiting on an approval says so now — Under the Ask posture a background thread — a goal you started on a thread of its own, a task, a conversation you switched away from — could block on a tool approval with nothing to show for it: no addition to the conversation, no rail badge, and the VS Code notice left to the 30-second discovery sweep and the summary fetch behind it, so it arrived far too late or not at all. The request surfaced reliably only by opening that thread, because opening it re-reads the thread's pending approvals while the live watch was dead. A watch opened for a thread this client had not watched before asked for since_seq=Number.MAX_SAFE_INTEGER, as a way of saying “skip the replay, deliver live events only” — and the runtime does not work that way. It delivers seq > since_seq, and the cursor a stream opens with is the same one its live pump continues from, so a cursor no event can exceed leaves a connection that opens, keeps alive, and is permanently silent, with no error anywhere to notice. Such a watch is now positioned at the thread's live edge instead (since_seq=0 with replay_limit=0, the runtime's own “send no tail, but put the cursor at the end”), which is what “from now on” actually means to the engine. Every path that armed one is corrected: a newly discovered background thread, a background goal's fresh thread, and any watch the client re-arms after a drop. This is a regression rather than a gap that was always there: the watch replaced an earlier periodic refresh of the thread summary, which had covered exactly these threads, and its own notification decision also moved onto a summary refresh — so the case the deleted refresh handled had nothing left behind it once the watch could not deliver. The approval, the turn completion and the goal update on such a thread now arrive as they happen, so the notice is immediate, the rail badge follows, and the finished turn is saved without waiting for a poll.

• An approval in the conversation marks the tool call it belongs to — The runtime names the call an approval gates as tool_call_id on approval.required; the client read call_id, which that payload does not carry, and fell through to the approval's own id — a key no map holds. The request was then attached to whichever tool call happened to be running rather than the one being gated, so on a turn with more than one call the card and the panel marked the wrong row. It now reads the correlator the runtime documents.

• The extension can start CodeWhale on Windows again — It looked for the engine in a handful of fixed places and then ran the bare name codewhale.exe. On Windows that name is usually a .cmd shim, which Windows will not start without a command interpreter, and a window opened before you installed CodeWhale keeps the PATH it started with — so startup failed with spawn codewhale.exe ENOENT while codewhale worked fine in a terminal. It now looks where CodeWhale actually installs on Windows, falls back to your PATH, and runs a shim the way the terminal would. macOS and Linux are unchanged: the same installs still resolve to the same binary.

• **Re...

v0.8.4

CodeWhale for VS Code v0.8.4

Install: download brotherwhale-vscode-0.8.4.vsix from the assets below, then:

code --install-extension brotherwhale-vscode-0.8.4.vsix --force

SHA-256 checksums are in checksums.txt.

---

Everything here is client-side except where an entry says otherwise — the engine halves, and which engine release carries them, are listed under Upstream TUI PRs at the end of this section.

New Features

• Anonymous usage counting, with a switch to turn it off — The engine can count how CodeWhale is used: your version, OS and CPU family, session length, and totals of turns, tool calls and approvals. Never your conversations, code, prompts or files, and only under a random ID kept on this machine and shared with your terminal sessions. It is on by default; set brotherwhale.telemetry to false to turn it off, which applies from the next engine start (CodeWhale: Restart Engine applies it now). The counting belongs to the engine, so what is collected follows its published contract rather than anything this GUI decides — and nothing interrupts you at startup to say so.

• Skills got a place in the panel, and /skill can finally run one — The Activity tab has a Skills section now: your skills and the shipped ones listed apart, a switch beside each, a box to install one from GitHub, and update / remove / trust / audit for the skills you own. And activating a skill works the way the terminal does — /skill <name> arms it for the next message, so the skill's instructions travel with that one message while the message on screen stays the one you typed; /skill <name> <task> sends the task straight away. A chip above the input shows what is armed and takes it back on click. This one is not client-only: the panel reads a skill's instructions over a runtime route that ships with the engine's skill lifecycle, and an engine without it says so instead of offering an activation that would fail.

Bug Fixes

• A sidebar the width of another window no longer pushes the conversation out of sight — The panel's width is remembered, and that record is shared by every project, so a panel you sized in a wide window came back in a narrower one at its full width: it took the whole row, left the conversation zero pixels wide, and put the drag handle on the far edge. The panel is bounded by the room it is in now — it keeps the width you chose while there is space for it, is pushed back as the view narrows (the sidebar edge or the window, immediately, without reopening it), and always leaves the conversation a column of its own. With the panel open on a modest view the toolbar's controls past the edge — mode, permission, the agent chip — used to be laid out beyond the viewport, unseen and unclickable, and the row wraps instead of clipping there now; the width a drag was stopped at is also what gets remembered, rather than the wider one the drag kept asking for.

• Folded Activity sections no longer draw their titles on top of each other — Fold Work, Changes, Fleet, Tasks and Agents away and open the Skills list, and those five headers were squeezed into a few pixels each — their titles stacked over one another into an unreadable smear. A folded section's floor was zero, so the shared column could shrink it below its own header; the floor is the header now, and when even the headers no longer fit the tab scrolls, which is what it already said it would do.

• The skills list stopped pointing at a command that did nothing — Listing skills told you to run /skills <name> for the detail of a built-in, but the command took no arguments and answered with the same list again, so the one hint on screen led back to where you already were. /skills <name> now shows that skill's own detail — what it is, whether it is on, how it can be invoked, any aliases, and where it lives — and /skills <prefix> narrows the list.

Known limitation

• This extension can run only one instance at a time — The engine's runtime ownership model, new in v0.10.1, allows one driving client per machine: a second VS Code window running this extension, or the extension alongside another CodeWhale client on the same machine, is refused instead of starting its own engine. The upstream fix — one control endpoint per runtime store, one driver per workspace so two engines never write one working tree — is Codewhale#6924, still open; until an engine carries it, keep to one window, and one CodeWhale client on the machine at a time.

Upstream TUI PRs

• Codewhale#6869 — merged 2026-10-06, released in engine v0.10.1. feat(runtime-api): serve a skill's body so a client can activate it — the engine half of the Skills panel's activation and detail view. On engine v0.10.0 the panel dims those two with the reason, while listing, toggling and the install / update / remove / trust / audit actions keep working there.

• 5166473 — in main, not yet in any tagged engine release. feat(telemetry): let an embedder declare the server's surface — the engine half of the switch's companion: until an engine carries it, sessions this extension starts are counted as an anonymous serve instead of naming the client they belong to, while the off-switch itself works on any engine.

• Codewhale#6924 — open, unmerged. feat(runtime): one control endpoint per runtime store, one driver per workspace — lifts the one-instance limit described under Known limitation above. Each runtime store derives its own control endpoint and each workspace admits one driver at a time, so one machine's CodeWhale clients — web, desktop, TUI and this extension — work side by side without two engines writing the same working tree.

v0.8.3

CodeWhale for VS Code v0.8.3

Install: download brotherwhale-vscode-0.8.3.vsix from the assets below, then:

code --install-extension brotherwhale-vscode-0.8.3.vsix --force

SHA-256 checksums are in checksums.txt.

---

Everything below is client-side and lights up on engine v0.10.0 the moment you install it — except where an entry names its engine half: moving an open conversation to another provider needs a Codewhale build newer than any tagged engine release, and a command's row in the Changes panel keeps only its paths until an engine carries the new call-change route. Both are listed with their status under Upstream TUI PRs at the end of this section.

New Features

• The Changes panel now lists what a command changed — A turn that edited its files by running something — a script, a sed, a build step — left the Changes panel with nothing to show for the work: the engine records a command's writes as a command execution, not as a file change, so a turn whose edits were all scripted read as a turn that changed nothing, and the panel answered with a sentence about what it could not see. A command's own writes now draw rows like any other change — New, Modified or Deleted, their own +/- counts, with Diff, Open and Revert on the card — while the conversation runs and again when you reopen it. The card carries a small mark that the record came from a command, because that record is a window of time rather than a cause: anything else writing the same workspace while the call ran is inside the difference, and a path the snapshots do not track — node_modules/, a .gitignore hit, a binary — cannot appear at all. The sentence the panel used to say about its own scope is gone with the limit it described.

• The provider you switch to can now take the conversation with it — Switching provider used to move only what the next conversation would start on: the one on screen stayed where it was created, and the only way to change that was to start a new conversation, giving up the history you were in the middle of. The runtime can move a conversation onto another route now, and with a conversation open the picker means that conversation — the chip already described its route rather than the picker's, and the choice now lands there too. It asks first, inside the panel: the move keeps the history but gives up the prefix that provider has cached of this conversation, so the next message goes to the new route whole — more expensive, and slower to start. Declining changes nothing at all, neither the conversation nor what new ones start on. With no conversation open, the picker still means what new conversations start on, which is all it can mean there. The same question guards /model on an open conversation — a provider caches each model's prefix separately, so switching the model re-sends the conversation just as changing the route does — and it is skipped when there is nothing to spend: no conversation open, or the model it already runs on. On an engine without the route, nothing is moved and the panel says so, rather than reporting a switch that did not happen. The engine half is a05a1c734 (feat(runtime): switch a thread's provider, or override it for one turn) in Codewhale main: no tagged engine release in this checkout carries it yet, while the panel's own dev build does.

Bug Fixes

• A long turn no longer makes the panel look finished — While the agent was doing something that takes a while — a build, a test run, a command that runs for minutes — the send button went back to a plain Send and the Guide this turn button left with it, so a conversation the agent was still answering read as ended; typing into the box brought the guide button back, which is how this was noticed. The panel was holding the turn against a five-minute clock rather than against the turn itself, so every turn that outlived five minutes gave up on its own. It goes by silence now instead of duration — a turn that keeps reporting stays marked as running however long it takes — and when a turn really has said nothing for five minutes the panel no longer decides for itself: it asks the engine whether that turn is still running, and keeps it when the answer is yes. The composer is handed back only when the engine says the turn is over, or when the engine cannot be reached to say anything at all.

• Every DeepSeek model is selectable on the DeepSeek route again — Picking deepseek-v4-pro (or deepseek-v4-flash, or deepseek-reasoner) answered “it belongs to concentrate”, leaving deepseek-flash as the only DeepSeek model the list would take. The panel treated any other provider's default model of the same name as proof the id belonged elsewhere, and the gateways that front DeepSeek ship the very same bare ids as their defaults — Concentrate's is deepseek-v4-pro — so the official route's own catalog was blocked by routes you had never configured. A route you cannot select no longer counts, and a model the route you are on is known to serve is never called foreign.

Upstream TUI PRs

• Codewhale#6817 — open, unmerged. feat(runtime-api): read what one tool call changed, from the snapshots around it — the engine half of "the Changes panel now lists what a command changed". The rows themselves come from what the engine already records, so a command's paths appear on any engine; the change kind, the line counts, the patch and the revert target that make a command's row an ordinary row need this route. Until an engine carries it, a command's row stops at the paths.

• a05a1c734 — in main, not yet in any tagged engine release. feat(runtime): switch a thread's provider, or override it for one turn — the engine half of "the provider you switch to can now take the conversation with it", pushed to main directly rather than through a PR. On an engine without it nothing is moved and the panel says so.

v0.8.2

CodeWhale for VS Code v0.8.2

Install: download brotherwhale-vscode-0.8.2.vsix from the assets below, then:

code --install-extension brotherwhale-vscode-0.8.2.vsix --force

SHA-256 checksums are in checksums.txt.

---

Client-side only; verified against engine v0.10.0.

Improvements

• A long conversation no longer makes the panel sluggish to resize — Dragging the edge of the conversation panel re-laid-out every message the conversation held — thousands of rows, each carrying rendered markdown and tool output — so the edge trailed behind the cursor while a short one dragged smoothly. Messages outside the viewport now skip that work, and a jump from the message rail still lands exactly on its row.

Bug Fixes

• A turn that failed now says why, instead of just stopping — When the model service refused a request — the quota was spent, the key was rejected, the network was down — the answer's bubble simply ended and the transcript said nothing more, so a conversation that had been cut off looked exactly like a model with nothing to say. The engine records the reason on the turn and as its own error record, and the panel now reports it: live, as an error line under the answer, and after reopening the conversation, as the same line in the same place. A turn you stopped yourself still ends quietly.

v0.8.1

CodeWhale for VS Code v0.8.1

Install: download brotherwhale-vscode-0.8.1.vsix from the assets below, then:

code --install-extension brotherwhale-vscode-0.8.1.vsix --force

SHA-256 checksums are in checksums.txt.

---

Client-side only; verified against engine v0.10.0.

Bug Fixes

• The input box remembers what you sent, even after a restart — Pressing ↑ to bring back an earlier prompt only worked within one session: restart the window (or reload the panel) and the list was empty, so a prompt you had spent time writing had to be retyped from memory. What you send is now kept per workspace on disk and handed back when the panel comes up, so ↑/↓ walk the same entries as before. Each workspace keeps its own list, it holds the same 200 entries as before, and slash commands are kept too.

• The chime only rings when something has finished — It could also be heard while nothing had: the cue was looked up relative to the directory the host process happened to run in, so running this extension's own tests played it, several times per run, on whoever ran them. The cue now comes only from the extension's own bundled file, by absolute path, and only if that file is really there — any other path is silence.

• The sidebar comes back the way you left it — Keeping the sidebar open lasted only until the window was reloaded: the next launch showed it shut again, and closing it was forgotten the same way, so a sidebar you actually work with had to be reopened every time. Whether it is open is now written down beside the width — the same way the Activity sections you hide are — and restored before the panel first paints, so a sidebar left open is never shown shut first. The 📋 toggle, the ✕ and Esc all record the choice; a window that has never made one keeps the old default and opens shut.

• A section you folded stays folded — Folding Work, Changes, Fleet, Tasks or Agents away lasted only until the next window too: every one of them came back open, so a tab you had arranged yourself had to be arranged again each time. Each section's fold is now remembered the same way the sections you hide are kept, in its own choice so the two cannot overwrite each other, and it is applied before the tab first paints — a section folded shut is never drawn open on the way to being folded.

v0.8.0

CodeWhale for VS Code v0.8.0

Install: download brotherwhale-vscode-0.8.0.vsix from the assets below, then:

code --install-extension brotherwhale-vscode-0.8.0.vsix --force

SHA-256 checksums are in checksums.txt.

---

Everything below is client-side, and all of it lights up on engine v0.10.0 the moment you install it — except the Branch row, which calls an engine route v0.10.0 does not have, so on v0.10.0 no Branch row is drawn at all. Verified end to end against an engine built from the branch that adds the route (Codewhale main at 8a835d7c4). The upstream PRs behind these features are listed with their status under Upstream TUI PRs at the end of this section.

New Features

• A finished turn is now something you can hear — Working in another window made the end of a turn easy to miss: nothing said so, and the answer was simply waiting whenever you looked back. A short chime now rings when a turn finishes — for the conversation you are reading, and for a thread still running in the background, which is the case you are most likely away for. A turn that failed or was interrupted stays silent, and turns finishing at the same moment are heard once rather than as a rattle. It is on by default; brotherwhale.completionSound turns it off.

• A branch now says which conversation it came from — Branching left two conversations carrying the same title with nothing to say which was cut from which: both take their title from the same first message, and the branch is newer, so it was listed first. In the Sessions rail a branch is now drawn nested under its source, indented and joined to it by a guide line, with a ↳ in front of its title and a Fork chip whose tooltip names the source and how much it held at the cut. A branch of a branch nests one level deeper, and a family sorts where its newest member sorts, so the two rows move together. The Threads rail cannot nest the same way — it groups threads by what they are doing, and a branch often sits in a different group from its source — so a branch says it inline instead: "Branched from …" directly under the title, naming the source thread when it is on the rail. Either way, a branch whose source is not in the list keeps its place and says so, rather than reading as an unrelated conversation.

• The Changes panel now says what it cannot list — Its rows come from the engine's file-change records, and only the file tools produce those: a file written by a shell command is recorded as a command execution, so a turn whose edits all came from a script read as a turn that changed nothing — the panel showed nothing for it, with no hint that anything had happened. A turn that ran shell commands is now listed with a line saying how many, and the panel itself says once, above the list, that it reports only the changes the file tools made. That holds whether the conversation is running or was opened from the Sessions rail. (Editing files with the file tools is still what makes a change reviewable row by row, with diff, locate and revert.)

• Undo and Retry now say they are working — Both used to go quiet for the few seconds they take: the click was answered by a still screen, with no sign that anything was happening. The status bar now carries the activity dot a running turn gets, the conversation's own buttons and the composer's send hold for the duration with the reason on hover, and everything is released on success or failure. Asking for one while another is still running says so rather than starting a second.

• A saved session can be opened as a live conversation — Browsing an old conversation from the Sessions rail used to be read-only: the turns could be read, but nothing could be done with them, and a branch needs turns. The toolbar now offers Continue in exactly that view — it opens the session as a live conversation without sending anything — after which every finished turn offers Branch. Same action the Undo and Retry buttons were already performing silently on a viewed session, now available on purpose.

• Branch a conversation from any of its answers — Every answer in a live conversation now ends with a small Branch row. Click it and a new conversation opens holding that turn and everything before it, while the turns after it stay where they were, in a conversation left exactly as it was: what you had asked next is already in the input box, ready to edit or replace. Branching at the newest answer keeps the whole conversation, so you can carry on in a copy. No files are rolled back — both conversations work in the same workspace. Creating a branch takes a moment, so the click is answered where it happened: the row says it is working, the status bar keeps the same activity dot a running turn gets, and the composer holds its send until the branch lands — you can keep typing, and your text is still there (and sendable) the instant it does. Undo, Retry, New Thread and Compact hold for the same few seconds, because they act on the conversation that is being replaced; a second click cannot start a second branch. This needs an engine that has POST /v1/threads/{id}/fork-at-turn (a Codewhale build newer than v0.10.0); on an older engine the row is not offered at all, because the only fork those engines can do is of the last turn — which would cut somewhere other than the turn you clicked.

• The Activity tab now shows only the sections you want — Work, Changes, Fleet, Tasks and Agents used to take their slots whether or not you ever looked at them. A ⚙ beside the Activity hint opens a checklist of all five: untick one and it leaves the tab, tick it back and it returns, and the choice is still in place the next time you open the panel. Hiding is not the same as folding — a folded section keeps the header you click to reopen it, a hidden one leaves nothing behind — which is why that checklist always lists every section, hidden ones included, and stays where it is even when nothing else is left showing.

• The Activity sections now share the height the panel has — Work, Changes, Fleet, Tasks and Agents each used to stop at a fixed height, so folding one left everything it freed sitting empty at the bottom of the tab while a long list stayed in a small box. The open sections now share whatever the tab has: fold one and the others grow as it closes, hide one and they take the space at once, and a section with more to show gets more of it — a long Changes list ends up taller than a short Work panel. Each keeps its header and at least a couple of rows and scrolls the rest, and when even that will not fit, the tab itself scrolls rather than squeezing a section away.

Improvements

• The message rail now says which turn each dot is — Hovering a dot on the rail gave you the first line of the message and nothing else, so a dot could only be matched to a turn by reading it. The tooltip now opens with the turn number — "Turn 3 · …" — and it is the same number the Changes panel heads its sections with, so a dot and a section can be read against each other instead of counted out.

Bug Fixes

• A new session no longer keeps the previous conversation's rail — Starting a new session cleared the conversation but not the dots beside it: the rail was refreshed only when a message was drawn, and an emptied conversation draws none, so the old dots stayed on screen pointing at messages that were gone. The rail is now taken down with the transcript it mirrors, whether that is a new session or a switch to a conversation with no turns — and redrawing it no longer loses the one dot that was lit, which used to go out every time a message arrived and only come back once you scrolled.

Upstream TUI PRs

• Codewhale#6580 — merged 2026-09-26, not yet in any engine release. feat(runtime-api): fork a thread at a named turn — the engine half of "Branch a conversation from any of its answers". The Branch row is capability-gated on this route: against engine v0.10.0 the row is not drawn at all, and it appears the moment an engine carrying this is installed. Naming the turn keeps it and everything before it, and the receipt carries the first dropped turn's prompt — the text the composer hands back to you.

• Codewhale#6664 — open, unmerged. fix(tui): a fork continues when a turn lost its tool call — found while using the Branch rows this release adds. A fork cut from a conversation holding a tool call that never produced a result — a failed tool, or a process that died mid-call — could fail its first message with 400 No tool output found for tool call …, and a retry refuse to identify the history boundary. Until an engine carries the fix, a branch of such a conversation may refuse to continue; branching a conversation whose tool calls all completed is unaffected.

• Codewhale#6646 — open, unmerged. perf(tui): stop walking the whole item store to list or open a thread — the engine half of the rails staying quick on a large store. Listing threads and opening one used to read every item file in the store — measured on a 140-thread store, opening took 1.3s warm / 6.7s cold and a page of the list 1.27s, costs the rails pay on every refresh and every click — and the fix bounds both reads to what the client asked for. Nothing here is blocked on it; until an engine carries it, a large store is simply slower engine-side than it needs to be.