Every release, in order.

A chat you started on the phone stayed "New session" everywhere, because the naming only ran for messages typed in this window. It now gets the same two steps: the first message as a stand-in title right away, then a short name once the first answer is in. Renames from either side also show up on the other straight away, without a refresh. And the phone can now choose which workspace a new chat runs in, instead of always landing in the one this window is showing. Needs the phone app 0.5.0 or later for the workspace choice.

People often answer your Slack post with a new message in the channel or DM instead of a thread reply, and without tagging you. A sweep read only the thread, so it missed those. It now reads the channel after your last post too: everything after it in a DM, the next 24 hours in a channel. An item the label pass forgot to label also used to disappear from the report once anything else had a label. It now stays in "Needs you" with a warning, and the label step is told to label every item.

Muse Spark, Meta's multimodal reasoning model with a 1M-token context window, joins Claude, GLM, Kimi, 9Router and custom endpoints on the provider grid. Connect it with a Meta API key from ai.developer.meta.com. Its models named "contributor" cost about 12x less than the standard ones; the picker labels them, and the guide on the card says what that price saves: Meta may use those requests to improve their products. Everything Muse Spark reads images you attach, so attachments work out of the box.

- The Gmail, Google Calendar and Google Drive cards, and their Connect dialog, name /connect-google as the recommended route for full access, with a Use /connect-google button. The cards keep working for reading. - A branched chat's row menu shows what the old banner did: the parent with its status, Open parent, Handoff brief and the sources. Right-click the chat's title to open that menu. - Work and Tree agree on an Overdue reply: a waiting-on is late only when its record says so, not because a deadline passed. - The GLM Coding Plan counts as a subscription, like Claude Pro or Max: no Budget and no monthly ceiling for it.

- The Dashboard no longer fails with "Failed to load dashboard" when a workspace summary has no session counts, and the "Scanning workspace" bar is gone. - A row that said "Checking…" no longer keeps a spinner after the check is done, and a tool being rechecked shows one indicator, not two. - Routines no longer shows empty boxes while its options load; the model picker always offers Provider default. - Alt+Up and Alt+Down now move between chats; before, they did nothing. - Clicking a folder path in a chat opens the folder instead of an "is not a file" error. - The update and engine notices are one bar, and only one connect prompt shows above the message box at a time.

On Windows, pressing Connect on a tool that signs in through your browser, such as Gmail or Google Drive, could leave the dialog asking you to paste an address back with no link to open and no browser window. The sign-in link was there all along, but the app never received it. It now arrives in a second or two, and the browser opens the page by itself as it should.

The "which AI" step of setup used to offer two cards, free or paid, with the paid choice hidden inside the second one. It now shows one card per AI this computer can use: 9Router (free, and the one to start with), Claude Pro or Max, GLM Coding Plan and Kimi, each saying in a line what choosing it means. A custom endpoint you already saved shows as a card too. With none saved, its card says where to add one instead of offering a choice setup cannot finish. Nothing is picked for you, and the button says what happens next: Create my workspace.

Settings → Connected tools shows each tool as a card with its logo, its name and a footer with its status and the one button that changes it. Status reads Connected, Not connected, or what is wrong, in a colour that matches. When a sign-in finishes, a green line at the top of the pane names the tool, and says your next sweep includes it when the sweep reads that tool. Every button does what it did before; only the layout changed.

A sweep used to read email and Slack DMs only. A question in a thread you started, a Jira comment that mentions you, a Doc comment assigned to you, a share request, or an invite you never answered did not show up. Sweeps now cover every connected tool: Slack threads you posted in, Gmail, Jira and Confluence, Linear, Google Docs and Drive, Calendar, GitHub, and meeting notes.

A drafted reply saved in a file ran off the right edge when opened in the file viewer or the dashboard. It now wraps there too, the same as in the chat, and so do .txt files.

The chat shows one "thinking" line instead of two, and every wait now shows a spinner.

No user facing entry was written for this one.

There was nowhere in the app that said which version was running. Settings now has an About pane with the version and platform, and a Check for updates button that answers in the pane. It uses the same member-aware check as the menu item, so it says whether this account gets updates: a member sees their tier, a signed-out copy is offered Sign in, and a lapsed membership is named as the reason instead of "you're on the latest version". An update it finds installs from the same pane, and pressing Update twice no longer starts two downloads.

Every launch replaced the files in a workspace's meeting-recorder/ folder with the app's copies. A workspace with its own transcription pipeline (the harness template) lost its larger common.py each time, and its watcher stopped with no error anywhere visible. The app now records what it installed, keeps updating files nobody touched, and leaves changed files alone.

A phone that kept saying "trying again" left nothing on this computer to look at. The relay connection, the phone's handshake and the request loop now write to app.log (lines starting [remote]) and to the error reports: a relay that would not connect, an opening that was refused, a frame from the phone that would not open, and any phone request that took over 3 seconds to answer. The phone app (0.3.4 and later) also sends its own record of failed attempts, timeouts and errors when it connects, and those land in the same place ([phone ...] in app.log, and phone_report in the admin view).

With WhatsApp showing Connected, a chat in a workspace added or switched to after the app started had no WhatsApp tools at all, and nothing said why. The tools were only written into the workspace that happened to be active when WhatsApp last started. Every chat now gets them when it opens, in whichever workspace it belongs to. Checked on 26 September 2026 in a second workspace: WhatsApp connected with all 17 tools.

Before this release, making the window narrower pushed controls off the edge with no way to reach them: SETTINGS and FINISH SETUP in the tab strip, BRIEF, DETACH and SESSION in the chat header, the model pickers in the status bar, and Send in the composer when a file was open. A check of every control at every width found 645 that could not be reached. It now finds none.

The relay connection gave up after 15 seconds when no phone was attached, then waited up to a minute before dialling again, so a phone arriving in that gap was told the computer was asleep. It now waits for a phone as long as the connection is open, and serves one phone after another on it. The relay also came back OFF after every restart while the wifi server came back on, so a phone worked at home and silently stopped working on mobile data after the next update. It now comes back on with phone access, unless it was turned off by hand.

Every heartbeat now carries the relay room and the computer's name, so a phone added before the relay was on picks it up the next time it connects on wifi.

The phone gets the turn in progress (session.live): the reply so far, any permission card or question still waiting, and whether the session is working. A card raised before the phone connected can now be answered from it. Chat history sent to the phone is capped well under the relay's 4 MB frame limit, which a long session used to exceed, closing the connection the moment the chat was opened.

On a Mac the recorder captured your own microphone only. The helper that records the call audio was never included in the app, so every Mac showed a warning naming a file that did not exist. The app now ships the helper. On macOS 14.2 or newer, a recording carries the call and your voice, with no driver to install. The first recording asks for System Audio Recording permission. If a recording still falls back to the microphone only, the app says so when recording starts and gives the reason. We are also told, so the problem no longer depends on someone sending a screenshot.

Found at the AI Circle workshop of 26 September 2026. New releases of 9Router (0.5.86 and later) ship with an endpoint key switched on and no key created, so every request from this app was refused. The model check then told each participant "no account connected", which was not the problem. The app now signs into 9Router's dashboard with its default password, creates a key named "AI Second Brain" (or reuses one), saves it on the 9Router provider, and checks again. Chat sessions send the same key. If the dashboard password was changed, the app says so once and shows where to create the key by hand, without retrying, because 9Router locks the dashboard after five wrong passwords. The model check also now sends a key you pasted yourself, instead of a placeholder.

The model list was read once, when the 9Router card opened. Anything enabled in the dashboard after that never appeared. The list is now read again when you come back to the app window and when you press Check.

The account screen offered Google, GitHub and WhatsApp above the email form. None of the three was switched on at the account server, so Google and GitHub opened a browser on a page of raw JSON and then waited five minutes before saying anything, and WhatsApp answered "404 Not Found". The app now asks the server which of them are on and shows only those. The email form is always there, and it is the one that works today.

A typo in the email, a password the server will not accept, too many sign-ups from one network, a Wi-Fi login page answering instead of the server, a timeout, an office network inspecting secure connections: each now has its own sentence with the next step, instead of "Request failed (400 Bad Request)" or "error sending request for url". Mistakes in what was typed are shown next to the form, not beside a "Continue offline" button, which is now called "Continue without an account". A typo such as budi@gmail is caught before anything is sent, Enter submits the form, and the button counts the seconds while it waits.

The AI assistant is now a 237 MB download, and the installer allowed 5 minutes, which needed a steady 6 Mbps. Below that it failed every time and the retry started from zero. It now has 25 minutes, a time-out is not retried, and the message says to try a faster network or a phone hotspot.

- The Claude sign-in window found no claude command, because Terminal starts a shell whose PATH does not include where the installer puts it. It now opens with the app's own PATH, and does not need permission to control Terminal. - On a Mac without Apple's developer tools, the app no longer opens the "install the command line developer tools" dialog at every launch and during setup.

- No "Failed to start a new session: workspace not configured" message on the welcome screen, and no empty "New session" left in the list from it. The chat is ready when the tour ends. - A message sent before the assistant finished installing says so and says where to finish it, instead of "claude CLI not found on PATH". - A GLM or Kimi key the provider refuses is reported as a refused key, with a button to the AI providers settings, instead of "Your Claude sign-in expired". Someone who never signed in to Claude is no longer told it expired. - After setup, GLM and Kimi users are asked for their key, not sent into the free-account flow. - Connecting Slack the first time downloads its tools. The dialog now counts the seconds and says why it can take minutes, and closing it during that wait no longer ends in a "TypeError". - The window fits the screen it opens on. At 1366x768 the setup buttons sat under the taskbar. - Scrolling a long chat no longer stutters.

The app now reports the errors people run into, so they can be fixed without anyone having to describe them: uncaught errors in the window, failed actions, crashes, failed answers (quota, sign-in, network), and help requests that did not get an answer. Reports carry no names, email addresses, file paths, message text or keys; those are removed on this computer before anything is queued. The same failure is reported at most three times an hour.

A routine can now run a local program on its schedule with no AI session. Set "kind": "script" on a "runner": "app" row, and the app runs its command in the workspace folder on whichever machine has it open:

The attach button followed a flag on the provider, and the GLM provider was marked text only. That turned image paste off for every GLM session, including sessions on GLM-5.x and the GLM-4.xV vision models, which read images. The app now decides by the model the session runs. A model it does not recognise still follows the provider setting.

On Windows, updating Claude Code with npm while the app is open can leave a placeholder where should be. The app used to accept that file, report the engine as installed, and fail on the first message with "Unsupported 16-Bit Application" or os error 216. It now checks that each it finds is a real program for this machine, steps over one that is not, and when no working copy is left it shows the engine as not installed, so setup reinstalls it with the official installer.

From this release on, updates reach paying members only. A release now publishes its update to the members feed, and the public feed stays on 0.18.0, the version that was current when this was decided. If you are not a member, your app keeps working on the version it has and stops being offered new ones.

Panels opened links through the opener plugin directly. On a machine where that launcher does nothing, the call still succeeded and the panel believed a page had opened. Panel links now go through the same backend command as every other external link in the app, which tries a chain of launchers and reports a failure instead of hiding it.

The Meetings tab now asks two things before you press Record: whether to capture video alongside the audio, and what that video should cover. The default is unchanged, audio only, because that is what the transcript is made from and video costs disk.

Folded in from the meetings-screen-toggle branch, whose "Also record the screen" switch the window picker above replaces. What survives from it: the "Record the screen too" tick is stored like the other view preferences and comes back ticked on the next launch, with the window list already fetched. The picked window is not stored, because a window title from yesterday names nothing today. The calendar's quick Record uses the same start call, so it carries the choice too. A stored tick on a machine with no ffmpeg shows as unticked and disabled, and Record then means audio only, exactly as the card says.

The relay reaches this computer from anywhere with nothing to set up, and the Cloudflare tunnel does it for someone who owns a domain. Both put something between the phone and this computer: a server that copies sealed bytes, or a public address behind a lock.

Turning the Cloudflare tunnel on while one was already starting took a lock twice on the same thread and hung the whole app, on the path that exists so a second press is harmless. The check now lets go of the lock before it answers.

A source that delivers the same conversation in pieces produced a chat per piece. Three messages in one Slack DM over an hour became three sub-sessions, each drafting its own reply to a fragment of the same thing, and the rail filled with near-duplicates that all had to be read to find out they were the same conversation.

A parent that keeps producing children grew a list that never shrank. Every child reached "done" and stayed there, so the rail became mostly history with the two things still waiting on you somewhere in the middle of it.

A status report written by something outside a session (a cron job, or a workspace's own reply router closing a conversation Slack has already answered) sat unapplied until some unrelated session happened to end a turn. The finished chat kept its place until then. The auto-drafts ticker now applies status reports on every pass.

A Claude Code too old for the app used to read as Ready forever. On 2.1.223 the model picker shows Opus 5.5 and Fable 5.1 as disabled and never says why. The app now requires 2.1.280 or newer. Below that, the checklist marks the engine as needing an Update, not an Install, and runs the same repair path as a Node version that is too old. A version the app cannot read is not treated as too old: running one build behind is better than refusing to run.

The reply-queue digest ran even with Auto reply drafts turned off. The toggle now controls both, the card says so, and the Routines row no longer looks like an unrelated manual job.

The instructions every workspace receives told the agent to keep the tree in work-tree.md. The app has always read journal/state/work_tree.json first. They now say that an existing work_tree.json is the work tree, and the work-tree.md guidance applies only when neither exists.

Window size, position and maximized state survive a restart. Sessions that were popped out into their own windows at quit reopen at launch, each in its old place. The main window reopens the session it last showed, not whichever one sorts first, and falls back cleanly when that session was deleted or belongs to another workspace.

0.17.0 put the server half of this in place and said the half you would see was next. This is it.

- The status strips above the message box (connection, provider, permission and the question chip) no longer move the conversation up and down when they show or hide. They now float over the bottom edge of the conversation instead of taking a row of their own. - Routines: with Scheduled runs turned off, the settings and the routine list below it are dimmed, with a note that every routine is paused. The Auto reply drafts row now says it runs on its own schedule, whatever this switch says.

Approving a draft meant Settings, then Connected tools, then the WhatsApp card, then Manage to open the rows behind it. It is something you do several times a day and it was filed next to the things you do once.

Codex has been in this app as an ACP runtime for a while and had no WhatsApp tools at all. The wiring was one file, .mcp.json, written into whichever workspace happened to be active when the bridge started, when pairing finished, or when the send policy changed. That file means something to Claude Code and to nothing else, and there are five workspaces on this machine.

"Type send without asking to confirm", with the middle three words in bold. Bold is emphasis, not a boundary, and this is the one field in the app where a character has to be reproduced exactly. The phrase has its own line now, in the mono face, and one click selects the whole of it.

A blinking block sat at the bottom right of the bubble while a reply streamed, keyed on a class that comes off once per assistant message. One reply is several messages: a thinking block, then a tool call, then the answer. So through a single answer it blanked at every boundary and reappeared somewhere else a moment later, which reads as the pane twitching rather than as a cursor. It belongs to the turn now and is released once, when the turn ends.

[some/path.sql](https://github.com/...) opened nothing and reported its own label as a missing workspace file. Inline code is stashed before markdown links and restored after them, so a code span used as a label came back as a file mention nested inside the anchor, and the inner span owned the click. A label is not a mention of a file. It is the name the link chose to wear.

Shortlists were compiled into the binary, so "the newest model" meant newest as of the last build: GLM-5.3 shipped while this app's newest GLM id was glm-4.6 and nothing here could notice. Every provider is an HTTP API that knows its own catalogue, so it is asked. An unreachable provider or a rejected key falls back to the built-in list with the reason attached rather than failing.

A connector sign-in could sit on "Waiting for you to finish signing in" with no browser, no link and no way forward. Windows ConPTY re-emits output at the width it was asked for, so a 400-character authorization URL came back hard-wrapped into four pieces. The pty is wider than any URL a provider emits now.

Two auto-reply requests left the queue on 21 Sep without becoming a chat, and one of them was a real question from a real person. Every diagnostic in that module was an eprintln!, and the app has no console on Windows, so all of it was discarded. It goes to the app log now, and a request is only recorded as dispatched once the chat it claims to have made actually exists.

Settings, Connected tools, a waiting WhatsApp draft, Send. The app raises "Send to <number>?", focuses its Cancel button, and paints the whole card underneath the settings pane. So Send read as a dead button, the next click anywhere landed on a backdrop nobody could see and answered the hidden dialog with a no, and the draft stayed in the outbox. Seven of them did.

.mcp.json set the state directory, the send mode and the outbox path, and never the two database paths. whatsapp.py reads those itself and falls back to <server_dir>/../whatsapp-bridge/store/, a layout that is real in an upstream checkout and absent in every install of this app. So sqlite3.connect got a directory that does not exist, the error was caught, and list_chats, search_contacts, list_messages and get_last_interaction each returned an empty list. With a fully synced 28 MB store on disk, the agent concluded WhatsApp had never been connected.

upcoming() asks each token profile for its own primary calendar and concatenates the answers, and nothing stopped two token files from resolving to the same Google account. Events are deduped by id now, which keeps each occurrence of a recurring series in its own row, and an event with no id keeps its row because hiding a real meeting is worse than showing a duplicate. The dedupe runs before the list is cached, so a duplicate cannot be served from memory for the rest of the TTL.

0.17.4 rebuilt the WhatsApp bridge for Windows and Linux and went live on all four platforms. The macOS artifact it published still carries v0.4.1-9-g9b91b12, with no /api/pair/status in it. So the pairing window on a Mac fails today exactly the way it failed before that release.

0.17.1, 0.17.2 and 0.17.3 each shipped a WhatsApp bridge with no /api/pair/status in it, each under a changelog entry saying the pairing window was fixed. The source had the route. The version file named the right commit. Nothing in the release ever looked inside the artifact.

It never did. The published Linux binary was built without cgo, which makes go-sqlite3 a stub, so the process exited on "Failed to connect to database" before it bound a port. Every route it contained was unreachable, the pairing window included. The route check alone would have passed it, which is why the contract above also forbids the build flag.

Reported again on 0.17.3, after two earlier fixes, and this time the app's own probe named it: pinnedUserMessage 0px -> 0px (4 changes) alongside timeline 462px -> 462px (5 changes), inside one second, with nobody typing.

Pressing Sign in said "Your browser is opening" and, on some machines, nothing opened. Nothing failed either: the adapter hands the sign-in to the codex binary, which opens the browser itself and reports nothing back, so the card sat there for ten minutes and then timed out with no URL ever shown.

Moving a session to Codex left both pickers on screen until the next message. They configure one thing -- the endpoint Claude Code's CLI talks to -- so for Codex they set nothing, and offering them is what turned "which provider is Codex" into a question worth asking. The registry has always said which agents read them; the window now reads that instead of waiting for the agent to start and say it again.

The window opened, the box stayed white, and underneath it: "bridge returned a body this app could not read".

Nine of the seventeen rows on the Routines page were outlined in danger red and captioned in danger red, on a machine where nothing was wrong. The pane read one backend field, schedule_error, and that field answers "will this app's scheduler fire it" -- which is also false for a job that runs on the automation host, for one that is started by hand, and for the reply-router the app runs on its own ticker. All three are working exactly as declared. The one row that really was broken had nothing to set it apart.

The four switches at the top sat in the same frame as the routines under them, so they read as the first four routines. They are their own card now, above a card of routines and a card of past runs.

It is a switch at the top of the page, and the app hosts it on its own ticker. A reply-router row in the workspace registry declared the same work a second time, so the page showed the toggle and, five rows below, what looked like a duplicate of it. The row has been removed from the registry; load_registry already refused to schedule it.

Press Connect, or any link in a card, and the page arrives in the browser you are already looking at, raised. It used to open behind whatever was in front, which from the Settings sheet reads as a button that does nothing.

Connecting Slack needs fourteen permission scopes copied into Slack's own console. They were listed in the middle of a block of text, so following the instructions meant reading a comma-separated run out of prose and retyping it, and one wrong character fails later with an error about something else.

The idle-layout probe that shipped in 0.17.0 named this in 38 seconds, with nothing being typed: the tab strip grew from 36px to 54px, the transcript below it moved by the same amount, and three seconds later both went back.

On 0.17.0 the pairing dialog never filled in. The box stayed white, the line under it said "Waiting for a code…" forever, and below that: "bridge returned a body this app could not read".

It used to be a modal inside the main window. That is the wrong shape for this one screen: the user is holding a phone up to the monitor, not clicking, and a modal inherits the main window's stacking, so it sits behind the Settings sheet that opened it, and behind anything else in front. What that looks like from the outside is a code that never appears.

Nothing in the app behaves differently in this release. What landed is the server half of reaching this computer from a phone that is somewhere else, and it is written down here because the next release is the half you will see.

Press a Connect button and the browser gets the page, but stays behind this window, or flashes in the taskbar and waits. Sometimes the click reads as nothing happening at all.

A connection set up in a workspace's own .mcp.json is gated by Claude Code behind a trust prompt only an interactive claude can show. Until somebody answers it the server loads into no chat at all, and the card said as much and then stopped: "Pending approval (run claude to approve)". That is a true sentence and a dead end. The pane could not lift the gate, and the assistant is told not to hand out claude mcp command lines, so both surfaces declined and the tool stayed unusable with nothing in the app to press.

The pane holds two kinds of connection that looked identical and are not. A Slack, Gmail or Figma card connected through your Claude account is the same in every workspace; one added for "just this workspace", or set up in the workspace's own .mcp.json, is not. Nothing on a card said which, so the reasonable conclusion was that none of them were per-workspace, when half of them already were.

Its two buttons read "Buka area member" and "Lihat AI Circle". They were the only translated strings anywhere in the shipped interface, so the strip read as a piece of a different app bolted to the bottom of this one. They are English now, like everything around them.

The conversation stepping up and down while nothing is happening was traced in 0.15.0 to two boxes trading pixels, and that trade was fixed. It is reported again on 0.16, which means a second cause and no evidence for it. The probe that found the first one was made opt-in in the same release, behind a flag that can only be set from a developer console this app does not ship, so the person seeing the bug could not turn it on.

The mode picker moved onto the status bar in 0.16.0, next to a chip that had been put there back when the picker was two clicks away inside the session popover. With both on the same row the bar printed FULL AUTO twice, a foot apart. The chip is gone and the picker carries the gold itself, so the control that sets the mode is also the thing that warns about it.

FULL AUTO appeared to reset itself to manual every time a chat was opened. Nothing reset it. A new chat inherits its model, effort, provider and permission mode from the last session, and "the last session" was the newest row in the session index, which is not only your chats: the reply router writes a group container the moment it drafts a day's replies, carrying no permission mode at all, and a scheduled routine writes a run carrying the mode its autonomy decided, which is plan for a read-only routine. Both are newer than the chat you were actually last in, and a missing mode reads as manual in the picker.

The rail carried two things called "Auto reply drafts": the group every drafted reply hangs under, and a separate top-level chat, one per day, sitting beside it. Same job, run twice.

The Routines pane said Claude on opus. Every auto reply draft came out of 9Router anyway, and nothing on screen said so.

A capture finished cleanly at 15:54 on 16 September. At 15:59 the floating control was still on screen with its red dot pulsing, and pressing Stop did nothing at all. Nothing was recording, and nothing had been for five minutes.

Switching between manual, accept edits, plan and FULL AUTO meant opening the SESSION popover from a button at the far end of the header. That is the wrong distance for this particular control, because of when people reach for it: not while setting a session up, but mid-turn, at the moment they decide they are tired of being asked about every edit. Two clicks and a pane away is exactly where it should not be at that moment.

"Why is OpenAI not under Claude, only Kimi and GLM?" gets asked in the Providers pane, because that list reads as which AIs the app supports.

Updating could stop on a Windows dialog offering Abort, Retry and Ignore, over Error opening file for writing: whatsapp-bridge.exe.

Text and layout moved up and down in the main area while nothing was happening. The app has carried its own instrument for this since 0.13, and eleven days of its log is what finally named the cause: 1,460 recorded height changes, of which 1,269 were the banner bar and the transcript moving in the same millisecond, in opposite directions, always summing to the same total.

The cue set had five sounds behind a single toggle, and almost every decision around it was wrong in a way you would only notice by living with it.

There were six shortcuts, each an anonymous listener wherever its surface happened to be built, and a catalogue of them maintained by hand in a different file.

The two most common failures in the app had no wording of their own, so they arrived as a raw fragment of whatever the provider said. An overloaded provider now says it is overloaded, that nothing here is misconfigured, and to try again in a minute. A conversation that has outgrown its model says that, and says the history is not lost, because that is the obvious fear at that moment.

Three collections grew for as long as the app was open and nothing ever removed anything from them.

The calendar was the only part of the app that talked to the network without a timeout, so one hung socket parked the headline widget indefinitely; it now has one, reuses its connection, and caches the access token instead of performing a fresh grant every thirty seconds -- roughly 2,880 of them per profile per day.

One suite had been red on every Windows run, for a reason that had nothing to do with the code: it searched the source for a newline followed by a brace, and a Windows checkout has carriage returns in it. It reported that a function had been removed while the function was sitting right there.

Every routine row ended in five controls: ON, RUN, MODEL, EDIT, DELETE. Four of those are verbs, and the fifth wore the same ghost-button styling, so it read as a fifth instruction. Looking at a row that said ON, you could not tell whether the routine was on, or whether you had to press ON to turn it on.

Clicking a file:///C:/Users/... link in the timeline reported the file missing, and the error named a path with the drive letter in it twice. The file was never missing. The renderer strips the scheme off every link it draws, so the viewer received /C:/Users/..., which Windows reads as rooted but not absolute. That took the branch meant for relative paths, which joins onto the workspace root, and the app went looking in C:\workspace\C:\Users\....

Move workspace asks how much room the destination has before it copies anything. On Windows that question never got an answer: it refused with "Could not find drive information for ..." on a drive with a terabyte spare, so the move stopped at the first screen and no file was ever copied.

Ten tests failed on Windows no matter what the code did, which is worse than having no tests: a red run that is always red gets ignored, and the real failure above was sitting inside it. Five split PATH on a colon, which is the separator on macOS and Linux but not on Windows. Three compared file paths written with forward slashes against paths the code had built with the platform's own separator. Two were the Move workspace bug.

A backup carries the workspace folder, which is the writing and nothing else. Everything that makes a second laptop feel like the same laptop sits outside it: the conversations, the session list and branch tree, and the tokens every connection needs. Restoring a backup over there hands you your notes and none of your history, which reads as success right up until the first prompt fails.

The feature worked and never cleaned up after itself. Every drafted reply became a chat under one "Auto reply drafts" parent, and a chat marked done stays in the tree, so a busy day added dozens of rows that nothing ever removed. Seventy-five of them was an ordinary week.

A command started with run_in_background keeps going after the turn that started it ends. Nothing in the app said so. The status bar read "Ready", the session in the rail showed the idle marker, and the cross-workspace chip did not count the session at all, for the whole twenty minutes a CI watch took.

Connecting Gmail, Calendar or Drive could end on a Google page reading "Access blocked: Authorization Error, Missing required parameter: scope", with your own OAuth client named underneath it. The client was never the problem, so the trip to the Google console it sends you on cannot fix anything.

Removing one of the bundled commands brought it back on the next launch, because the seeding pass could not tell "never had this" from "had it and threw it away". The offer is recorded now, so a deletion holds.

The same sign-in asked Google for no refresh token, so access died with the first access token and every recovery meant the whole browser flow again. It now asks for offline access and accepts the consent screen that comes with it, which is what Google requires before it issues one.

The microphone is a toggle, so a clip runs for as long as you talk, and a minute is long enough to go and read another session while it records. The transcript went into whichever composer was on screen when you pressed stop, which means a prompt spoken into one chat arrived pointed at a different agent.

A session that branched could see its sub-sessions appear under a completely unrelated chat. On 6 September a morning update split into six branches and all six hung off a background ledger-sync session that had nothing to do with any of them.

The bundled command set was sixteen commands with flat descriptions, which read as one long alphabetical list. It now carries a group name at the front of every description, so the picker reads in blocks: Daily, Weekly, Meetings, Product, Artifact, Comms, Notes, Tracking, Session, Setup.

/inbox-sweep, /follow-ups and /meeting-prep each checked for a connected tool by telling the user to run claude mcp list. The app's own Connecting Tools protocol, which it writes into every workspace's CLAUDE.md, says not to hand out that command, because a connection made on the command line is a second copy of a server the app already manages and the app cannot show, repair or disconnect it. The three commands now read the tools available in the chat, and point at the card in Settings, Connected tools when one is missing.

A Google Doc, a Notion page, a Confluence page: other people edit them, and most write tools replace the whole document rather than merging into it. So an edit made between the agent's last read and its write was not merged, it was deleted, and nobody was told. The person who wrote it found out when they reopened the page.

The Routines tab used to govern a registry only a hand-written JSON file could fill, which for most people meant it governed nothing, forever. Three changes from the first-value spec:

Five honesty fixes out of the September UX review:

Adding another agent used to end at a toast telling you to run codex login in a terminal. The agent's card now carries its own Sign in button: the app asks the agent which sign-ins it offers (over ACP, the protocol the agents already speak), draws one button per choice, and runs the chosen one, browser methods open the browser, API-key methods become a paste field on the card. One-press "+ Add Codex" and "+ Add Gemini" buttons pick the right launch command for the machine, and the launcher downloads itself on first use, so nothing is installed by hand. The Codex preset also moves off the deprecated the adapter adapter to the adapter.

The Hours view read every session with the sdk-cli entrypoint as an unattended run and left it out of the day. The app spawns Claude through that same SDK entrypoint, so a member's own chat looked exactly like a cron job: the day came back with zero streams, a leverage of 1.0x, and a count of "automated runs" that was really the person's working day.

A workspace that ships the reply-router skill can now turn it on from the Routines view: a new "Auto reply drafts" toggle. While the app is open, an internal ticker (same shape as the routine scheduler) runs the workspace's reply_router.py every five minutes. The script decides which new Slack messages actually need a reply (debounce, caps, quiet hours, baseline) and writes branch requests; the app consumes only those auto-reply-*.json files and turns each into a sub-session under a per-workspace "Auto reply drafts" container session, so drafts group in the rail instead of scattering between chats. Sending still waits for explicit approval inside each session, this feature only moves where the draft comes from.

Reported on Windows right after an upgrade: the corner indicator said a recording was running that nobody started, and Stop did nothing however many times it was pressed.

Every open chat runs its own CLI process, and that process carries its own copy of every MCP server the workspace connects. Nothing stopped one. The app closed a chat's process on an explicit Stop, on a model or effort change, and on an agent change -- and nowhere else. So reading a reply and moving on left the process running for as long as the app did.

Most of what this app can do lives behind a right-click, a double-click, or a chord nothing on screen advertises. Shift+/ now opens a searchable overlay listing every shortcut and feature, composer keys, voice input, session markers and menus, layout, workspaces, grouped the way you would look for them, filtered as you type. It works anywhere the cursor is not in a text field; Escape, a click outside, or ? again closes it.

On a fresh 0.13.3 install, two of the three setup rows reported failure while the work behind them had already succeeded. rename_all on an enum renames the VARIANTS, so the outcome went onto the wire as kind: "ready" while the wizard compared it against "Ready". The comparison never matched, and a successful outcome carries no failure object, so the row fell through to its last-resort line: "This step didn't finish, and it didn't say why."

Screen 3 treated "not answered yet" as "the free one", in three separate places that all defaulted the same direction. Read the screen, press Continue without choosing, and you were configured for 9Router. Two screens later the app said you would sign in to Claude after setup, and the first thing it said when you typed was that it could not answer yet.

It came with the app. The card called it "a separate small app", gave it an Install button, and the button opened a page that was never built, then said "Opened the download page, the installer walks you through the rest." Nothing had been opened and nothing was going to install.

Cloning stopped at 180 seconds saying "Nothing was changed", and every attempt afterwards was refused with "Directory is not empty" for a folder that had just been deleted.

The Gmail, Calendar and Drive cards asked for a client ID and left the eleven steps that produce one to you. Two of those steps were traps.

The banner records a message that is addressed to you and still unanswered, and drops it the moment you reply. Nothing capped how many could sit there at once. Twenty message cards is a backlog on one line, and the first thing it buries is the recording that stalled or the meeting starting in ten minutes.

Getting started used to mean a name, an email, a password and a WhatsApp number that could not be left blank, followed by a screen asking you to send a code from your phone. That was the shortest route. It is now one press.

You can sign up here and start using it in the same sitting. If your account is not paid for yet, the subscription page opens in a window inside the app rather than throwing you out to a browser, and the app notices when the payment lands instead of making you restart it or wait for a check hours later.

The small red-dot window that appears while a meeting is recording can be dragged anywhere on the screen. It was always meant to be: the window has no title bar precisely so that the whole surface is a handle. The permission that lets a window be dragged by its surface is not one of the ones granted by default, and the overlay had been given no permissions at all, so grabbing it did nothing and it stayed in the top right corner whatever was underneath it.

The rotating line typed its text out one character at a time, 30ms each, after an 800ms wind-up, and every card left the line after exactly 8 seconds whatever it said. Those two numbers decide a length: past about 240 characters the card was still being written when it rotated away. Whatever did get written was then clamped to two lines at a fixed height, so a long Slack message showed its first two lines and nothing else, ever. The two faults compounded, and they compounded in the worst direction: the cards carrying the most were the ones nobody could finish.

Gmail, Google Calendar and Google Drive need an OAuth client you create yourself, because Google's connectors will not register the app on their own. That client has two halves, an ID and a secret, and only the ID is written where anyone can see it. If the secret never reached the keychain, every sign-in ran the whole browser flow, Google approved it, and the exchange died at Google's token endpoint with client_secret is missing. The card went back to "Needs signing in", so the obvious next move was to sign in again, which failed the same way.

Three states that looked like one button in three moods: an outline mic, a red one, and a dimmer red one. Each is a different shape now, mic, filled mic, spinner, so they stay apart with colour off, with animation off, and at 16px. With motion reduced, listening keeps a permanent ring, because that is exactly the person who cannot rely on a pulse.

Hovering one shows what it is, whose it is and whether it has blown its SLA. Clicking opens the full record in a panel beside the conversation that mentioned it, with its notes and a link to the Slack message it came from. They used to be links that threw you into a browser, or into nothing when the dashboard was not running.

Twenty-seven emoji became one drawn set for the controls and the tabs, headings dropped the decoration they never needed, and the brand marks stayed. Emoji are a font: their weight and colour belong to the operating system, they ignore your theme, and they cannot change shape by state.

"Send N comments to AI" assigned the composed request straight into the composer. Anything already typed there was gone, with no undo and no copy of it anywhere. The likeliest moment to hit this is also the worst one: you write a sentence of context, then reach for the comments you left, and the sentence disappears.

COM-0754 and WAIT-0445 are in every briefing this app shows, each one a link to http://localhost:3737/#find/<ID>. Clicking one handed you to the system browser, or to nothing at all whenever the dashboard was not running. The dashboard has had a hover card and a drawer for these since August; this app never got either, so an id here was a string you had to go and look up somewhere else.

One reply on screen twice: the first copy in raw markdown with the asterisks and backticks still showing, the finished copy underneath it. Reported three times, guessed at twice, and now measured. The diagnostics added last week caught it:

Every row in the corner read Slack, with no channel, and the message itself was full of <@U02D89BUZ1T> where a name should be. Three separate things, one cause.

Four meetings sat in the corner reading "Transkrip jalan" for ten hours on a Mac where the transcriber had never been started. The app only knew "audio on disk, no minutes yet", which is equally true of a file being worked on and a file nothing has touched, so it guessed the flattering one.

Arrivals lived in a panel pinned over the top-right of the transcript. It floated because anything in the banner's own flow moves the whole conversation down, and it bought two problems: it covered the chat it hovered over, and it was a second place to look next to a rotating line already reporting the same counts.

21997 selesai and $13393 were lifetime totals sitting beside 5 hari ini in the same typeface, with nothing saying which was which. A number with no period attached stops carrying information within a week.

0.12.1 fixed the schema-bound case. This is the other one: an agent whose last line is a tool call that never returned stays unfinished for the life of the app, so a fan-out that ended half an hour ago still reads "2 running".

The composer grows as you type and the transcript shrinks to make room. The re-pin ran a frame late, so the browser painted one frame with the viewport already shorter and the scroll position still where it was: the conversation dropped, then snapped back. Every wrapped line, both ways.

Remote access bound a LAN port, which covers home and nothing else. Settings -> Phone now has a Cloudflare tunnel: this computer dials out, your phone calls a name like asb-mac.brianarfi.com, and it works on mobile data with no port opened on your router. The frames were already sealed with your phone's device key, so the tunnel carries bytes Cloudflare cannot read.

The rail said it and opening a chat threw it away, so the answer to "am I about to reply to a client from my personal workspace" was to go back and look. It is in the chat header now.

model and effort sat in a row of their own, one line above the status bar. Two strips of chrome, adjacent, both carrying session state, and drawn in two different typographic languages: lowercase sans labels with native boxed selects above uppercase display-face chips.

The status bar reports on the chat in front of you: what it is running on, how long, what it costs, whether it is blocked. Neither of these two is about that. SETTINGS opens the same modal from every chat, and FINISH SETUP counts facets of the install. They are at the right-hand end of the tab strip now, beside Chat / Dashboard / Routines / Meetings, which is the other thing in the window that is true app-wide. FINISH SETUP sits directly beside the button that opens it.

An agent that answers through a StructuredOutput tool call (Workflow stages with a schema) never reached the "spoke last" state the dock reader waited for. Sixteen finished agents showed as still running, each reading "starting…" because no tool was in flight either.

A command whose argument is marked optional now runs on a click. Before, any argument hint at all meant the click only wrote the command into the message box and stopped, which covered nearly every command in the list, so the list looked like it did nothing. The convention is now stated and load-bearing: an argument-hint in [square brackets] is optional and clicking runs the command, one in <angle brackets> is required and clicking waits for you to type it.

The message box has a / menu. It lists the same commands the rail does, each with what it is for, filters as you type, and takes arrow keys, Enter, Tab and Escape. Nothing before this told anyone that commands could be typed at all. A file path (/Users/...) does not open it.

Instead of one sentence pointing at the rail, a chat with nothing in it now offers five commands to start from, each with its description, and says that / finds the rest. The rail shows two lines of description per command rather than clipping it to whatever fits beside the name.

With a long session list in a short window, the Commands section could be squeezed to no height at all. It reported itself open, the arrow turned, and nothing appeared. It now keeps a floor of its own and scrolls inside it.

The workspace-name field on "New from template" suggested a real client's name. The leak checker only ever read the bundled notes template, never the app's own screens, so it could not have caught it. It reads both now, ignoring code comments, which is where the design notes legitimately name real work.

A connector sign-in on macOS worked in the browser and was then reported as failed. The browser said the sign-in was done and to close the window, and the card stayed grey. Nothing was wrong with the sign-in.

The "Which AI" screen offers two answers: the free one, or the one you already pay for. Each card says what choosing it means. The third card about running your own agent is gone from setup; that lives in Settings, Agents, where the people who want it will look.

Setup used to list four rows named after the programs behind them. It lists three things now: making your notes folder, installing the AI assistant, adding the extras. Under a running row you see what the installer is actually doing, because its output finally reaches the screen; a five-minute download used to look exactly like a hang.

Three things used to conspire to strand a meeting on the phone. All three are fixed.

A failed row has three buttons: Try again, Help me fix this, Skip for now. Help opens a panel under the row. First comes a playbook for that kind of failure, no internet, no space, a permission refused, macOS blocking a download, Windows refusing to run a script, a work network in the way, with the two or three things a person can do, offline, at once. It also explains what the failed thing is and why the app wants it, and offers the escape hatches that used to be extra buttons: choose a folder yourself, install the assistant by hand with a command you can copy.

The app now keeps one list of what it needs and handles each item itself: the notes folder, the AI assistant, the helper the free AI is built on, the free AI connection, the starter commands, the meeting recorder helper, and the backup helper. On Windows the backup helper is downloaded as the app's own portable copy, no installer and no password; on a Mac the app asks macOS to add it.

The last release let a session run on an agent you chose. This one gives you the screen for it.

Connecting Gmail or Jira used to mean asking Claude Code to run the sign-in, and what came back was kept in its keychain. An agent that is not Claude Code could see the connector and could not use it.

A session used to show your first message as its name, then swap it for a written one, and because the app only remembered that in the window it happened in, a restart could rename an old session all over again on some unrelated turn.

"Which AI should power this?" now has a third answer: you already have your own agent. Choosing it skips installing Claude Code and skips asking you to sign in to a subscription you do not have.

Until now this app was Claude Code with a window around it. If you did not have a Claude subscription, there was nothing here for you.

Agents do not have the same controls. Effort levels are a Claude Code idea; permission modes are whatever your agent chose to offer; the subagent tree reads files only Claude Code writes.

Connecting Gmail or Jira used to mean asking Claude Code to do it: the list of connectors lived in its config, the sign-in was its command, and the tokens were in its keychain. None of that exists for an agent that is not Claude Code.

The timeline, search and "does this session have anything to resume" all read Claude Code's private files. An agent that keeps no such files would have shown you an empty session with nothing to explain it.

Standing instructions in your workspace now reach an agent that reads AGENTS.md rather than CLAUDE.md, so branching works the same on either.

The recorder here has always been able to capture a meeting you are sitting in. It could not help you in someone else's office, because it is the laptop's microphone and the laptop was not there.

A network connection that has quietly died looks exactly like an idle one until something is sent down it, so the phone was showing "connected" while nothing arrived. It now checks every twenty seconds and treats silence as a dropped link, reconnecting on its own.

Plan mode is meant to be a detour: the AI works out what it is going to do, you approve the plan, and it gets on with it. What happened instead was that approving the plan dropped the session into asking-for-everything mode, whatever mode it had been in before. On a session set to full auto, that meant a permission card for every single file it had just told you it was going to write. It read as the app being stuck, and the only way out was to set the mode back by hand, every time.

Everything the app needs from the AI it runs is now stated in one place, as a contract rather than as a pile of assumptions about Claude Code specifically. Nothing changes today, and Claude Code still works exactly as before. It is the groundwork for running this app on an agent you choose yourself.

Settings has a Phone pane now. Turn it on, press "Show the code", and scan it with the AI Second Brain app on an Android phone: your chats, the replies as they stream, and the two prompts that stop a session dead until somebody answers them, all in your pocket.

It used to say "Tidak ada prioritas hari ini", and it said that every day, including the busy ones. It was never reading anything: the call it made could not reach the dashboard from inside the app, the failure was swallowed, and the empty answer looked exactly like a real one.

Start a recording and the same corner turns into its control: a red dot, what is being captured, a level meter, and Stop.

There is a microphone next to the Send button now. Hold it, say what you want, let go. A second or two later the words are in the message box, where you can read them, fix the one it got wrong, and press Send yourself.

Ask for something that needs a tool you have not connected, and the answer used to be a claude mcp add line to paste into a terminal, or a trip to Zapier. The app has had a whole pane for this for a while, and the assistant did not know it existed. Worse, the two routes do not agree: connecting the same service twice leaves the assistant choosing at random between two copies of every tool, and puts the second one somewhere the app cannot fix or remove.

Stop does not kill anything. It leaves a note in the recordings folder, and the program supervising the recording reads that note and shuts the capture down properly. That is what produces a playable file and lets the rest of the pipeline pick the recording up.

Clicking a command in the left rail did nothing when no chat was open, which is most of the time you would look at it. There was no error and no chat started, so the rail read as a catalogue of things the app could do in principle, rather than a list of things you can start.

What runs on a schedule, and what each run did, was four clicks inside Settings. It is something you read, like the Dashboard is, so it sits next to the Dashboard now. It moved, it is not in Settings any more.

You always could. The button said "⋯", which told nobody, so the answer to "can I rename this?" was a control already on screen. It says "Rename…" now. It still opens the same box, where you can also point a workspace at a folder that moved, or take it off the list.

Losing wifi mid-answer looked like something else entirely. Sometimes it came back as an error naming your AI provider, offering a settings page that could not have fixed it. Sometimes nothing came back at all and the spinner ran until you gave up. Either way your message was gone and you had to type it again, one chat at a time.

A link the assistant wrote came out broken in three ways at the same time. You saw the brackets. You saw the label and the address side by side, which read as two links to the same thing. And the part that was clickable often started halfway through a word, so clicking it opened nothing.

Sometimes a reply was on screen twice: once as finished text, and once above it as raw markdown, asterisks and all.

Reading a reply meant fighting the page for it. The text drifted up and down by itself, worst when you were parked at the bottom watching an answer arrive, and nothing you did made it stop.

Anything that needed doing at half past nine, or every twenty minutes, you had to start yourself. The app can do it now.

Half a typed message used to belong to the app, not to the chat it was typed in. Switching over to check something in another session carried the sentence along with you, dropped into a conversation it was not written for, and the images staged next to it were thrown away outright on the way. The only safe move was to finish the thought before looking anywhere else.

Marking up a file meant catching the button first. Select a line, the Comment button appears above it, press it, and it slid away from the cursor before the press finished, so the click never landed, the selection cleared, and the only way forward was to select the text again and try to be quicker. It was not a timing problem and being quicker did not help.

Reasoning arrives as its own block, and the model validates those blocks on the way back in as strictly as it emits them. One that reached disk empty therefore poisoned the whole conversation: every later message resent the same history, every one came back as 400 messages.76.content.0.thinking: each thinking block must contain non-whitespace thinking, and pressing try again could not work by construction, because the retry sent identical bytes. The session was dead while looking merely unlucky, and the error named an array index into a file you have never seen.

Record used to check for ffmpeg and, when it was missing, tell you to brew install ffmpeg. On a machine whose Homebrew belongs to a different macOS account that is not a fix, the install ends in a permissions error and the recorder stays dead. The app ships its own now, built from source rather than downloaded, and verified to carry no GPL-only flags so bundling it stays clean.

- 9Router's installer checks for Node 18 before starting, clears a half-finished install so a retry begins clean, and shows elapsed seconds against a 12 minute timeout instead of an unmoving button. - macOS stops asking for the same folder permission over and over.

A second brain fills up. After a few months there are notes, open loops, promises and meeting actions, and the honest answer to "what is going on with the client pitch?" becomes *read everything and find out*. Search only helps if you remember the right word.

The CLAUDE.md managed-block mechanism now carries more than one section. Adding a protocol is dropping a file into the template's managed/ and naming it in one list; each gets its own marker pair, and a section whose file is missing is skipped rather than costing a workspace the sections that are fine. The bundled-template test now checks every declared section has both its document and its markers, so adding a name without shipping the file fails in CI rather than in someone's workspace.

The real value, and a check that refuses to produce a release while that setting is still a placeholder. The same mistake cannot leave the building again.

Chat history backs up to a private GitHub repo you own, and restores onto another machine. It saves the session list, the sub-session ledger, and the transcripts themselves.

Connecting Slack, Gmail or GitHub used to fail outright. The sign-in ran against a stdin that was not a terminal, so it never got as far as asking you anything. It now runs against a real terminal, and supports three ways in: browser sign-in, a token you paste, or your own OAuth client, matched to what each connector actually needs. No claude.ai account required for any of them.

It used to report success when it had failed, so a meeting you thought was being recorded simply was not. It now checks what it needs before offering to record, quotes the real error when something is missing, and waits for confirmation that recording actually started.

The macOS PATH repair shipped in 0.8.3 never got its Windows half. Windows looked in seven fixed folders and stopped, so a machine with Node installed through nvm-windows or fnm was told Node was missing while it sat one folder away. Windows now gets the same search macOS has, including a PowerShell profile probe for version managers no list can predict.

Opening the app a second time now closes the new copy and brings the existing window forward, instead of running two copies against the same workspace with no coordination between them. Release builds only; tauri dev is deliberately exempt so it still runs alongside an installed copy.

- One settings surface, replacing three status-bar menus and a separate drawer. - The HUD opens collapsed instead of expanding and running an animation nobody asked for. - Sign-up failures report themselves properly. A successful sign-up used to render the "cannot reach the server" banner because the data tag never matched what the screen was reading for. - Telemetry now has denominators: how many installs, which connectors get used, how old an install is. A failure count means nothing without them.

- App state is read from the directory git actually uses. Inside a linked worktree or a submodule the app used to look in the wrong place and report no merge in progress while one was. - An interrupted sync no longer locks the workspace out permanently. The marker saying "this merge was ours" was written somewhere it could silently fail, after which every later sync refused and told you to open a terminal. - Undo after a restore cannot be silently undone by a session finishing a turn while the restore is in flight. - The WhatsApp bridge writes a real rotating log, so a failure has something to show rather than an empty "Recent log:".

- Single-instance is not guaranteed on Linux. It claims a D-Bus name there, and with no reachable session bus it fails quietly and a second copy starts anyway. Windows and macOS use mechanisms that always exist. - Browser sign-in is proven for two of nine connectors. The rest use the same code path but have not been exercised end to end.

Backing up your chats to a private repository that belongs to you, and restoring them onto another machine. On Windows, the app now looks where Windows actually puts things. Reopening an old conversation brings the conversation back rather than an empty window, and a backup now tells you the truth about what it did instead of reporting success either way.

A panel that lists each one and what it is doing, updated as it happens.

A new version now stays hidden until every computer type is ready, so nobody is offered something that does not exist. Network addresses keep their first part. Update errors say what actually went wrong.

A route back in from an expired sign-in, a setup step that tells you what it needs, and the meeting recorder included from the start rather than being something to install afterwards.

Calendar access, a warning when a recording has heard nothing for a minute, and three new views: what you are working on, where your hours went, and whether your setup is healthy.

The bar takes its own row and pushes the page down. Plus the Brief panel.

Controls that drop their text labels before they drop themselves, so every one of them stays reachable however narrow the window gets. Everything the dashboard lists now opens.

A marker you can read without stopping to think, a visible line showing which chat came from which, and a way into what an agent is doing.

One answer, read by all three.

Conversations that come with you. Also thirteen loading animations that change shape depending on what kind of work is running, so the movement tells you something instead of just spinning.

The app ignores the invisible character.

Four honest states you can tell apart, a working indicator you can actually see, and links that open a file you already own on your own computer.

The chat is announced when you actually send something, so the two can no longer disagree. Chats also get real names instead of "New session", and the text size control now scales the whole app rather than the conversation alone.

The app asks in its own window, with Cancel selected by default. The delete button is also coloured differently at rest, so you can tell which one is dangerous before you click rather than after.

Real sign-up and sign-in, with your login kept in the computer's own secure store rather than a plain file. Setup down to five screens with no command line anywhere in it, and your usage, level and points connected to the member area.

All six, each with a test attached so they cannot quietly come back, and agents that survive on every provider.

Agent work shown as it happens, and the ability to split one chat into a separate chat per thing that needs you, each openable and finishable on its own.

It sizes itself to your window properly, fills the width, and shows work as it happens.

A skyline that is a record rather than a score. A step of work lays a floor, a finished answer tops the building out, something going wrong leaves scaffolding.

The wiring, back, and a release check that would have caught a whole block of controls going dead.

It now tries them and keeps only the ones that answer, and turns the raw error text into a sentence with a next step in it.

A panel beside the conversation that you can resize, move to either side, and which stays where you put it.

WhatsApp, with a pairing screen and a queue of messages waiting for your approval, so nothing goes out without you agreeing to it. The pairing code is generated on your own computer rather than through a website, so it never leaves the machine. Public downloads. And the app started asking you questions and showing you its plan rather than deciding alone.

The first full build.