Every release, in plain language.

0.1.9-beta.88 19 September 2026 Desktop Latest

The things that stop you, and the work that ran behind them

• Threads that are not attached to a project stay put when the sidebar loads. If you have opened W1 and found threads missing, this was why, and it is fixed.
• Quitting W1 now closes everything it started. The app used to leave parts of itself running after the window was gone.
• W1 no longer runs background work you did not ask for: three separate jobs were starting on their own.
• Disk use is bounded again. A scanning guardrail that had been lost is back, and three directories that grew forever are now swept.
• The branch list no longer spawns git processes continuously - it was starting eight a second in the background.
• The sidebar's archive entry opens the archive rather than claiming to archive something, and says so: “View archive”.
• Choosing “a tool for my work” during onboarding now applies the design skill to your first build.
• Sending a message no longer looks acknowledged before the server has taken it, and your message no longer disappears while the previous turn is still settling.
• The flicker when a tool call starts is gone.
• Long prompts no longer fail with "Connection dropped". A big request used to be cut off after fifteen seconds while W1 was still thinking; it now keeps the line open until the first word arrives.
• Selecting text while W1 is running works, including after you have dragged a panel divider. Selection no longer stays locked until you restart.
• Build templates: the two templates that described work that was never built are now the real ones — a GitHub issue tracker wired to your own repos, and a billing desk that turns a quote into an invoice you can send on WhatsApp.
• Starting a build from a template opens the thread in the folder it just made, instead of a thread with nowhere to work.
• Picking a branch now tells you where your message is going. Choosing the branch a folder is already on stays in that folder; anything else says it will make a new worktree before you send, not after.
• The file cards under a reply no longer bury it. Only readable files get a card, at most four, and none at all when a turn touched only code.
• The task pill folds away when a plan has gone quiet, and comes back on its own when W1 picks it up again.
• Previews show what W1 just wrote. The page no longer serves the old version of a file it changed a second ago.
• Images stay visible. Attachments stopped loading after an hour; they are refreshed before they expire now.
• W1 stops re-reading a screenshot it has already seen, which is the single biggest saving found so far.
• An edit no longer fails with "has not been read this run" — W1 keeps track of what it read across a whole thread, not one turn.
• When an edit cannot be applied, nothing is written and every mismatch is reported at once, instead of stopping at the first.
• Opening W1 with an older version on newer data says "Update W1" with a download link, instead of spinning on "Starting W1…" forever.
• Running out of runs tells you when they come back, in your own time, with a way to upgrade — and the card updates itself the moment they do.
• When W1 is at capacity it says so, with a real wait, instead of blaming the model service and quietly retrying into the same wall.
• Background jobs report honestly: a wake that fired on time no longer says it failed.
• Search results say what they searched and what they skipped, so an empty result is never mistaken for nothing being there.
• A command-line tool can no longer answer its own "are you sure?" prompt for you on a destructive action.
• Sign-in status for plugins explains itself instead of showing a version number as the reason.
• The sidebar is a flat list of thread cards with a filter tray, and tags can be renamed, recoloured and deleted again.
• A short guided tour on first run, and onboarding no longer asks questions that change nothing.

0.1.9-beta.85 14 September 2026 Desktop

Workspaces, and a week of dogfood

• Workspaces. Group your projects under named workspaces in the sidebar: create one with the +, drag a project onto another workspace's row to move it there, right-click to rename or delete. Every workspace has its own page with project cards, and its own tags for threads, each with a name and a colour you choose.
• Drag threads to reorder them inside a project; the first drag switches that project to your order and keeps it.
• The launcher is one page again: New Chat, a project's pencil and a project card's New thread here all open the hero with recent threads, build modes and the branch picker. The app opens on it.
• Split view: clicking a file while the Files pane is in a split opens it in that pane, keeps the split, and the file tree keeps its scroll. The tab rail scrolls sideways smoothly.
• A wifi drop no longer disconnects you from your own computer. Account, usage and billing retry on their own after a network blip, with a Retry button if you'd rather not wait.
• Replies end cleanly: the duplicated final message and the empty bubble under a reply are gone.
• Image attachments show in your messages again after a restart. A plan pill no longer sits on top of the composer. Scrolling up on a freshly opened thread stays where you put it.
• If macOS blocks W1 from a folder, the thread says so plainly with the Settings path, instead of a raw error.
• Command-line tools installed with nvm, pnpm, bun or Homebrew are found when W1 is launched from the Dock. Diagnostics no longer lists tools you simply don't have as errors.
• The design canvas follows the app's theme, previews inline every time, and text and button colours change when you change them.
• Templates carry the W1 byline; the Stop me at menu no longer offers 100%.

0.1.9-beta.84 8 September 2026 Desktop

Settings, sacred

• Settings is the full page with the back button again, and everything lives there: Account, Usage, General, Preferences, Memory, Updates, Diagnostics, Help & docs, Remove W1 and Archive. The old profile page and the sidebar's Archive button are gone; every old link lands on the right section.
• The archive's project filter stops changing height as you switch projects.
• Run onboarding again from Settings → General.
• Referred by someone? Paste their link in onboarding or under your plan in Account for a free month of Pro, for both of you. The month is real now: a free account gets Pro's budget for 31 days, a paying one gets 31 days added, and repeat referrals queue one after another.

0.1.9-beta.83 8 September 2026 Desktop

One Settings

• One Settings page. Account, Usage, General, Preferences, Memory, Updates, Diagnostics, Help & docs and Remove W1 sit as tabs on the same side nav Archive uses; every old settings link lands on the right tab.
• Cancel works, and the app knows it: the plan row reads 'ends' instead of 'renews', the profile popup and Account update the moment you cancel, and a Resubscribe button brings you back. A new subscription keeps the days you had already paid for.
• Anyone without a live plan gets See plans in Account and in the profile popup.

0.1.9-beta.82 8 September 2026 Desktop

Your plan, in the app

• Paying shows up where you are. The plans screen notices the payment and shows the activation itself; Settings → Account names your plan, its price and renewal date, with Cancel that asks first and keeps your access to the end of the month you paid for; the profile popup shows the plan above Sign out.
• Payments has your history: every charge with its date, amount and receipt number, and a Resend receipt button per row.
• W1 has its own link scheme, w1://. Links from the web activation page open W1 and nothing else.

0.0.128 8 September 2026 VS Code

A cancelled subscriber gets a Resubscribe button in the…

• A cancelled subscriber gets a Resubscribe button in the plans row instead of an empty one, and a new subscription after a cancel replaces the old one cleanly: the week resets, the days already paid for are kept, and a late renewal notice on the cancelled subscription can no longer bring it back.
• Cancel works. Payfast's API refuses a timestamp with a zone suffix; every cancel since launch had failed on that.

0.1.9-beta.81 7 September 2026 Desktop

The meter tells the truth

• The context meter counts an attached image the way the provider does, about 1,300 tokens for a screenshot, not a quarter of a million. It no longer swings by half a million when a picture rides a call, compaction no longer fires on bytes it could never remove, and a compaction that would not help is neither attempted nor announced.
• Re-opening a page W1 already has open reuses that tab. A tab you have taken over is left alone, and a page already showing is not reloaded.
• Gruvbox is a third theme, and it survives a relaunch.
• Clicking a file in the tree keeps your split. The files-changed card closes when you open a diff. The plus button on a diff line opens a comment. Archive and Settings stop shifting when a scrollbar appears.
• The branch picker shows a pending state while it reads instead of vanishing. The launcher's placeholder text no longer draws a ghost copy. The Badges veil is unreadable again.
• Longest today counts the time W1 was actually working. A stopped command is named by the program that hung, never by cd, and never by the 1 in 2>&1.
• The Auto reasoning option is gone; it only ever ran Medium. Paid plans are live in Settings, with a receipt on every charge.

0.1.9-beta.80 7 September 2026 Desktop

The card, the ring, and the plans

• A failed turn is a card, not a reply. When W1 cannot continue — signed out, out of runs, the model service refusing, or you stopping it — the transcript draws a system card that says which, in its own colour, instead of W1 appearing to say it failed with a copy button and a report link beside it.
• Context compaction says so. When a long thread is folded down, a quiet line reads what happened, 250k → 48k, instead of the meter jumping for no visible reason.
• The working indicator is a ring of olive squares on a tumbling plane that tips edge-on and back, every square the same size. The rainbow and the shrinking squares are gone.
• Threads no longer leave a blank gap under short answers, or scroll you away from a finished reply. The Scroll-to-end button appears as soon as you leave the bottom, and scrolling down to the end resumes following on its own.
• Searching the sidebar opens the projects your matches are in, and puts them back when you clear it. Archive and Settings have a side nav instead of one long scroll.
• Plans are in Settings → Account, drawn from the server so the copy can change without an update. Nothing can be bought yet; the paywall is off. When it opens, a checkout can be carried: a QR code, a copy link, or a mail you can forward to whoever holds the card.
• The coming-soon veil is readable, Prints are Badges, the plugin page shows real vendor marks, the sidebar scrolls to the thread you are in, and a suggestion chip seeds the composer instead of sending for you.
• Sharing a page as a link works again. The client sent an alphabet the server refused, and a title without its key; both fixed.
• W1 no longer loses the browser after half an hour of non-browser work, and says what happened when it cannot use the browser. A fresh design canvas opens empty, with no phantom overlap warning.
• Run traces on disk are bounded by age, count and size, and the journal writes one durable line per event instead of three.

0.0.127 7 September 2026 VS Code

The context meter counts an attached image the way the…

• The context meter counts an attached image the way the provider does, about 1,300 tokens for a screenshot, instead of a quarter of a million. The meter no longer swings by half a million when a picture rides a call, and compaction no longer fires on image bytes it could never remove. A compaction that would not help is not attempted and not reported as one.
• A compaction's continuity note carries what W1 already did: receipts are promoted before the window evicts them.
• The Auto reasoning tier is gone from the settings pane. The engine only ever ran Medium for it; the picker now says so.
• A thread that opens with a hello names itself once real work shows up; "General Greeting" is a refusal, never a settled name.
• The browser tool's description tells the model the truth: tabs open in the background, and a url already open in one of its tabs is reused.
• Paid plans are live: Settings shows your plan, and a checkout can be carried as a link or QR.

0.0.126 7 September 2026 VS Code

A failed turn is a system card in the panel, not a reply:…

• A failed turn is a system card in the panel, not a reply: signed out, out of runs, the model service refusing, or stopped by you, each in its own colour. A thread that only says hello names itself once real work shows up. A session the server has refused is no longer claimed as live; a proxy's 403 no longer signs you out.
• The working ring is the signed-off one: olive squares on a tumbling plane, every square the same size.
• Copy and rewind are icons, timestamps show on hover, and the thought drawer opens with an animation that respects reduced motion.
• Plans in the sidebar, drawn from the server. Nothing can be bought yet.
• Sharing a page as a link works again (base64url, and the title's key).
• Run traces on disk are bounded; the journal writes one durable line per event; the design canvas opens empty on a fresh thread.

0.1.9-beta.79 5 September 2026 Desktop

The black window

• Clicking a browser tab could turn the whole window black. The browser panel asked its page a question before the page existed, the error escaped, and the app unmounted everything. The question now waits for the page, and the browser panel sits behind its own guard: if anything in it ever fails again, you lose the panel for a second, never the window.
• Element picking, annotations, the human-input channel and the design canvas's Send to W1 work again — the script that drives them had stopped loading in beta.77.
• Thread names are names. The naming step sometimes answered your greeting instead of labelling the thread; a reply is rejected now, and a thread that is only a hello is called General Greeting.
• Your avatar keeps its identity across the move to the new sign-in. An account carried over is seeded from the id it always had, so the mark you know stays yours.
• Thinking starts collapsed. Expand it when you want it; it no longer opens and then folds itself.
• The send button animates once per click.

0.1.9-beta.78 5 September 2026 Desktop

Every reply once

• Every reply rendered twice, on every turn. The engine ends a turn by repeating its answer as a closing summary, and both copies were being kept; the repeat is folded at the source now, and the transcript guards against it too.
• The plugins page opened in thirty-one seconds. Ten vendor sign-in checks ran one after another before anything drew; they run together now, off the reply, and the page opens in a few milliseconds.
• Updates download themselves once they are found, so a machine that never pressed Download no longer stays on an old build. If your disk cannot hold the update, W1 leaves it to you and says so instead of filling the disk.
• Files is one layout: the tree on the left, the preview on the right, and a splash when there is nothing to show.
• Run a diagnostic from Settings: twelve checks and a PDF you can send, with nothing secret in it by construction.
• Signing in on the new WorkOS Production keeps your account: your handle, your referral link and your earned months carry over, and only a verified email can inherit them.
• W1 can put a short notice in front of you from the server, dismissible, text only, and it fails to nothing if anything about it is wrong.
• Plan choice appears in account settings. Nothing can be bought yet; the paywall is off.
• The engine knows grep, reads several files in one step instead of one at a time, offers browser tools only when a browser is actually attached, and stops re-sending large file bodies it has since replaced.
• The support toast only promises an email when one was actually sent. The agent cursor in the preview moves for typing and scrolling too, and clears when the tab closes.
• Analytics can finally tell the desktop app, VS Code, the CLI and the backend apart, and attribute a turn's cost to the person who ran it.

0.1.9-beta.77 5 September 2026 Desktop

Lighter, faster, and locked down

• W1 starts in a third of a second on a long history instead of three, and holds a tenth of the memory it did. The thread journal was being loaded whole on every boot; it is compacted now, with every event kept.
• Four threads run at once, up from two. When every slot is busy W1 says so on the turn instead of wedging the engine, and a worker exits when its thread is done rather than sitting idle in memory.
• W1 stops growing your disk: run traces are a tenth of the size, old ones are cleaned up, and the first start after updating reclaims what was there.
• A new thread launcher, on the thread's own composer, with Build Templates and a design template that turns an edit you make in the preview into a targeted change to the code.
• The reply streams as it is written, in one bubble, instead of landing whole at the end. The working mark is a saucer, and the context dial lights before your first message and shows the thread's real size.
• Notifications: W1 tells you when it is waiting on you or done, as a system notification when the window is not in front, and a bell in the sidebar keeps only the threads that need you. On Windows every notification was being dropped silently; fixed.
• Security: a plugin's server no longer receives W1's own keys; reading credential files, saving cross-project memory and sending data off your machine now ask in supervised modes; a repository's instruction files are treated as reference rather than authority; and run traces on disk are readable only by you and never upload command lines or file bodies.
• Nothing you see carries the upstream fork's name any more: your data lives in ~/.w1, branches and checkpoint refs carry W1's name, and the password prompt is W1's own.
• A tool call is never used as a thread title, and a copied opening line is rejected. The greeting says your name on the first painted frame, never a mangled email.
• Screenshots from W1's browser stop coming back transparent, W1 honours the tab it named and bounds the tabs it opens, and a page in the pane can draft into the composer.

0.0.125 5 September 2026 VS Code

Thread names are names again. The naming call sometimes…

• Thread names are names again. The naming call sometimes answered your greeting instead of labelling the thread ("Hello! How can I help?" as a title); a reply is now rejected and a greeting-only thread is called General Greeting.
• Your avatar keeps its identity across the WorkOS move. An account carried over from the old sign-in is seeded from the id it always had, so the mark you know stays yours instead of being replaced by a new one on your first sign-in.
• The extension reports itself as VS Code in analytics rather than borrowing the desktop's name.

0.0.124 5 September 2026 VS Code

W1 in VS Code now reports what happens. Every public build…

• W1 in VS Code now reports what happens. Every public build before this one shipped without a telemetry key, so the extension and the engine it runs had never sent a single event — which is how VS Code ran on the wrong model for five releases without a number moving. Usage and errors now reach W1's production analytics, tagged as the VS Code surface, under the same identity as the desktop app. The VS Code telemetry setting still turns it off.
• Your sign-in survives the move to WorkOS Production: a returning account keeps its handle, its referral link and its earned months, and only a verified email can inherit an account.
• Plan choice appears in the W1 settings view. Nothing can be bought yet; the paywall is off.
• The engine underneath: a `grep` tool, parallel read-only batches (fewer model calls on the same work), browser tools advertised only when a browser is actually attached, superseded file bodies replaced with a stub once they are large enough to matter, and a cost estimate on every model call.
• Server-driven notices: W1 can put a short message in front of an installed build without shipping a new one. It is text only, dismissible, and fails to nothing.

0.0.123 5 September 2026 VS Code

W1 in VS Code is back on GLM. For the last few releases the…

• W1 in VS Code is back on GLM. For the last few releases the extension had been routing to a different model than the desktop app; both run the same model now.
• Full access asks for nothing. When you have chosen Full access, W1 no longer stops for fetches, installs, pushes or deploys. Supervised modes still confirm, and a session grant is exactly as wide as the card you approved, never wider.
• A turn runs in the folder its thread lives in, and the header shows which folder that is.
• The panel's dark palette is the desktop's, one to one, and light mode matches it. The tab title is the thread's title, and a rename you make outranks the engine's.
• The chat feed catches up with the desktop: tool rows, the working indicator, turn meta and the report copy all match.
• The working mark is a saucer instead of three dots, and the context ring lights when a turn starts and at rest.
• W1 can list, name and drive its browser tabs, and stays on the tab it named.
• W1 can publish an artifact: encrypted on your machine, and it asks before anything leaves it.
• The engine underneath starts in a third of a second on a long history instead of three, runs four threads at once instead of two, says so plainly when every slot is busy, and cleans up the workers a finished thread leaves behind. Run traces on disk are readable only by you and never upload command lines or file bodies.
• Security: a plugin's server no longer receives W1's own keys; reading credential files, saving cross-project memory and sending data off your machine now ask in supervised modes; a repository's instruction files are treated as reference rather than authority.
• A tool call is never used as a thread title, and a copied opening line is rejected.

0.1.9-beta.76 4 September 2026 Desktop

Everything you reported

• Files W1 writes show up in the Files panel — including images, and in folders that are not git repositories. They were being listed and then quietly removed again by the next scan, so the file was on disk and invisible.
• A long command tells you what it is doing. The working indicator names the command and counts up against its limit, and when W1 stops one for running too long it says so in the thread instead of leaving a silent spinner.
• Thinking streams again, before the reply rather than arriving with it, and the working indicator stays above the composer for the whole turn instead of sliding underneath it. Scrolling up still stops it following.
• The signed-out state no longer flashes on a cold start when you are signed in, your name and picture are there from the first frame, and the window opens on W1's own colour instead of a white frame.
• A new Auto thinking level, now the default: W1 decides per step and thinks harder when it gets stuck. Build and Plan match the size of the controls beside them, and the shortcut tray grows and shrinks instead of snapping.
• Sign out of a single site in W1's browser, not just all of them at once.
• Scheduled check-ins appear as what they are instead of as messages from you — and a long-running check no longer fills the thread, or its own memory, with them.

0.0.122 4 September 2026 VS Code

Light mode is properly light. Quoted text, inline code,…

• Light mode is properly light. Quoted text, inline code, keyboard keys, links and scrollbars were being painted by your editor's colour theme instead of W1's, so they stayed dark on a light panel — quoted prompts came out as unreadable dark slabs. They all follow W1 now, and W1's light palette matches the desktop app exactly.
• Every open W1 tab follows your theme, not just the one in front.
• Setup no longer reloads the window, and never asks you the same thing twice — including when you sign in partway through. If a folder is already open, W1 uses it; if that folder has files in it, W1 makes one inside it for this build and tells you which. If nothing is open, it asks you where.
• Your brief appears as your own first message in the thread. So does anything else W1 starts on your behalf, instead of an answer arriving with nothing above it.
• Your picture in the sidebar is your W1 mark — the same one the desktop app and setup draw. Clicking your name or picture opens settings; the separate gear is gone.
• The context meter is a ring that matches the desktop app, and turns red when you are nearly full.
• Every chip above the composer has an icon, and the task chip is centred and narrower.
• The "Finish setup in the W1 tab" panel sits in the middle of the sidebar instead of the top-left corner.
• W1 can browse. Opening a page, clicking, typing, scrolling, resizing and screenshotting all work from the panel now — where VS Code's own browser tab is available W1 drives that, and everywhere else it opens its own browser window automatically.
• A command that hangs stops after 90 seconds instead of five minutes, and W1 can set its own shorter or longer limit — so a stuck command no longer reads as minutes of silent thinking. Deploys and global installs are told to ask for the longer limit they need.
• When you have trace sharing on, W1 no longer sends the text of a command that ran too long.
• Affinity connects again. W1 was calling it at the wrong address.
• W1 designs in Affinity itself now, rather than handing the work to a separate assistant that could not see what it had drawn.
• Scheduled check-ins show as what they are instead of appearing as messages from you, and a run of identical re-checks collapses into one line with a count.

0.1.9-beta.75 3 September 2026 Desktop

The morning-after fixes

• Older threads no longer restart the engine on every message. Threads created before the engine change were being cold-started each turn, which showed up as flickering stop buttons, a blinking working indicator and stray 'Worked for 23ms' rows. Now they compact once and continue fresh.
• Full access means full access. W1 no longer stops to ask before fetching from the web, installing packages, pushing or deploying. It still asks, in every mode, before touching credentials, its own configuration, login items, system settings, payments or email. A plain download was also being flagged because of an unrelated flag later on the line; fixed.
• Servers W1 starts keep running after the turn, and W1 can list, read and stop them.
• Light mode is back to the neutral greys, in the app and in setup. Setup's send button is the app's own. The stray control trio at the top right of the tab strip is gone.
• No more false 'the question didn't render' banner while an approval card is waiting for you.

0.1.9-beta.74 3 September 2026 Desktop

The browser stops getting stuck, and sign-in works

• A hidden browser tab no longer wedges a turn. Snapshots always come back with the page text and elements, even when a screenshot cannot be taken, and W1 is told exactly what to do about it instead of retrying blindly.
• W1's browser tabs open in the background. Chat keeps focus, agent tabs carry a small W1 mark and a live dot, and a notice offers to open them. W1 only brings a tab forward when it needs you to look.
• Sign in with Google, GitHub, Microsoft and the like now works inside W1's browser. Pop-up sign-ins open as a real window and return to the page, and you stay signed in across projects and restarts.
• See where your context goes. The meter next to the composer breaks the window down by messages, tools, MCP tools, memory, skills and system prompt, with free space and your usage limits.
• Plugin status is honest on every platform: a tool that isn't installed says so instead of telling you to log in.

0.1.9-beta.73 3 September 2026 Desktop

A proper first hour, and a light theme

• New setup. The first launch after this update walks you through it once: your mark, light or dark, what you're making, where it lives, and how to write a brief that gets a good result. It ends in a real thread with your brief already sent. If a newer W1 exists it asks you to update first.
• Light theme. Bone paper, charcoal ink, the same olive. Pick it in setup or in Settings, or match your computer.
• Your mark is yours for good. It is drawn once from your account and stored, so it never changes between launches or machines, and it no longer sits in a dark box.
• Set how W1 works with you: ask first, ask only for risky things, or just do it; and how much it explains as it goes. New threads start from those choices.
• Long commands can no longer hang a turn. Shell commands stop after five minutes and the browser tools after one, and W1 is told what to do instead of guessing around a stuck tool.
• W1 looks at screenshots and rendered images from its own tools directly instead of reading a description of them.

0.1.9-beta.72 3 September 2026 Desktop

Everything is a tab

• The side panel is gone. The chat, your browsers, terminals, files, and changes are all tabs in one strip across the top, each opening full size in its own tab. Drag tabs to reorder them.
• Split the screen. From the helper or a tab's menu, pair the tab you are on with any other open tab and drag the divider between them. Put chat on one side and the browser on the other to get the old layout back, or two browsers, or a terminal beside a file.
• The helper now expands in place. The expand arrow opens the helper into a labelled list that explains what each item opens, and every item opens a fresh tab.
• Hover a tab for a preview. Browser tabs show a thumbnail of the page; files, terminals, and changes show where they point.
• Code panels stopped drawing lines through your code. Indent guides now sit only in the leading whitespace and match the file's real indent width, in files and in diffs.
• The chat header is gone. The thread's name is its tab, and the open-in and GitHub controls moved to the Files and Changes toolbars.

0.0.121 3 September 2026 VS Code

Full access means full access. W1 no longer stops to ask…

• Full access means full access. W1 no longer stops to ask before fetching from the web, installing packages, pushing or deploying when you've chosen Full access. It still asks, in every mode, before touching credentials, its own configuration, login items, system settings, payments or email.
• Servers W1 starts keep running. A dev server or watcher started in the background survives the turn; W1 can list, read the logs of, and stop them, and they are closed when the thread is archived.
• Older threads start fresh on the new engine: the first message after the engine change compacts the thread once, so it continues cleanly.
• A plain download command was being flagged as "sends data off this machine" because of an unrelated flag later on the same line. Fixed.

0.0.120 3 September 2026 VS Code

New setup. The next time you open W1 it walks you through…

• New setup. The next time you open W1 it walks you through it once, in the W1 tab: your mark, light or dark or match VS Code, what you're making, where it lives, and how to write a brief that gets a good result. It ends in a real thread with your brief already sent. If a newer W1 exists it asks you to update first.
• Your mark is drawn once from your account and stored, so it is the same in VS Code and on the desktop, and never changes.
• Set how W1 works with you during setup: ask first, ask only for risky things, or just do it. New chats start from that choice.

0.0.119 3 September 2026 VS Code

You now choose how much W1 may do on its own: Supervised,…

• You now choose how much W1 may do on its own: Supervised, Auto-accept edits, or Full access, per thread. Risky commands and actions on external sites ask you first with a clear card: Allow, Allow for session, or Deny. Approvals survive a reload.
• See where your context goes. A meter next to the composer shows how full the window is; click it for a breakdown by messages, tools, MCP tools, memory, skills and system prompt, plus your usage limits.
• Settings live in the W1 sidebar now: theme (light, dark, match VS Code), narration, telemetry, default access mode and thinking level, confirmations. Profile menu, contact support with screenshots, thread search, archive, delete, pin, mark unread, copy thread id, and a "needs you" indicator on threads waiting for an answer.
• Light theme.
• A Plugins page: see what's connected, sign in, enable or disable.
• Rewind a turn from VS Code, with a preview of exactly which files it will restore.
• Real Plan mode that only reads, a thinking-level chip, and copy buttons on messages and plans.
• The composer and task card line up with the text column, the "Thinking…" label stops flickering, and long-running commands can no longer hang a turn: shell commands get a five-minute wall and the browser tools get a one-minute wall with clear next steps.
• W1 can look at images returned by its own tools directly, with a per-turn budget.

0.1.9-beta.71 2 September 2026 Desktop

A new engine, and W1 stops going quiet

• W1 runs on a new default model that is faster and far cheaper per turn, and it can now see the images you attach directly. Older installs keep working exactly as before until they update.
• Coming back after leaving W1 open no longer costs you two or three minutes of silence. W1 keeps the thread you are looking at warm, wakes its connection the moment your machine does, and no longer lets background housekeeping pile onto the reconnect.
• Pick how hard W1 thinks. A Thinking control in the composer sets Low, Medium, or High per thread.
• Code stops wrapping. Files and diffs scroll sideways with a fixed line-number gutter and indent guides, like an editor.
• The right panel folds into a small rail with Changes, Browser, Terminal, and Files buttons that open straight to that tab.
• Thread names arrive reliably and come from what you asked, not from W1's greeting.
• Windows launches show W1 immediately, keep a boot log, and give you a Retry if the engine cannot start, instead of sitting on nothing.
• W1 can now hand off a self-contained chunk of work to a background worker that writes code while W1 keeps going, with strict limits so it is used only when it pays off.

0.0.118 2 September 2026 VS Code

W1 runs on a new default engine that is faster and far…

• W1 runs on a new default engine that is faster and far cheaper per turn, and it can now see the images you attach directly instead of describing them second-hand.
• Thread names arrive reliably and come from what you asked, not from W1's greeting.
• W1 can hand a self-contained chunk of work to a background worker that writes code while W1 keeps going, with strict limits so it is only used when it pays off.
• Set how hard W1 thinks with the W1_REASONING_TIER setting (low, medium, high); a picker in the panel follows in a later update.

0.1.9-beta.70 27 August 2026 Desktop

The browser's first look stops stumbling

• Taking a visual snapshot right after the browser opens no longer stalls the panel for half a minute. Capturing the page's pixels could silently wait on a frame that wasn't ready yet, and every browser action queued behind it in the meantime. The capture now gives up cleanly within ten seconds and the next action runs immediately.

0.1.9-beta.69 27 August 2026 Desktop

Long threads stop paying the same bill twice

• A long conversation now compacts its context once, not on every message. The result of compaction was never carried into the next turn, so each new message re-read and re-folded the entire thread — that is why a “Context compacted” chip appeared before nearly every reply. One compaction now stands until the thread genuinely outgrows it.
• The browser panel can no longer wedge for the rest of a session. If a page hung mid-load (for example when a local dev server died), one stuck browser command silently blocked every later snapshot, click, and evaluate. A stuck command now fails on its own within ten seconds with a clear message, the automation session resets itself, and the very next action works.

0.0.117 22 August 2026 VS Code

Your messages sit against the right edge again and thinking…

• Your messages sit against the right edge again and thinking blocks against the left. 0.0.115's reading-width change had been sizing every row instead of the column, which overrode their alignment.
• W1's thinking no longer flickers. Reasoning that resumed after a burst of narration was starting a brand-new block each time — several a second, each one animating in. It now continues the same thought.
• The W1 mark on chat tabs is olive instead of black, so it is visible against a dark tab.

0.0.116 22 August 2026 VS Code

The W1 mark now sits in the editor title strip, beside the…

• The W1 mark now sits in the editor title strip, beside the split-editor button. One click starts a new chat from anywhere in your editor.
• Removed the duplicate "W1" heading in the side panel — VS Code already titles the view.

0.0.115 22 August 2026 VS Code

W1's thinking no longer strobes while it thinks. The…

• W1's thinking no longer strobes while it thinks. The reasoning block replayed its entrance animation on every token that arrived; answers were already exempt, reasoning was not.
• One chevron everywhere. The thinking dropdown drew a different arrow from every other disclosure in the transcript.
• W1's own sentences are no longer clipped. A line of narration promoted into a step header was cut to one line with an ellipsis, so you could not read what it said.
• Chat tabs carry the W1 mark, so a conversation is findable in a strip of open files.
• The transcript and the composer keep a readable column width in a wide editor tab instead of stretching edge to edge.
• The side panel gained the usage bars, the update button and sign-out, and the chat tab's hamburger menu is gone — one place for all of it.
• Fixed a "New conversation" appearing in the list for a conversation nobody had started.

0.1.9-beta.68 21 August 2026 Desktop

The chat stops flinching

• Sending no longer flashes a finished-turn card at you. For a few frames a brand-new conversation claimed the turn had already completed in 267ms before going back to thinking; the very first message of a thread was the one case the existing guard could not catch.
• W1's answer is no longer printed twice. The completed response was also being rendered as a line of work underneath itself, with its paragraphs run together, until the turn collapsed and hid it.
• Sending from the launcher no longer looks like nothing happened. The new conversation sat on “Send a message to start the conversation” for several seconds while your message waited for the workspace to connect — it now says Starting, because it is.

0.1.9-beta.67 21 August 2026 Desktop

Your message stops jumping when you send it

• Sending a message no longer makes it flicker as W1 starts working. Your message was quietly being replaced by a second copy of itself the moment the turn began, which redrew the bubble — it is one message now, from the moment you press send.
• The thread no longer scrolls up and snaps back after you send. Moving your new message near the top is deliberate; losing that position mid-scroll was the same replacement, and it is gone.
• A screenshot you attach keeps its preview in your own message instead of turning into a file name once the turn starts.
• W1 waiting for its engine to start now says so in the conversation, where the working indicator is, instead of opening a red error banner. Nothing has failed — it is starting, and your message will run.

0.0.114 21 August 2026 VS Code

The side panel is now a list of your conversations with a…

• The side panel is now a list of your conversations with a **New chat** button, and the chat itself opens in an editor tab. No more chat in the sidebar and a copy of it in a tab — one place for the conversation, one place for the index.
• Clicking a conversation opens it, the way clicking a file does. Several stay open side by side and come back after a reload.

0.0.113 21 August 2026 VS Code

Conversations now open in editor tabs by default. Picking a…

• Conversations now open in editor tabs by default. Picking a chat opens it the way picking a file does, so several stay open side by side instead of one panel you keep swapping. 0.0.112 shipped this as a command you had to find in the palette; now it is simply how it works.
• Turn it off with the **W1: Chat Tabs** setting if you prefer everything in the single side panel.

0.0.112 21 August 2026 VS Code

Each conversation can now open in its own editor tab, so…

• Each conversation can now open in its own editor tab, so several chats stay open side by side instead of one panel you keep switching. Open the current chat in a tab from the command palette: **W1: Open Chat in Editor Tab**.
• Chat tabs come back where you left them after a window reload, still on the same conversation.
• Closing the side panel no longer ends work that is still running in an open chat tab.

0.1.9-beta.66 19 August 2026 Desktop

Thread names that survive a cold start

• A fresh installed app now retries the small model-derived naming call with a new provider when the first cold request fails, instead of leaving the conversation as New thread.
• Completed answers remain immediate while W1 keeps the worker alive just long enough for the semantic title frame to land; prompt truncation is never used as a fallback name.
• Packaged desktop runs now carry the exact app version and harness BUILD_ID into the in-process worker, so diagnostics can prove which signed engine actually handled a turn.

0.1.9-beta.65 19 August 2026 Desktop

Your work is visible again

• W1's working narration now appears as real assistant prose instead of disappearing while only tool rows remain. It stays visible when you reopen the thread or restart the app.
• New conversations receive a short model-derived name within seconds, even while a long task is still running or later gets interrupted.
• Thread naming runs independently from the main task, so it cannot hold a completed answer or tool execution behind a title request.

0.0.111 19 August 2026 VS Code

Model-derived conversation names now retry with a fresh…

• Model-derived conversation names now retry with a fresh naming provider when a cold first request fails, instead of leaving the thread as “New thread.”
• Completed answers remain immediate while W1 keeps the worker alive long enough for the semantic title frame to land.
• Thread names continue to come from conversation context; W1 never falls back to truncating the opening prompt.

0.0.110 19 August 2026 VS Code

Working narration now survives the durable engine…

• Working narration now survives the durable engine projection and reloads as visible assistant prose instead of disappearing while tool rows remain.
• Thread naming starts in parallel with the first turn, so a long or interrupted task receives a short model-derived name within seconds instead of staying “New thread” until completion.
• Completed answers are never delayed by the naming call; fast turns finish immediately while the bounded title task drains independently.

0.1.9-beta.64 18 August 2026 Desktop

See work the moment it starts

• Tool calls now appear immediately and fill in with their output when the work finishes. Long commands and image inspection feel responsive while still showing honestly what is running.
• Tool outputs stay with the right action and image tools show the image W1 inspected, with scrollable details instead of an unreadable wall of collapsed calls.
• Questions, approvals, follow-up messages, and attached images settle reliably. A stale interaction can no longer trap the conversation, and an image queued while W1 works remains visible and reaches the next turn.
• Conversation names are derived from the completed context and update live in both the header and sidebar instead of remaining New thread or clipping the first prompt.
• macOS now creates one main window even when startup and activation race, removing duplicate hidden renderers that wasted memory and made an idle app feel heavy.

0.0.109 18 August 2026 VS Code

Tool calls now appear the moment W1 starts them, then fill…

• Tool calls now appear the moment W1 starts them, then fill in with their output when the work finishes. Long commands and image inspection feel immediate without hiding what is still running.
• Tool results stay attached to the right action, including image previews, so you can inspect what W1 saw instead of guessing from a collapsed label.
• Questions, approvals, follow-up messages, and attached images settle reliably without leaving a conversation stuck behind an old interaction.
• Conversation names are derived from the completed context and update live instead of remaining “New thread” or clipping the opening prompt.

0.1.9-beta.63 17 August 2026 Desktop

What you send is what W1 receives

• Images now survive every send path. A picture attached before creating a chat reaches the new thread as real bytes, and an image sent while W1 is already working reaches that same run instead of expiring unseen.
• Threads keep their full history through switching and restarting, with completed work grouped in order above the final answer. W1 no longer loses replies, duplicates messages, or lets new output steal the page after you scroll away.
• Conversation names are written from the completed context instead of clipping the first sentence. The branch selected for a thread is also the branch W1 is told to use, rather than something guessed from a folder name.
• Questions, approvals, Stop, and follow-up messages release the thread cleanly. Stale cards dismiss once, stopped work stays stopped, and cleanup can no longer kill the agent that is still finishing your task.
• Visual work now uses an isolated design specialist that owns its document, compares the latest render, and corrects it before the final handoff. Plugin state is ready when the app opens, and Plan mode and scratchpad boundaries remain enforced.

0.0.108 17 August 2026 VS Code

Messages sent while W1 is working now reach that active run…

• Messages sent while W1 is working now reach that active run reliably, including attached images. W1 inspects the real pixels instead of losing the attachment or replaying the correction later as a separate task.
• Long-running work no longer gets killed by its own cleanup. W1 removes processes a task started while preserving the agent that is still completing your request.
• Visual work is more deliberate: W1 can delegate to its design specialist, keep each conversation's design state separate, compare renders, and correct the latest result before handing it back.
• Conversation names are derived from the completed context. A clipped opening sentence is rejected and retried instead of becoming the permanent title.

0.1.9-beta.62 15 August 2026 Desktop

Steer the run you're watching

• Send a message while W1 is working and it lands IN the run — W1 folds your correction into what it's doing at its very next step, instead of quietly saving it to run as a confused new turn twelve minutes later. If a run ends before your message got in, the transcript says so plainly and offers one-tap Send again. Pressing stop clears the queue: taking back control means exactly that.
• A request that goes silent can no longer hang a run: if the model streams nothing for four minutes, W1 kills the request and retries or fails honestly — the 19-minute frozen turn class is gone. And a thread whose run died while the app was closed wakes up idle and ready, never stuck 'thinking' at a message that goes nowhere.
• Threads name themselves properly now: a real title drawn from W1's first answer fades in moments after you start, and it never changes again. The one-more-rename-every-turn behavior is over.
• Images attached in the launcher finally arrive in the chat — the third report was the charm: the durable first-message record was written before the image was, and it won. Now it carries the image itself.
• Answering W1's questions got its own input box on the question card: your half-typed answer survives switching threads, submitting never leaves stray text in the composer, and the composer stays yours throughout.
• The periodic 'Is this still the goal?' interruption is deleted.
• Under the hood, W1's helpers grew memories: the workspace-search agent remembers what it already established in your thread (no re-crawling), W1's eye remembers every image you've shown it and can tell you what changed between them, and a new image-native design agent can build a design in Affinity from your reference — rendering and correcting its own work until it matches.

0.1.9-beta.61 15 August 2026 Desktop

Old threads are first-class again

• Reopening an old thread now shows the real work: every tool call renders with its actual description and its output — inputs, results, failures — exactly like it looked live. The walls of “Tool event” and “Runtime event” are gone, and threads recorded by earlier versions get the same treatment retroactively, including long runs you thought were lost.
• Sending to an old thread can never be refused again. Right after an update, the engine hand-over window could reject messages to existing threads; now the send always goes through and the app catches the thread up in the background.
• “You stopped W1” only appears when you actually pressed stop. Runs ended by the system now say so honestly, so a dead run can never be blamed on you.
• Very long runs stay smooth: the transcript batches its refreshes instead of re-rendering on every one of hundreds of events, and a timed-out helper process can no longer leave silent survivors behind.

0.1.9-beta.60 14 August 2026 Desktop

Hotfix: beta.59 could not run turns

• beta.59's packaged engine worker crashed the moment it started — every message failed instantly with “The run ended unexpectedly.” The cause was a packaging fault in the new plugin-tools client, invisible to source-based tests; it is fixed, and the build pipeline now boots the real packaged worker before any release can ship.
• Everything beta.59 promised is in and working here: the memory-leak kill, the idle-CPU fix, the scroll rules, the honest local-engine copy, released turns, steered images, avatars, and the live Affinity tools.

0.1.9-beta.59 14 August 2026 Desktop

The app that stays out of your way

• Found and killed the memory monster: an internal debug record was being saved at full weight on every model call — megabytes each — until the app could eat all the RAM on the machine. It is gone at the source, existing threads are protected, and the app now watches its own memory so a leak can never hide again.
• An idle W1 is actually idle now. The app was silently spawning one process per second around terminals nobody had open — roughly 86,000 a day. It spawns nothing unless you are actually watching a terminal.
• Nothing scrolls unless you ask. Tool calls and streaming responses never move the page; auto-follow turns on only when you press Scroll to end, and any upward scroll gives you the page back. Opening a thought process or tool drawer animates smoothly in place instead of yanking the view.
• A failed turn releases the thread. Messages can no longer pile up behind a dead run as permanent “queued” ghosts — they run as their own turns, and a steer can now carry images.
• Your own computer is not a remote server. The old “Lost the connection to <your machine>” wording is gone: W1's local engine restarts and recovers quietly, and only speaks — plainly — when it genuinely cannot.
• The first message after reopening the app can no longer vanish. If the engine is still waking up, W1 says so and keeps your draft instead of losing your words.
• If the display process ever crashes, the window brings itself back in seconds and tells you what happened — no more black window waiting for View → Reload.
• Closing the terminal you launched W1 from can no longer crash it (the EPIPE class TK hit), on the desktop, the engine, and the VS Code extension alike.
• Windows: timed-out git operations now kill their whole process tree and never stack — the orphaned git.exe pile-ups that could lock a repository and freeze the app are over.
• The Affinity plugin now really works: W1 ships a real MCP client, connects to Affinity's own tool server, and was proven live against a real board — script execution to rendered pixels. Avatars are back for everyone, healed automatically on older installs.

0.1.9-beta.58 14 August 2026 Desktop

Talk to W1 while it works

• Send a message while W1 is busy and it queues — visibly, right in the conversation — then runs as the next turn the moment the current one finishes. One button does the right thing: red stop while the composer is empty, the ordinary send arrow the moment you type. Desktop and VS Code both.
• Several messages sent in a row — including while signed out — each become their own turn now. Before, everything but the last one could silently vanish on the way to the model.
• Switching away from a running thread and back can no longer kill the run. The whole “W1 stopped before finishing this turn” class traced to one bug, and it is gone.
• The transcript tells the truth: tool rows appear the moment a call starts and read as plain English, status pulses no longer masquerade as tools, and the turn summary counts only real work.
• Plan mode is enforced at the tool layer on W1's own engine — read-only means read-only, and W1 says so instead of quietly editing.
• The Affinity plugin is live. Connect it and W1 arrives already knowing the SDK, the silent-failure traps, and how to check its own work by rendering what it drew.
• Sign-in can never strand you on a dead button again: clicking again supersedes the old attempt and opens a fresh tab immediately.
• Quit is bounded, the window appears at launch instead of after the backend, and updates now measure their own relaunch time so slow machines show up in data instead of anecdotes.
• Your thinking blocks survive restarts, questions always reach the composer, avatars are yours and stop changing, and the launcher remembers your draft — text, images, branch — even across a restart.
• Windows: every release now passes a real Windows lab — a live turn, the engine on real named pipes, and the full new-feature surface — and the update flow was reproduced end to end over a running app with zero orphan processes.

0.1.9-beta.53 13 August 2026 Desktop

The engine outlives the cleanup crew

• Fixed the first conversation working and everything after it failing. Internal housekeeping that used to clean up a finished session was accidentally shutting down the engine for the whole app; the engine now lives exactly as long as the app does.
• Messages can no longer disappear silently after that shutdown — because the shutdown is gone.

0.1.9-beta.52 13 August 2026 Desktop

The engine lives inside the app now

• W1's engine no longer runs as a separate background process the app has to find and talk to — it lives inside the app itself. “Local engine unavailable” as a category of error is gone: there is nothing to reach, so nothing can be unreachable.
• On networks where IPv6 exists but doesn't actually work, W1 now reaches its backend over IPv4 instead of timing out. This alone was killing every turn on some Windows machines, on every surface.
• A failed turn now shows its own real reason in the conversation, and never dresses up as an engine problem in a banner.
• Opening the new version shuts down any engine processes left behind by older versions, so an update always starts clean.

0.0.107 13 August 2026 VS Code

W1's engine now lives inside the extension itself instead…

• W1's engine now lives inside the extension itself instead of running as a separate background process. "Local engine unavailable" as a class of error is gone — there is nothing to reach, so nothing can be unreachable.
• On networks where IPv6 exists but doesn't route, W1 reaches its backend over IPv4 instead of timing out. This was silently killing every run on some machines.
• Closing a chat panel no longer disturbs work in progress; the engine winds down only when the window itself closes.

0.1.9-beta.51 12 August 2026 Desktop

Windows heals itself

• On Windows, W1 can now replace a stuck engine left behind by an older version — before, it could see the engine was stuck but had no way to find and stop it, so it gave up with an error. This was the failure that ate every turn for some Windows users.
• If connecting to the engine fails for any reason at all, W1 now starts a fresh engine instead of showing “Local engine unavailable”.
• Installing W1 from the website now shuts down anything left over from an older or broken install first, so a fresh download is a clean start. Your threads and sign-in are untouched.

0.1.9-beta.50 12 August 2026 Desktop

The error that told you the wrong thing

• When a turn fails because you're not signed in, W1 now tells you to sign in — instead of reporting an unexpected runtime error and suggesting a retry that could never work. Windows users have been hitting exactly this.
• W1's engine now reports its failures to us automatically, so a broken release gets caught the day it ships instead of the week after.

0.1.9-beta.49 11 August 2026 Desktop

Every Mac, and Linux too

• W1 for Mac runs on Intel Macs again, not just Apple silicon. The download page had been offering a universal build while shipping an Apple-silicon-only one, so an Intel Mac got an app that could not open.
• Linux is current again — the download was 29 releases behind and predated W1's engine entirely.
• Archiving a thread that is already archived no longer shows an error for something that worked.
• Connecting a plugin says "Connecting…" while it connects, instead of looking stuck.
• Affinity and Paystack now say coming soon rather than offering a Connect button that cannot finish.

0.1.9-beta.48 11 August 2026 Desktop

W1 starts, even when the old one is still running

• Fixed W1 refusing to open with "Local engine unavailable" after an update. An engine left behind by the previous version held the connection, and the new one would neither use it nor replace it. It replaces it now — and it never interrupts work already in progress.
• W1 no longer treats one beta as identical to the next, which is what made an update look like a conflict instead of an upgrade.

0.1.9-beta.47 11 August 2026 Desktop

Send lands where you sent it

• Sending from the launcher is one motion now. Whether you press Enter or the send button, your message goes straight into the thread and W1 starts — instead of landing beside an idle send button, sitting there for a beat, then submitting itself.
• Fixed being unable to send at all: the send button could sit spinning with your message stuck in the box and no thread ever created.

0.1.9-beta.45 11 August 2026 Desktop

It fixes itself

• W1 heals its own engine. If an old or stuck engine was holding the connection, W1 refused to open and told you to quit and reopen it — or showed "Local engine unavailable" with nothing you could do. It now takes the connection back on its own. The only thing that can stop you is a genuinely out-of-date W1, and it says exactly that.
• Updates take. Every beta build compared as the same version underneath, so updating could leave you unable to start.
• The chat moves properly. Replies, commands, tool results and thinking ease in instead of snapping into place, and everything that opens on click opens gently. Reduced-motion settings are honoured.
• Sending from the launcher is one motion. Your message used to land in the thread next to an idle send button, pause, then send itself. Now it just sends.
• The Completed label is W1's own olive, matching Working and Awaiting input.

0.1.9-beta.44 11 August 2026 Desktop

You can talk to W1 while it waits

• Messages you send while W1 is waiting on something now get answered. They used to disappear — W1 would reply "Waiting on …" to whatever you asked, and your message was never read at all.
• When W1 starts a wait, it tells you what it is waiting for in its own words instead of a stock line, and that reply stays in your thread.
• A wait no longer fills the conversation with repeats of your own message every time W1 checks back.
• Sending a support message with a screenshot works. Screenshots were quietly too large to send, and the app blamed your connection for it.
• When something does go wrong sending support, W1 now tells you what actually happened.

0.1.9-beta.43 11 August 2026 Desktop

Updates that actually take

• Fixed W1 refusing to start after an update with "Local engine unavailable". An engine left running by the previous version held on to the connection, and the new one would not take over. It does now — and it never interrupts work already in progress.

0.1.9-beta.42 11 August 2026 Desktop

Waiting, and your own skills

• W1 can now wait for a set time properly — ask it to check back in ten minutes and it does, on this computer's clock, waking once instead of chattering through the conversation.
• W1 finds the skills your project already has. If you keep them in .claude, .agents, .codex or .w1, they show up automatically instead of being invisible.
• Your CLAUDE.md is read in full. Long instruction files were being cut in half without saying so.
• Plugin updates reach installs that already exist, without ever switching a plugin on for you.

0.1.9-beta.41 11 August 2026 Desktop

Sending looks like sending

• Fixed the send button flicking back to its idle arrow for a moment after you send, before the stop button appears. W1 was treating the moment your message was accepted as the moment the run began.

0.1.9-beta.40 11 August 2026 Desktop

Sending works again on Windows

• Fixed W1 on Windows being unable to send at all: the engine was rejecting the browser connection the app had just started sending, and every message died before it reached the engine.
• The browser tools reach the built-in browser again on the shared engine.
• A reply no longer appears twice.
• You can message support even when you are signed out or your session has expired — leave an email and it reaches us.

0.0.106 11 August 2026 VS Code

W1 heals its own engine. If an old or wedged engine was…

• W1 heals its own engine. If an old or wedged engine was holding the connection, W1 refused to
• Updates take. Every beta build compared as the same version, so updating could land on "Local
• The panel moves properly. Replies, tool rows, reasoning and disclosures ease in and out instead

0.0.105 11 August 2026 VS Code

You can talk to W1 while it waits. Messages sent during a…

• You can talk to W1 while it waits. Messages sent during a wait used to disappear — W1 replied
• When W1 starts a wait it tells you what it is waiting for in its own words, instead of a stock
• A wait no longer fills the conversation with repeats of your own message each time W1 checks back.
• Sending a support message with a screenshot works. Screenshots were quietly too large to send,

0.0.104 11 August 2026 VS Code

Fixed W1 refusing to start with "Local engine unavailable"…

• Fixed W1 refusing to start with "Local engine unavailable" after an update. An engine left

0.0.103 11 August 2026 VS Code

W1 can wait properly now. Ask it to check back in ten…

• W1 can wait properly now. Ask it to check back in ten minutes and it waits on your computer's
• W1 finds the skills your project already has. If you keep them in `.claude`, `.agents`, `.codex`
• Long CLAUDE.md files are read in full. They were being cut in half without saying so.

0.0.102 11 August 2026 VS Code

Fixed a reply still appearing twice. The previous fix…

• Fixed a reply still appearing twice. The previous fix stopped the thinking repeating; the answer
• Messaging support now works even when you are signed out or your sign-in has expired — leave an

0.1.9-beta.39 10 August 2026 Desktop

Browser tools work again

• Restored W1's ability to drive the built-in browser — the connection was lost when turns moved onto the shared engine.
• Fixed W1 refusing to run when the terminal or the VS Code extension was also open — each one now runs independently, and your conversations are carried over.
• Signing out works, and no longer hangs on a slow connection.
• The send button can no longer be left spinning after a failed turn.
• Attach opens upward so the whole file list is reachable instead of being cut off.
• W1 for Mac is signed and notarized by Apple again, and the in-app update finds this release.

0.1.9-beta.36 10 August 2026 Desktop

Signed macOS updates

• W1 for Mac is signed and notarized by Apple again, so it installs and opens without warnings.
• The in-app update button now finds this release instead of reporting you are up to date.

0.0.101 10 August 2026 VS Code

Fixed W1 showing each thought and each reply twice in the…

• Fixed W1 showing each thought and each reply twice in the same turn.

0.0.100 10 August 2026 VS Code

Fixed W1 reporting "the model service rejected the request"…

• Fixed W1 reporting "the model service rejected the request" when your sign-in had simply expired.
• W1 no longer claims it has no browser; when a surface cannot reach its browser it says so plainly.
• Affinity and Paystack are listed as coming soon.

0.0.99 10 August 2026 VS Code

Fixed W1 refusing to run whenever the terminal or the…

• Fixed W1 refusing to run whenever the terminal or the desktop app was also open. Each place you
• Background jobs no longer disappear: if W1 starts one and finishes replying before it lands, the
• Attached images can be opened reliably — W1 is given the exact reference for each one rather than

0.0.98 10 August 2026 VS Code

Thinking blocks work properly: each one opens the thought…

• Thinking blocks work properly: each one opens the thought you actually clicked, they keep their
• Removed the duplicate copy of W1's reply that appeared after responses.
• The panel is one background again, with only the message box and the task list raised.
• W1 starts working the instant you send, instead of a pause with nothing on screen.
• Cmd+V now attaches a copied image wherever you are in the panel, not only inside the message box.
• Looking at an attached image works whichever form of its identifier is used, and if an identifier

0.0.97 10 August 2026 VS Code

Fixed W1 going silent: if a background job ended…

• Fixed W1 going silent: if a background job ended unexpectedly, every message you sent afterwards

0.1.9-beta.35 9 August 2026 Desktop

Holy Grail shared engine

• Shared durable local conversations with W1 in VS Code and the terminal.
• Added request-level recovery, bounded retries, and clearer version mismatch guidance.
• Kept images, questions, task progress, steering, and tool activity synchronized through the engine.
• Removed the global reconnecting interruption and the signed-out flash while authentication resolves.

0.0.96 9 August 2026 VS Code

Your W1 conversations now use the same durable local thread…

• Your W1 conversations now use the same durable local thread history across the terminal,
• Images, questions, task progress, tool activity, tables, and Markdown now render consistently;
• You can steer a busy task without stopping it, and scrolling up no longer drags you back to the
• Connection failures are handled at the request with bounded retries and clear recovery actions;

0.0.95 8 August 2026 VS Code

Fixed an auth issue where some sign-in sessions were…

• Fixed an auth issue where some sign-in sessions were rejected by the model service with

0.0.94 8 August 2026 VS Code

Web search and web fetch no longer ask permission when…

• Web search and web fetch no longer ask permission when you're in Full access — they're read-only lookups.
• W1 addresses you by name, never "the user".
• The long-task explorer can no longer stall a task indefinitely — it now times out honestly and W1 continues without it.
• Sharper answers after tool-heavy work: the closing summary always arrives (it could previously be dropped).
• Image understanding stays quietly in context across turns — W1 no longer narrates its own plumbing.

0.0.93 7 August 2026 VS Code

No more beta key. Sign in with just your email

• No more beta key. Sign in with just your email — the key prompt is gone, and any previously
• You can now attach images while W1 is asking you questions: paste or drop them, see the
• Image understanding got sharper — W1's visual inspection now reports strictly what is in the
• Background jobs got more dependable: if W1 closes while a job is running, the job is reported

0.0.92 7 August 2026 VS Code

W1 can now finish long jobs on its own. Hand it a build, a…

• W1 can now finish long jobs on its own. Hand it a build, a test run, or a server: it starts the
• If W1 is busy when a background job finishes, it takes the result on board mid-task instead of
• Sign-in no longer gets stuck, and a sign-in problem can no longer crash other extensions.
• Long conversations start reliably on Windows (very long threads previously failed to launch).
• When something breaks — a provider, a network, a tool — W1 now tells you what happened in one
• Sharper answers on the same requests: W1 now runs on our strongest model configuration to date.

0.0.91 27 July 2026 VS Code

W1 says what it's about to do, before it does it

• **W1 says what it's about to do, before it does it** — every task now opens with a plain-language line about what W1 is going to do, before the first command runs. No more sitting through a silent gap and then seeing a command that is already executing.
• **Loudest before anything irreversible** — before deleting a file, overwriting your work, or running a wide-reaching command, W1 states plainly what will be affected, so you have the chance to stop it. This is always on and cannot be switched off.
• **A visible checklist for multi-step work** — when a job takes several steps, W1 lays out its plan as a checklist and keeps it up to date as it works, so you can see where it is and what is left.
• **Asks first on big, open-ended requests** — given a vague or far-reaching ask, W1 now tells you what it understood and what it intends to do, and waits for your go-ahead instead of quietly changing files.

0.0.90 24 July 2026 VS Code

A leaner, faster engine

• **A leaner, faster engine** — W1's core was rebuilt to work in fewer, more deliberate steps, so runs get to the point quicker and cost less to run.
• **It sticks to exactly what you asked** — W1 now treats your request as the contract: it preserves the interfaces and behavior you specified, makes the smallest complete change, and skips unrequested extras and cleanup.
• **Survives a dropped connection mid-thought** — if the network hiccups while W1 is mid-response, it recovers cleanly and picks up where it left off instead of repeating work or losing the thread.
• **Double-checks its own work before finishing** — W1 re-reads your original request and verifies every deliverable is actually done before it calls a task complete.

0.1.8 12 July 2026 Desktop

Native W1 transport

• Kept W1 activity and final answers in one continuous transcript.
• Made run and verification cards show their actual output.
• Added live task progress and reliable thread continuity across desktop restarts.
• Restored desktop image search configuration and removed duplicate progress notes.

0.0.89 12 July 2026 VS Code

Documents with code blocks now write correctly, first time

• **Documents with code blocks now write correctly, first time** — README-style files, PRDs, and quotes full of fenced code used to fail repeatedly and could land half-written or even empty. The whole class is gone: content travels in a form that fences, quotes, and newlines cannot break.
• **Half-written files can't happen** — when a payload does get cut off in transit, W1 now refuses to write it and retries properly, instead of saving a partial file (or wiping one) and calling it success.
• **W1 talks while it works** — a real opening reply before the first tool runs, and short narration between steps as it figures things out, so you always know where a run is.
• **Looking at its own work, properly** — when W1 visually checks a page or PDF, the reason now leads the result (no more mystery fails), and multi-page documents no longer fail for content that lives on a later page.
• **Rebuild-in-place now works** — "delete the old PDF and regenerate it" command patterns inside your project are allowed; recursive and out-of-project deletes stay blocked.
• **W1 remembers what you tell it** — names, links, and decisions you share are saved to project memory the moment they come up, so they survive long conversations and restarts.
• **Sharper answers** — a finished piece of research or a done-summary lands as the reply immediately, without a format error and a wasted retry.

0.0.88 8 July 2026 VS Code

W1 recognizes its own progress

• **W1 recognizes its own progress** — passing checks now count everywhere: a green syntax check, a live endpoint test, or a passing self-verify all advance W1's internal plan. Before, a run could be cancelled minutes after proving its work because the bookkeeping couldn't see the proof.
• **A run with green evidence is never cancelled by bookkeeping** — internal progress trackers can nudge and replan, but they can no longer abort a run that has a passing check to its name.

0.0.87 8 July 2026 VS Code

Dev servers finally work

• **Dev servers finally work** — starting a server in the background used to hang the step for two full minutes and then kill the server it was testing. Now the command returns the moment the shell is done, the server stays alive for later steps, and W1 is told it's running so it reuses it instead of restarting.
• **W1 replies before it works** — the first thing you see is a short answer to your message plus the plan it's about to follow, not a bare terminal command. If you attach a screenshot, W1 now reads it in the context of what you asked ("can we win this?") instead of treating every image as a design to rebuild, and reacts to it in its reply.
• **Proving work once is enough** — running your own test green now counts everywhere it should: W1 no longer gets stuck being told to "run your probe first" after it already ran it, and finishing no longer demands a second proof of something it just proved live. Every internal guard now backs off after two rejections instead of ever burning a run.
• **A corrupted-write bug is gone** — a rare recovery path could save a file as the literal placeholder text instead of your content while reporting success. It's fixed at three layers, so a bad write can't slip through silently again.
• **Session usage is now a real 5-hour window** — it survives restarting the app, and shows its exact reset time with a live countdown, just like Weekly. Weekly also refreshes during long runs instead of only at the end.
• **Tidier activity feed** — long shell writes fold to one line, the repeated "cd your-project &&" prefix is gone, a new task card cleanly supersedes the old one instead of leaving orphaned checkboxes, and the plan flips back to active the moment you continue a run.
• **Smarter effort routing** — "build me a website game that talks to an AI" is no longer classified as a trivial static page: anything with a server, an API, credentials, or game state gets the full planning treatment. Installing packages also no longer requires 8GB of free disk.

0.0.86 6 July 2026 VS Code

Big file writes can't break anymore

• **Big file writes can't break anymore** — file bodies now travel in a raw form that quotes, newlines, and regex escapes cannot corrupt, and when an action does misfire W1 is taught the escape hatch on the spot. Commands with nested quotes also self-repair instead of costing a retry.
• **No more silent stalls** — a run that goes quiet is cut off sooner and retried immediately with deep thinking switched off (the stall cause), turning a dead 100 seconds into a fast recovery.
• **Faster follow-ups in the same conversation** — W1 keeps its picture of your repo warm between turns, so consecutive requests start instantly instead of re-scanning your project.
• **Leaner steps** — W1's internal status notes were deduplicated and tightened, and it's pushed harder to patch lines instead of rewriting whole files (its most expensive habit).

0.0.85 6 July 2026 VS Code

No more verify loops

• **No more verify loops** — W1 no longer re-proves finished work over and over: its own scratch/test files don't count as new edits (that was making fresh proofs look stale), a visual check must target your real page instead of a mock it built for itself, and it can clean up its own scratch files (which are also named `_w1_*` and auto-deleted at run end).
• **See exactly when your budget resets** — the usage menu now shows the precise day and time of your weekly reset with a live countdown ("Resets Mon, Jul 13, 00:00 · in 6d 1h"), and the Session row says plainly that it resets when you restart the app.
• **The menu fits your panel** — the context menu no longer spills off-screen on narrow sidebars.

0.0.84 6 July 2026 VS Code

W1 knows your codebase before it starts

• **W1 knows your codebase before it starts** — every run begins with a map of which file owns which function, component, and export, so W1 goes straight to the right file instead of spending its first steps exploring.
• **TypeScript edits are checked the instant they land** — a broken edit is caught and fixed on the spot (using your project's own TypeScript), not discovered minutes later by a failed build.
• **"Continue" actually continues** — if a run gets interrupted, asking W1 to continue picks up from a saved checkpoint (what was done, what was next, last test result) instead of re-exploring your project from scratch.
• **More work per step** — W1 now lands all the changes it has planned in fewer, bigger turns instead of one small edit at a time.

0.0.83 6 July 2026 VS Code

W1 now speaks the model's native tool language

• **W1 now speaks the model's native tool language** — actions arrive as structured calls instead of text that has to be parsed back out. In our head-to-head tests that meant zero action misfires, leaner replies, and roughly half the wall-time per step.
• **No more stubborn retries** — when a check fails twice because your environment can't run it (missing dependency, broken toolchain), W1 switches verification strategy instead of trying endless flag variants; repeated identical searches now reuse the earlier answer instantly; and a precise edit that misses shows W1 the exact code region so the retry lands first time.
• **Cleaner repos** — W1 now deletes its own temporary self-test scripts when a run ends, and read-only questions ("walk me through this repo") finish without being forced to invent a test.
• **Fewer, bigger edits** — W1 is nudged to batch consecutive changes to the same file into one operation instead of many small ones.

0.0.82 6 July 2026 VS Code

Runs cost a fraction of what they did

• **Runs cost a fraction of what they did** — W1 now reuses everything it has already shown the model instead of re-paying for it on every step, and your usage meter charges that reused context at its true, much lower rate. Long build sessions that used to eat most of a week's budget now fit comfortably.
• **2.5× bigger weekly allowance** — we repriced the meter to the model's actual current rates, so the same weekly plan now buys two-and-a-half times the tokens it did last week.
• **No more dying at the usage wall** — W1 checks your remaining weekly budget before and during a run. When it gets tight, it wraps up to a safe, verified checkpoint and tells you exactly what's done and what remains, instead of being cut off mid-edit with work half-finished.
• **Steadier under upstream hiccups** — a brief capacity squeeze on the model service no longer kills your run; W1 automatically retries with a smaller reply size and keeps going.
• **A tidier task list** — only the task W1 is working on now shows above the composer; earlier tasks fold away behind the Tasks header (click to see history). Cards from a stopped run are marked "Stopped" instead of dangling half-checked, and W1 is now much more diligent about ticking off steps as it finishes them.
• **Cleaner composer** — the Send button is now a compact square arrow that stays inside the input box on narrow panels (it becomes a stop square while a run is live).

0.0.81 6 July 2026 VS Code

No more garbled, piled-up text in Figma designs

• **No more garbled, piled-up text in Figma designs** — text stacks that weren't given an explicit layout used to render every line on top of each other; they now stack properly on their own, and W1 double-checks text contrast on dark backgrounds.

0.0.80 6 July 2026 VS Code

Design runs no longer get cut off mid-polish

• **Design runs no longer get cut off mid-polish** — longer default runway for iterative work (cost is still governed by your token budget, not step counts), and W1 groups its searches and image placements to make every step count.
• **Batch edits accept any reasonable input shape** — no more falling back to a dozen single edits because of a formatting mismatch.

0.0.79 6 July 2026 VS Code

Pixel-accurate recreations

• **Pixel-accurate recreations** — W1 now reads your reference as a measured build spec (element positions as canvas percentages, exact highlighted words, tilt angles, which emoji are used) and places elements by the numbers instead of by feel.
• **Sharper self-critique** — the side-by-side check now ranks differences by visual impact with a concrete fix for each, and holds the work to a "would a casual glance mistake them?" standard.
• **Designer details** — real emoji instead of placeholder shapes, tilted collage photos, proper pill buttons, and highlights that cover exactly the right words.

0.0.78 6 July 2026 VS Code

Fixed a false "quota used" block

• **Fixed a false "quota used" block** — accounts with an active allowance were sometimes stopped by an out-of-date local check before the run even started. The panel now trusts the server's answer, and the quota message shows the correct reset day.

0.0.77 6 July 2026 VS Code

Figma designs must pass their own visual check before W1 calls them done

• **Figma designs must pass their own visual check before W1 calls them done** — canvas work now counts as real build output, so W1 keeps refining until its side-by-side comparison passes (or tells you plainly what it couldn't match), instead of finishing with known issues.
• **No more doubled text when recreating a post** — W1 no longer places your reference screenshot (with its baked-in text) behind its own editable text layers, and it edits existing elements during fixes instead of re-creating them.
• **Batch edits are more forgiving** — multi-fix operations accept the tool-call shapes models actually produce, so repairs land in one pass.

0.0.76 6 July 2026 VS Code

Visual checks don't randomly fail anymore

• **Visual checks don't randomly fail anymore** — a brief hiccup reaching the vision service used to kill an image check for the whole run; W1 now retries automatically and reports the real cause if it truly can't see.
• **Cleaner Figma output** — no more stray black boxes (empty containers are now transparent), no more collapsed/invisible text after edits, and W1 edits the same frame instead of littering your canvas with v2/v3 copies (it can also delete its own failed attempts now).
• **True photo-overlay designs** — social-post layouts now support a full-bleed photo with text and buttons floating on top, matching how these designs are actually built.
• **Better font matching** — recreating a design now picks a typeface that matches the reference's style instead of defaulting everything to Inter.

0.0.75 6 July 2026 VS Code

Attached images stay in W1's working memory for the whole run

• **Attached images stay in W1's working memory for the whole run** — the description of your screenshot no longer drops out after the first step, so "recreate this" keeps the reference in front of the designer from the first action to the last check.

0.0.74 6 July 2026 VS Code

Attached screenshots now actually reach the designer

• **Attached screenshots now actually reach the designer** — "recreate this" with an image attached now works: W1 reads your screenshot in detail (exact text, colors, layout), keeps it on file during the run, and compares its Figma recreation against it side by side until they match. Previously an attachment could be silently unreadable and W1 would design from the text alone.
• **Sturdier Figma building** — text no longer collapses or clips, "fill" sizing stretches the right direction, CSS-style values like "24px" are accepted, and design exports of large frames no longer stall the run.

0.0.73 6 July 2026 VS Code

W1 can now SEE its Figma designs

• **W1 can now SEE its Figma designs** — after building in Figma, W1 exports the real canvas and visually checks it (spacing, contrast, clipped text) before calling it done, then fixes what it finds. No more "looks done" that isn't.
• **Real photos in Figma designs** — W1 finds on-brand photography and places it straight into your frames as image fills, so cards and posts look finished, not gray-boxed.
• **Recreate a screenshot in Figma** — attach a reference and W1 builds it, compares its work against your image side by side, and iterates until they match.
• **Much faster, cheaper design edits** — layout fixes now land in one batched operation instead of dozens of single calls, and layouts come out right the first time far more often.

0.0.72 6 July 2026 VS Code

Design in Figma, from a conversation

• **Design in Figma, from a conversation** — connect the W1 Bridge plugin in Figma and W1 can now create and edit real, editable designs in your open Figma file: frames, text, full layouts. Ask for a card, a landing section, a component — it appears on your canvas, not as a code mockup.
• **Connected tools are picked up reliably** — external integrations now register at the start of every run, so W1 always knows what it can reach.

0.0.71 3 July 2026 VS Code

Even more reliable long builds

• **Even more reliable long builds** — W1 now recovers from a wider set of mid-run hiccups: a dropped connection while streaming, an over-full context, or a slow sub-task no longer stops the run — it reconnects, trims, and keeps going. Provider failover is steadier too, so a brief blip with one model doesn't stall your work.
• **Safer edits** — stronger checks that a file still parses after a change (now including multi-file patches), and hardened workspace snapshots so your files are never touched during recovery.

0.0.70 1 July 2026 VS Code

Builds don't stall out anymore

• **Builds don't stall out anymore** — if the connection to the model briefly drops mid-run, W1 now reconnects and continues from the work already on disk, instead of stopping partway (e.g. right after writing the code, before the preview). More reliable start-to-finish.

0.0.69 1 July 2026 VS Code

Real photography in your pages

• **Real photography in your pages** — when W1 builds a site, it now pulls real, on-brand photos so landing pages and mockups look finished out of the box, instead of falling back to plain placeholders.

0.0.68 29 June 2026 VS Code

Builds stop spinning on already-correct pages

• **Builds stop spinning on already-correct pages** — W1's visual self-check now reads its own pass/fail verdict reliably and looks at the *whole* page (not just the top), so it no longer re-edits work that was already done. Faster, and a lot cheaper.
• **Tighter fix loop** — when a check does fail, W1 makes one targeted fix and re-checks, instead of firing off a batch of guesses.

0.0.67 29 June 2026 VS Code

Faster research

• **Faster research** — when W1 compares options or gathers facts, it now pulls several sources at once instead of one at a time, so research finishes in fewer steps
• **More trustworthy answers** — W1 leans on official/primary sources (a company's own site, docs, pricing) and flags when a detail comes from a secondary source instead of presenting it as official
• **Leaner advice runs** — when you ask for advice, a draft, or say "don't edit my files," W1 answers directly without spinning up a plan or touching your workspace

0.0.66 29 June 2026 VS Code

Cleaner answer runs

• **Cleaner answer runs** — W1 no longer writes recap/report files when you only asked a question or draft
• **Less confusing failures** — quota, auth, stopped, and failed runs now show the right status instead of looking completed or telling you to sign in for quota issues
• **Sharper thread replay** — prior context is kept by whole turns, failed runs replay as failed, and secret-bearing commands are redacted in the run feed

0.0.65 28 June 2026 VS Code

Full run on open

• **Full run on open** — reopening W1 now shows your whole conversation immediately — every step, tool call, and checklist — instead of just the text until you re-click the thread

0.0.64 28 June 2026 VS Code

Know when there's an update

• **Know when there's an update** — W1 shows an "Update available" button in the panel the moment a new version ships, so you're always on the latest
• **Smoother big builds** — large pages now build in one clean pass instead of restarting partway through
• **Live task checklist** — watch the plan tick off step by step as W1 works
• **Cleaner run feed** — the preview step no longer shows up twice

0.0.63 28 June 2026 VS Code

The W1 logo now shows on the sign-in and welcome screens

• The W1 logo now shows on the sign-in and welcome screens

0.0.62 28 June 2026 VS Code

Sign in with a beta key

• **Sign in with a beta key** — no API keys to manage; W1 runs on a hosted backend
• **Build from a screenshot** — paste or drop an image and W1 builds to match
• **Skills on demand** — frontend design, documents, testing and more, pulled in only when a task needs them
• **Privacy controls** — turn off run-trace sharing anytime (`w1.shareTraces`); W1 honors your VS Code telemetry setting

0.0.1-0.0.61 22 June 2026 VS Code

The first W1 release, and 60 more before the changelog began

• W1 launched for the first time ever, on VS Code — version 0.0.1, shipped 2026-06-22. The desktop app and the other surfaces did not exist yet.
• Versions 0.0.11 through 0.0.61 shipped in rapid succession over the following week (through 2026-06-29) as the extension found its shape. None of them have individually authored release notes — the changelog only starts being written per-release at 0.0.62, the first closed beta, immediately below. This entry exists so the record says that plainly instead of skipping straight to 0.0.62 with no explanation.