W1 changelog

0.1.9-beta.77 5 September 2026 Latest

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.1.9-beta.76 4 September 2026

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.1.9-beta.75 3 September 2026

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

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

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

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.1.9-beta.71 2 September 2026

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.1.9-beta.70 27 August 2026

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

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.1.9-beta.68 21 August 2026

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

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.1.9-beta.66 19 August 2026

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

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.1.9-beta.64 18 August 2026

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.1.9-beta.63 17 August 2026

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.1.9-beta.62 15 August 2026

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

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

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

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

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

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

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.1.9-beta.51 12 August 2026

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

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

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

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

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

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

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

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

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

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

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.1.9-beta.39 10 August 2026

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

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.1.9-beta.35 9 August 2026

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.1.8 12 July 2026

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.