Every release, in order.

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.