Changelog

Text stays put, and see every file the agent touched

• Transcript text no longer disappears. Reply text could briefly blank out while it streamed, and rows could collapse as you scrolled a long conversation — both from the native text views momentarily reporting a wrong height mid-relayout. Now each row holds its last good height, so nothing vanishes while streaming or scrolling. Expanded Thinking blocks also stay expanded when scrolled away and back.
• New Changes panel. A Changes tab in the right dock lists every file the agent edited, wrote, or created this session — one reviewable list with per-file diffs. Writes outside the project are flagged, and it resets when you clear the conversation.

Approve MCP right in the chat, no session needed

• The MCP approval fix now lives in the chat — and works with no session running. When a project's .mcp.json server needs Claude's one-time approval, a prominent Approve strip appears right above the composer, detected from files. One click approves and reconnects.
• Standardised for Codex. Codex has no approval gate, so its parallel — an MCP server that needs OAuth sign-in — now shows the same in-chat strip with a Sign in button.

Approve buttons that show up, tidier skill headers

• MCP "needs approval" now reliably offers an approve button. A project .mcp.json server waiting on Claude's one-time approval shows the approve action instead of just "why?/reconnect" — the panel re-checks approval state as it polls, not only when it first opened.
• Skills header buttons aligned. The enable / enable all action on a pack's section now sits at the right edge instead of floating over the label.

Skills you can see, and clearer states

• Installed packs always show their skills. The Skills list reflects what's actually installed (from Claude's own plugin state), including packs that are installed but turned off — shown with an enable action instead of vanishing.
• "disabled" → "on-demand". A skill that only runs when you type its command is now labeled on-demand (with a tooltip), not the misleading "disabled".
• Sign back in after any signout. If a session ends because your Claude login expired — not only mid-turn — the Sign in prompt now appears.
• Dev-build note. A Debug build run from Xcode shows a small, dismissible reminder that it updates by rebuild, not auto-update.

Enable all skills in a pack

• "enable all" on a pack's section in the Skills list. Some packs ship skills as on-demand — they only run when you type the command, not automatically (the "disabled" badge). One tap now turns auto-firing on for every on-demand skill in the pack, and the section header shows how many are on-demand.

Installed packs actually show up

• Fixed: an added pack's skills didn't show in the Skills list, and its card kept saying "add pack." Atelier now reads each marketplace's manifest to discover its plugins — instead of assuming a fixed folder layout many packs don't use — and finds skills nested in category folders (skills/<category>/<skill>/). So an installed pack appears in the Skills list and its card flips to "enabled ✓".

Skill packs load themselves

• Adding a pack now reloads your session automatically so its skills come live right away — nothing to press. Your conversation is preserved (the session reconnects with --resume).
• If a turn is mid-stream, Atelier won't interrupt it — it notes the skills will load on your next session instead.

Skill Packs that actually install

• Fixed: "add pack" silently did nothing. Packs are now resolved by their repository, not a guessed marketplace name — so clicking add actually registers the marketplace, installs its plugins, and enables them.
• Real progress and results. Each pack shows a live "adding…" / "installing…" spinner, a clear "enabled ✓" when it's done, and an inline error with a "try again" button if something fails — no more freeze-then-revert.
• A restart hint confirms when a pack is added so its skills load into your session.

Sign back in without losing your place

• A "Sign in" button when a session signs out. If Claude's login or token expires while you're working, the composer is replaced by a clear "Your Claude session signed out" strip with a Sign in button — no more cryptic red error with no way forward.
• Your conversation is preserved. After you sign back in (in your browser — Atelier never sees your password), the session reconnects with --resume, so you pick up exactly where you left off.
• Also fixes the sign-in sheet not always closing itself after a successful login.

Skill Packs, findable

• A "packs" button in the Skills header. One click opens the featured catalog — no more digging through a footer link or onboarding to find it.
• Installed pack skills show right away. After you add a pack, its skills appear on the Skills page immediately, expanded under their plugin · name group instead of hidden behind a collapsed row.
• The empty Skills state and the "+ new" menu now point straight at skill packs, so there's an obvious way in whether you have skills yet or not.

Skill Packs

• Featured packs. Skills → skill packs → opens a curated catalog — Matt Pocock (verified · MIT), Anthropic (official), Expo (community). Expand a pack to see its skills and the command that runs each one (/tdd, /code-review, /prototype, …).
• Set up the essentials in one click — adds the recommended packs, with a clear note up front that skills can run tools and read files in your projects.
• Add a pack from a repo. The old "do it in a terminal" dead-end is now a working field — paste an owner/repo and Atelier registers the whole marketplace so its plugins become installable.
• Packs stay updatable. They install as Claude Code plugins — Anthropic's official pack auto-updates; third-party packs get a check for updates button and a restart hint so new skills load into your session.

MCP self-heal

• Approve a project server in one click. A server from a repo's .mcp.json waiting on Claude's approval now shows an approve button — it grants the approval and reconnects — instead of a "sign in to retry" that could never fix it.
• “Ask agent” to fix a stuck server. Hand a failing or needs-sign-in server to the agent: it diagnoses in the shared terminal and, if needed, runs the login so you finish in your browser — it never sees your credentials.

Adding an MCP server, rebuilt

• Add a server with one field. Paste a URL or a command and Atelier detects the transport for you instead of asking you to pick stdio / HTTP / SSE, and auto-suggests a name. Manual controls fold into “Advanced”.
• Test before you save. A “test” button (and a check on save) actually connects and tells you ✓ / needs-sign-in / what went wrong — so a bad config is caught up front, not later.
• One-click popular servers. A “Popular” section installs well-known servers (Filesystem, Git, Fetch, Playwright, GitHub, and more) straight into a prefilled editor.
• Clearer scope. Project scope now spells out the team-sharing + git-commit + per-person approval it implies, and steers you to ${ENV_VAR} references over committed secrets.

MCP recovery, and a fix for lost chats

• Fixed the app and a dev build clobbering each other's open chats. Your workspace — which chats you have open — is now saved per build, so running a development build alongside the shipped app no longer overwrites each other's tabs.
• A failed MCP server is no longer a dead end. When a server (Supabase, Kapso, and the like) shows “failed,” you can Reconnect it right from the panel, and a “why?” button shows the actual reason. If it just needs sign-in, that option appears after it retries.
• A server that drops mid-conversation now says so — a one-line note in the transcript instead of silently going dark until you open the MCP panel.
• A server stuck “starting” too long is now treated as a reconnectable failure rather than an endless spinner.

Voice input: permission + stability fixes

• Fixed the microphone permission for voice input. Atelier now asks for microphone access first, so it reliably shows up in System Settings → Privacy → Microphone — and if the toggle that's off is Speech Recognition (a separate one), the banner and the "open System Settings" button now send you to the right pane.
• Fixed a crash when starting dictation. If the mic wasn't ready the instant you started talking, dictation could take the whole app down; it now fails gracefully instead.

Voice input, rebuilt

• Dictation is now a real voice surface, with two ways to talk. Tap the mic for hands-free (tap again to stop; your words land in the composer to review, then hit ⏎), or hold the mic — or just hold ⌥ — to push-to-talk, which sends the moment you let go.
• You can see it hearing you. A live caption strip streams your words in as you speak, with a voice-reactive dot and a blinking caret. The text only drops into the composer once you're done, so a half-heard phrase never clobbers what you already typed.
• Talk over the agent to correct it. Start speaking while Atelier is working and it interrupts the current turn, so your correction becomes the next message.
• Clear recovery when something's off — one-tap prompts for when microphone access is off (opens System Settings), when nothing was heard, or when a transcription didn't come through.
• Long-form dictation and the offline on-device fallback are preserved, and the same voice surface works in both Claude and Codex sessions.

A real shell window, and another MCP sign-in fix

• The co-driven terminal is now a proper floating window. When the agent (or you, with ⌘⇧T) opens a shell you both share, it no longer stacks a full terminal pane directly above your composer — it floats in its own draggable panel, with a tab for each concurrent shell and a status badge (running / needs you / done / failed).
• The window only pulls itself to the front and grabs your keyboard when a shell genuinely needs you to type something (like a password prompt) — everything else stays out of your way until you open it.
• Fixed another case of MCP sign-in (Supabase and other OAuth providers) failing with a malformed authorization link.

MCP sign-in fix

• Fixed MCP servers (Supabase and other OAuth providers) intermittently failing to sign in with an "expected string, received array" error. The authorization link is now sanitised before it opens, so a duplicated-parameter URL no longer gets rejected.

Agent runs you can actually follow

• A whole fan-out is now one row. Delegating to N agents shows a single batch row — overall state, a live count (done · running · failed), and a cell per agent that fills in as each finishes. Click to expand into the individual agents.
• A live Agents panel with three tabs: running (every delegated agent live, with "stop all"), session (every fan-out this session), and definitions (your agent types, as before).
• You always know they're working — a running count on the agents tab (red if one failed) and a "N agents running" chip in the composer; click it or press ⌥A to jump to the panel.

Dictation, done properly

• Dictate as long as you want — the mic no longer cuts out on a pause or at the one-minute mark. Talk through pauses, think out loud, rant an idea.
• You can see it listening — a live waveform, a pulse, and an elapsed timer while you speak, instead of a button that just greyed out.
• Clearer transcription — Apple's more accurate engine by default, with automatic punctuation; falls back to on-device when you're offline.
• The mic turns off when you send, survives switching audio devices mid-sentence, and — if microphone or speech access is off — takes you straight to the right System Settings pane instead of doing nothing.

Project creation and dictation reliability

• Fixed a crash when tapping the composer's dictation button. The microphone and speech-recognition callbacks now safely return to Atelier before updating the interface.
• New projects now appear in Atelier immediately after creation, while optional Git repository setup finishes in the background.

Fixes an instant crash on the dictation button

• Fixed the mic button in the composer crashing the app immediately on tap, introduced in 2.11.5. If you're on 2.11.5, this is a same-day critical fix — please update.

Dictation

• New: a mic button in the composer, for both Claude and Codex chats. Click it, speak, and your words appear in the draft as you talk.
• Recognition runs on-device when your Mac supports it — your voice never leaves the machine in that case. Falls back to Apple's server-based recognizer automatically when on-device isn't available.
• Atelier only asks for microphone and speech-recognition access the first time you actually use it, never at launch.

Local diagnostics, for when something goes wrong

• New: a "Report a Problem…" flow (menu bar and Preferences → Diagnostics), backed by a small, local, redacted diagnostic timeline — what happened and when, never conversation content, tool output, credentials, paths, or configuration. Export produces a ZIP with an explicit list of what was excluded, so you can review it before attaching it to a bug report.
• Hang detection now feeds into that same timeline, with a cooldown so an extended hang doesn't pile up overlapping capture attempts.
• Hardened logging throughout the app: subprocess and provider output is now counted (bytes/lines), never retained as text — closing off a class of logging that could have echoed prompts, tokens, or local file paths into the system log.

Fixes a tab-stuck-working regression from 2.11.2

• Fixed a bug introduced in 2.11.2 where a background task or subagent finishing while a tab was idle could leave that tab permanently stuck showing "working" — pulsing status ring, progress line, and elapsed timer running forever on a tab that wasn't actually doing anything. In active sessions with a lot of background/subagent activity, this could show up as scroll and animation churn across several tabs at once, and in the worst case contribute to the app becoming unresponsive. If you updated to 2.11.2, this is a same-day follow-up fix.

A guardrail against silently using Fable

• Fable now shows a clear warning wherever it's selected or in use — in the model picker and in the always-visible model chip in the header — since it draws down your plan's usage limits faster than other models.
• Added a hard, enforced guarantee that Atelier itself can never auto-select or silently reroute to Fable: the code path that would enable that is now actively stripped and asserted against, not just avoided by convention.
• If a turn ever does land on Fable via a server-side fallback, the transcript note now calls that out explicitly instead of blending in as a routine notice.
• Fixed a tab status bug: when a chat resumes on its own (a scheduled wakeup finishing, or any other self-triggered continuation) rather than from something you sent, the tab now correctly shows it as working instead of sitting idle while it's actually still going.

Attaching an image no longer hangs the app

• Fixed the composer hanging when you pasted or dragged in a large image. Pasting used to decode the image and then re-encode it uncompressed on the main thread before doing anything else — for a real high-resolution photo that could block the app for over a second. Attaching now reads the image's raw bytes directly and does all the real work in the background, so the app stays responsive no matter the image size.

It's Atelier everywhere now, and your sessions travel

• The download finally says Atelier. The disk image, the mounted volume, and the app you drag to Applications are all named Atelier — not "Work". Updates keep working exactly as before: the app's internal identity is unchanged, so existing installs update seamlessly. (If you installed before this release, the file on disk may keep its old name until you re-download — cosmetic only.)
• Move a conversation to another Mac. File → Export Session (⇧⌘E) writes a portable .ateliersession file; Import Session (⇧⌘I) on the other machine files it under the right project there and opens it. Works for both Claude and Codex. Credentials and unsent drafts never leave your Mac, and importing asks before replacing an existing copy of the same session.
• Fixed the path bug underneath: Atelier now derives Claude's session-storage folder the way Claude actually does (every non-alphanumeric character, not just slashes), so projects with spaces, dots, or underscores resolve first try — and CLAUDE_CONFIG_DIR is honoured.
• Codex multi-agent work is now visible: delegation cards with live status and elapsed time, a persistent strip that keeps running agents in view, and click-to-peek into each agent's own thread. Agents are named instead of raw thread IDs, fan-outs show every agent, and a re-spawned agent's card comes back to life.
• A hardening pass before shipping: 34 fixes, including several message-loss paths, atomic export/import writes, and a settled agent's final report never being overwritten by later chatter.

Codex replies render like they were written

• Fixed your own message appearing twice in Codex chats. The app-server echoes every sent message back, and Atelier was rendering both the instant local copy and the echo.
• Rebuilt markdown rendering around what Codex actually writes, measured across 67 real session logs: numbered lists keep their real numbers ("3. Run tests" no longer renders as "1. Run tests"), nested lists keep their depth with distinct markers, "---" draws a real divider instead of a line of dashes, task-list plans render as ☐/☑ checkboxes instead of literal brackets, blockquotes get a quoted left edge, underline-style and #### headings render as headings, and a code block under a list item renders as code instead of stray backticks.
• Claude replies benefit too — the transcript renderer is shared.
• New SANDBOX NETWORK section in the Codex session config: see and change whether commands inside Codex's sandbox can reach the internet. When it's off (codex's default), git push and gh fail instantly with "Could not resolve host" — and until now nothing in the app said why.

Codex tabs come back to your conversation, not a button

• Reopening Atelier now restores your Codex tabs to their actual conversation with a live composer — the same way Claude tabs already did. Previously only the tab you were last looking at came back; every other Codex tab showed a "Start session" button over an empty pane.
• Restoring costs nothing. Codex history is read without starting the thread or spending a turn, and every restored tab is served by one shared process instead of one each — launching Atelier with ten Codex tabs open starts zero agents. Your first message wakes whichever tab you actually use.
• Idle Codex sessions on background tabs are now reclaimed after ten minutes, the same as Claude's — the conversation stays on screen and replying brings it straight back.
• Fixed the Codex composer being unusable in that resting state — it invited a reply while the text field and Send button were disabled.
• Fixed a message typed into a resting tab being silently swallowed if the session couldn't restart — it's handed back to the composer now instead of disappearing.

The provider switcher is readable again

• Fixed the provider switcher rendering the active provider as a solid black slab with an unreadable label. 2.10.4 filled the selected segment with the same color as its text, so the name of the provider you were actually talking to was invisible.
• Restored the Claude and ChatGPT product marks in the switcher — 2.10.4 had dropped them, leaving two words in a grey box.
• The active segment now carries that provider's own accent color — the same terracotta and teal used by the badges and transcript — so the switcher shows which agent you're talking to, not just which half is on.

A real sign-in flow, and a refined provider switcher

• Built a real "Sign in to Claude" flow. Atelier previously had no way to detect or fix "not authenticated," just a silent failure. It now checks your real sign-in status before ever attempting a session, and offers an in-app sign-in when needed.
• Added a real "not installed" screen for both Claude and Codex — previously just plain, unclickable text. Now shows the actual install command (copy button, nothing runs automatically) and a link to the full guide, from both the empty state and each tab's start button.
• The provider switcher now arms before it switches. Clicking the other provider shows exactly what happens ("switching restarts the session — context is re-sent, in-flight work is lost") and requires an explicit confirm, instead of switching immediately.
• The plan-usage breakdown now always shows reset time, carries severity in the bar color, and gives an exceeded window its own clear state instead of just "100%".
• The composer's compact usage meter now shows your session window by default, and swaps to weekly only once weekly needs your attention — instead of showing both at once.
• Crossing into a usage warning or hitting a limit now prints one line into the transcript when it happens, instead of nothing.

Plan meters and a real provider switcher

• Your Claude and Codex plan limits are now visible in Atelier. A compact gauge in the composer tracks session/weekly usage, and the session-config popover shows every window in full: percentage, severity, and reset time.
• Claude limits come from the CLI's own zero-cost usage surface, refreshed on session start, after every turn, and on rate-limit pushes — including model-scoped weekly limits.
• Codex limits come from the app-server's rate-limit surface with live push updates and plan type.
• Provider switching is now a segmented control — both providers always visible, the selection slides between them, in Atelier's sharp-cornered language. The popover no longer resizes when you switch.
• An unavailable provider or a switch mid-turn now dims with an explanatory tooltip instead of silently doing nothing.

Codex transcript parity, and a real permission deadlock fixed

• Fixed a real deadlock. When a turn fired two tool calls needing permission at once, the second silently overwrote the first in Atelier's UI, orphaning it — the session waited forever for an answer it could never receive. Fixed for both Claude and Codex sessions.
• Codex now renders through the exact same transcript surface Claude uses. Full markdown, tables, code fences, file links, and tool cards, instead of a separate, simplified view.
• Codex's event handling now covers all 18 of the app-server's item types (was 7), including live reasoning disclosure, command output, file-change diffs, MCP tool results and live progress, and a live task checklist from turn plans.
• Fixed Codex silently proceeding as authenticated when its account check failed, instead of showing the sign-in screen.
• Fixed the "Sign in with ChatGPT" button getting permanently stuck if the browser sign-in was closed without finishing — it's now a working cancel/retry control.

Provider continuity you can trust

• Claude-to-Codex handoff now works reliably. Atelier sends Codex the correct app-server protocol shape and keeps both providers' native session identities, drafts, and visible working timeline when you switch.
• Relaunch no longer sacrifices a retained provider. Both provider slots are restored, with a safe fallback to whichever Claude or Codex history remains available.
• Claude and Codex now share one responsive composer. Attachment chips, send/stop controls, context meter, and layout stay consistent, while persistent labeled badges and distinct shapes/colors make the active provider clear at a glance.
• History is unified. Closed Codex threads are discovered and resumed through the local app-server alongside Claude sessions, without spending a model turn.
• MCP discovery no longer blocks Codex startup or history restore. Repeated refreshes are coalesced, while configuration and OAuth remain owned and isolated by each provider.
• Codex tabs now show the correct elapsed time, and long streaming transcripts avoid a full indexed-array allocation on every refresh.

Claude and Codex, side by side

• Start either a Claude or Codex session from the same V2 workspace. Codex connects through its local app-server and uses the ChatGPT/Codex subscription already managed on your Mac—Atelier does not collect a separate API key.
• Pick from the live Codex model catalog, including Sol whenever your account exposes it. Supported reasoning levels, thread resume, native streaming, attachments, interruption, approvals, follow-up forms, and context usage are all integrated.
• Switch an idle tab between Claude and Codex while carrying the visible working thread. The checkpoint is bounded and provider-neutral; hidden reasoning, credentials, hooks, and provider-specific caches never cross the boundary.
• Inspect and configure Codex MCP servers without leaving Atelier. OAuth remains owned by each server, and compatible project servers can be explicitly imported from .mcp.json without copying Claude credentials.
• Existing Claude sessions and MCP behavior remain unchanged. Restored Codex tabs resume lazily, drafts survive relaunch, and shutdown now cleans up both provider runtimes.

Project, Local, and User: three real MCP scopes

• The MCP panel now shows three real sections instead of two. "Project" (checked into .mcp.json, shared with your team) and "Local" (private to you, this project only) used to be silently merged into one "This project" bucket, told apart only by a quiet line of subtext — easy to miss, easy to confuse. They're now their own sections, both shown up front. "User" (every project on this Mac, not just this one) stays out of the way by default, but now carries its own marker so it's never mistaken for something scoped to the project you're actually looking at. Same three words claude mcp add --scope already uses, in both the pre-session and live views.

MCP install/delete stop hanging

• Fixed: installing or deleting an MCP server could leave the button stuck on "saving…"/"deleting…" long after it actually finished. Both were waiting on a full reload of every project's config before clearing their loading state, instead of on the actual save/delete — which had already completed. The server would show up correctly if you backed out and checked, but the button itself looked hung the whole time. Both now clear the instant the real write finishes.

The MCP panel finally shows the right project

• Fixed: the MCP panel could show a completely different project's servers than the one you were actually looking at. Clicking a project in the left rail set which project the panel "remembered" — but clicking between already-open tabs never updated that, so once you'd clicked a project in the rail, the panel kept showing that project's servers no matter which tab you switched to afterward. With a few tabs open across different projects, this made the panel actively lie about what was connected where. It now always reflects whichever tab is actually active.

MCP panel leads with what's actually yours

• The MCP panel now shows your project's own servers first. "Available everywhere" used to list every global server with the same weight as the ones actually scoped to the project you're looking at, which made the panel noisy and hard to scan. This project's servers are now the primary, always-visible list; everywhere-servers collapse into a one-click disclosure instead of crowding the top. Using "→ project" on a global server still moves it into this project's list, same as before.

A quieter header

• Removed the chat/terminal toggle button and the running-state dropdown from the header. Neither did anything most people ever used — the toggle switched to an embedded terminal mode nobody reaches for, and the dropdown's only real actions were restarting the session and that same terminal switch. One less thing competing for space up top.

Window fits your screen, for real this time

• The model/effort/permissions pill no longer jumps position when you click it. Each value used to size the pill to its own text, so picking a different model or permission mode ("sonnet" vs "claude-opus-4-8", "Plan" vs "Bypass permissions") visibly shifted it. It now holds a constant width no matter what's selected.
• The real main cause: the right-side dock panel had a hard, fixed width with no way to shrink — and it silently stuck in its "expanded" state across every future launch the first time you ever opened any panel (MCP, agents, skills, etc.), permanently pushing up the window's minimum size regardless of your screen. It's flexible now, and MCP/agent rows that used to wrap instead of truncate are fixed too.
• The composer's context meter had a smaller version of the same issue and is capped now as well.

Window fits your screen again

• Fixed: the window couldn't shrink small enough to fit on some laptop screens. The new model/effort/permissions pill shipped yesterday always rendered at full width, unlike every other header control — that alone was pinning the whole window's minimum size. It now shrinks the same way the rest of the header does as the window narrows.
• Removed duplicate session info from the header — the session name and its live/working indicator are already on the tab, so the header no longer repeats them.

Model, effort & permissions, unified

• One control for model, effort, and permissions. The model switcher used to be an inert little chip buried in a faint subline, and effort had no control at all. Both now live in a single bordered pill in the header — click it to see and change all three in one popover. Model and permission changes still take effect on your next message; changing effort restarts the session (a real limit of the CLI, not a shortcut — the app is upfront about it with a red "restarts session" tag).
• The slash-command palette now shows the real thing. It used to cap out at 10 hand-picked commands. It now reads the session's actual live command list — skills, project commands, everything the binary itself reports — instead of a hardcoded subset.
• Monitor calls are live now, not a frozen preview. Watching a log, a CI run, or any other background stream via the Monitor tool used to show a static one-line description that never changed. It now shows a real live strip — how long it's been watching, the latest event, and how it ended.
• MCP servers: click a row, get everything you can do with it. Sign in, edit, and delete used to be split across a single button that only ever showed one option at a time, plus a right-click menu most people never found. Clicking a server now opens one clear menu with every real action in it.

The "/" command palette actually works now

• The slash-command palette is reliable now. It used to only open if "/" was literally the first character you'd ever typed into an empty box — after that, nothing. It now opens whenever "/" is at the start of a line or after a space, wherever your cursor actually is, and a permanent "/" icon (or ⌘/) opens it from anywhere regardless of what you've already typed. Picking or dismissing a command never wipes the rest of your message anymore.
• Command search is real search now — it matches names and descriptions, fuzzily, instead of only the start of a command's name.
• MCP servers now split into "available everywhere" vs. "this project only" instead of burying the distinction in small print on each row.
• Skills can be edited with Claude's help now, not just manually — "improve with Claude" revises a skill for you (via skill-creator, on a private copy first) and drops the result into the same review-before-save form as a manual edit.
• Fixed: the model couldn't reliably tell when a command in a co-driven terminal had actually finished — it can now ask to wait for a real answer instead of polling blind.
• Tool call previews cover Claude Code's real tool surface now — worktree actions, scheduled wakeups, background monitors, task management, and more all render their actual fields instead of a raw JSON blob or a blank summary.
• Added a hang watchdog — if the app ever fully freezes, it now notices automatically and captures a real stack sample, turning a future freeze into something diagnosable instead of a mystery.

MCP buttons stop feeling broken

• Buttons now acknowledge your click — every chip button used to give zero visual feedback on tap, so a slow action read as unresponsive. They now dim instantly on press.
• Installing an MCP server no longer has a dead gap — the row flips to "installing…" the instant it registers, instead of sitting silently while two sheets swap behind the scenes.
• Deleting a server shows real progress — a "deleting…" state instead of the row just sitting there until it silently vanishes (or doesn't, if it failed).
• Fixed: a malformed marketplace entry could get a row stuck on "installing…" forever — it now shows a clear error instead.
• Fixed: connecting Supabase without a resolved claude binary opened a blank sheet — now shows an explanation instead.

Connect Supabase without typing a project ref

• Supabase now has a real "connect & choose project" flow — sign in once, then pick your project from an actual list instead of hunting down and typing a project_ref by hand. Atelier writes a properly scoped, token-free config entry, with a read-only toggle for the cautious.
• MCP servers can now be deleted and edited in place from the v2 panel — no more delete-and-recreate just to fix a wrong credential.

No more silent model switches

• You now see when the API swaps your model — a rate-limited model can silently fall back to another (e.g. Fable 5 → Opus 4.8); that used to render as "[unknown block: fallback]". A clear inline note now names both models, in live sessions and reopened history.
• Pasted images render as a proper chip ("image · png") instead of "[unknown block: image]".

MCP setup keeps getting safer

• Can't save a broken server anymore — an empty credential field now blocks the save with a clear message, instead of writing a server that reads "configured" but can never authenticate.
• Plugin MCP servers are now visible and reusable — servers shipped inside plugins appear in the MCP panel and get the same "→ project" action as your own, with URL-parameter binding that keeps OAuth and writes zero tokens to disk.
• MCP editor and marketplace buttons now use Atelier's own design language instead of native macOS styles.

Subagent visibility, fixed for real

• Fixed: subagent tool calls leaking into your main conversation — a delegated agent's actions (including its errors) rendered as ordinary tool widgets in the main transcript; they now stay on the delegation card.
• Fixed: the delegation card's peek never showed errors — failing tool calls inside an agent were invisible; they now show as a red "✗ reason" line.
• Fixed: delegation cards freezing during thinking — the card now shows "‹ thinking…" instead of freezing on stale text for 30–90+ seconds.

MCP setup, actually easy this time

• The MCP marketplace is finally connected — "+ add" opens a searchable catalog with one-click, prefilled install instead of a blank form.
• Use an existing server in a new project — any global MCP server gets a "→ project" action that copies it into the current project with the same name.
• OAuth sign-in now starts automatically the moment you add a remote server, plus "Sign in again…" for switching accounts.
• Fixed: MCP servers stuck on "starting" forever — status now refreshes live instead of freezing at session spawn.
• A guardrail against committing secrets to a project-shared server config, plus grouping for multi-account servers.

"Is this still doing anything?"

• Fixed: a stalled reply looked identical to a finished one — the streaming indicator now shows "still working… Ns since last update" once a reply's gone quiet for a few seconds, instead of a silent dot.
• Fixed: the header went silent while a subagent kept working — it now shows "Working in background" instead of "Ready" until everything's actually done.
• Fixed: Usage tab cost totals were under-reporting real spend — 1-hour prompt caching was priced at the cheaper 5-minute rate, and Claude Sonnet 5 had no pricing entry at all. Also fixed per-turn duration being truncated instead of rounded.

Smooth streaming again

• Fixed: sloppy scroll and content flickering while a reply streams — a renderer change in 2.8.2 was rebuilding the entire message thirty times a second instead of just the new words; the streaming message now updates only its growing tail.
• Fixed: rate-limit retries were silently dropped — two decode bugs meant real 429 retries never showed the "retrying…" indicator, and a rate-limit status event was being discarded instead of parsed.

Observer mode

• Watch any session live, wherever it runs. Start a session from a terminal, another machine, or any tool other than Atelier — it shows up in the history rail with a pulsing "live" badge. Open it and Atelier tails the transcript in real time: the same live chat view, background-task strip, and delegation cards, fully read-only.
• Chrome-style tab strip — tabs shrink to fit as you open more instead of a fixed width that scrolls off-screen; once fully shrunk, a searchable dropdown finds any tab by title.
• Fixed: ⌘1–⌘9 and ⌘]/⌘[ didn't do anything — jump-to-tab and next/previous-tab shortcuts were silently broken; they're wired correctly now.

The tab bugs, found and fixed

• Fixed: switching to a tab sometimes showed an empty chat — a memory-address recycling bug ate the "this tab changed" signal; sessions now carry a stable identity.
• Fixed: reopening with several tabs bounced the scroll — the restore burst collapses into a single update.
• Fixed: thinking blocks were always empty — streamed thinking text was never captured; now you can read the model's reasoning.
• Select across paragraphs — prose is one continuous selectable surface, and right-click any message → Copy message.
• Running commands show elapsed time, and reopened conversations stop showing forever-spinning tool rows.

A real crash fixed, plus a full stability pass

• Fixed a crash in the co-driven terminal — reachable automatically, with zero agent activity, when running something like vim, htop, or tmux co-driven for long enough.
• Two real security gaps closed in the skill-from-repo flow — a malicious skill name could have written outside Atelier's skills folder, and a crafted URL could have been read as a git flag.
• Quitting Atelier now actually stops your chat sessions — previously only terminal tabs were signaled on quit.
• The ACP preview no longer leaks its process on close, plus a long list of smaller stability fixes.

See your agents work, not just background tasks

• Delegated agents are now visible — a delegation card in the transcript shows what a subagent is doing, how long it's run, and a live tail of its current action.
• Click a delegation card to watch it live — follows the agent's own transcript as it runs, then shows its final report.
• Co-driven terminals no longer stack up — a clean finish auto-folds the pane, the close button is a real "dismiss," and Claude can close a terminal itself once it's read the output.
• Skills "+ new" is a clear two-way choice — Add with Claude or Add with repo — and the body editor now fills the sheet instead of a cramped box.

See what's running behind a session

• Background tasks now show up. Anything Claude runs in the background appears in a live strip above the composer — command, elapsed time, and a one-line tail of what it's printing right now.
• Click a running task to watch it live. The output peek follows along as it prints; if nothing new has arrived in a while it tells you exactly how long, instead of leaving a stalled task looking identical to a healthy one.
• Tabs signal background work — a session with something running behind it gets a distinct slow pulse in the tab strip, so you don't have to go looking for it.
• Co-driven terminal catches interactive commands in Bypass Permissions mode too — a command that looks like it'll ask questions now gets flagged in the transcript instead of silently hanging.

Your tabs come back

• Reopening Atelier restores your workspace — every tab returns, resting quietly at zero cost until your next message wakes it with full history.
• Skills repo links find every skill — nested multi-skill repos get a picker instead of a wrong guess.
• "Clean up" confirms visibly — cleaned up N ✓.

The transcript stops bouncing

• Fixed: scrolling a long conversation would bounce up and down while a reply streamed — the render window is now set once per conversation instead of re-centering on every message.

Cleanup and update detection for skills

• Duplicate skill files get a real cleanup action — moved to Trash, always undoable.
• Skills installed from a plugin tell you when there's an update — side-by-side comparison, nothing overwrites automatically.

Skills fixes

• Editing a skill no longer silently pins its model — a real "inherit" option, nothing forced.
• Links to one skill inside a larger repo now work — the right branch, the right folder, not a guess across the whole repo.

Skills, finally reachable

• Skills panel — grouped by personal, project, and plugin, with enable/disable, full editing, and undoable delete.
• Let Claude write it for you — describe a skill in plain language, review Claude's real draft before anything saves.
• Marketplace — install a single skill from any registered plugin marketplace, or add one from any git repo.

Projects you actually chat with, actually show up

• Fixed: a project used only through Atelier could look untouched forever — session activity was counted from a log Atelier's own chats never write to. Now read from the real conversation files on disk.
• Fixed: reopening a session in a project with a space or punctuation in its name could show an empty conversation — Atelier was guessing the wrong storage location; it now finds the right one.

Snappier tabs, calmer memory, no more paste glitches

• Tab switching is instant — the chat view updates in place instead of rebuilding from scratch on every switch.
• Long chats scroll like new ones — only the most recent messages are laid out at once.
• The composer stopped stealing focus from the transcript or a co-driven terminal mid-stream.
• Pasting long text no longer glitches the app.
• Idle tabs rest instead of costing memory — "Resting" after 10 minutes, instant wake on reply.

A perfectly still scrollbar

• The scrollbar stops dancing. Scroll anchoring is now handled by the system during layout — at the bottom it follows the stream, scrolled up it holds perfectly still, back at the bottom tracking re-engages on its own.
• Sending a message still always jumps to your reply; resumed sessions open bottom-anchored.

The transcript stops fighting your scroll

• Scroll up during a streaming reply and the view stays put. Auto-scroll used to yank you back to the bottom ~30 times a second while the agent worked. The transcript now knows whether you're at the bottom: pinned → follows the stream; scrolled up → holds perfectly still; back to the bottom → tracking resumes.
• Sending a message always snaps to your reply — the agent's own tool activity can never steal your scroll position.
• Resumed sessions open at the latest message instead of mid-history.

MCP sign-in that heals itself

• Sign-in self-heals. Providers quietly expire the OAuth client registration cached on your machine — every later sign-in opened a perfect link they rejected ("Unrecognized client_id"). Atelier now resets that state automatically on every sign-in: one click, fresh registration, working consent page.
• claude.ai connectors sign in properly — Atelier now opens the right claude.ai page (previously the browser never opened for these) and says plainly: finish authorizing there, it connects on your next session.
• Real errors, fast — unknown servers report the CLI's actual message in seconds instead of a silent 3-minute timeout. Plus extra-wide sign-in terminal hardening.

Logos for every ecosystem

• Project favicons cover app projects, not just web: iOS/macOS and Flutter/React Native apps (Xcode AppIcon sets), Android launchers, Tauri, Electron, and browser/VS Code extensions — all quality-gated exactly like before.
• Fresh, on-brand share cards for the website.

Your projects, recognizable at a glance

• Project favicons. Tabs and the rail show each project's own logo — canonical locations only, quality-gated (square-ish, sane size, decodes) so nothing ugly ever renders; anything failing a check keeps the clean dot. Status still wins: the radar ring wraps the logo while working, the clay glow pulses when a tab needs you.
• Fold the terminal. The co-driven terminal collapses to its slim header while it works — command + live timer stay, plus a one-line tail of the latest output. On finish the header flips ✓ green / ✗ red with total duration. Secure prompts force the pane open.

The co-driven terminal

• Interactive commands finally work. Claude runs them in a visible terminal pane — a real PTY — answers routine prompts itself, and asks you in chat for anything it can't decide. You can click in and type at any time.
• Secrets never touch the model. Password prompts flip the pane into a secure state: Claude's reads are withheld and its typing is rejected, enforced in the engine. You type directly, hidden from the agent. An INPUT strip attributes everything the agent typed; a dovetail mark pulses while it watches.
• Run co-driven from the permission card — when Claude reaches for an interactive command via plain Bash, one click reroutes it into the shared terminal.
• Model selection, finished. Your pick sticks as the default for new sessions; the model list comes from your Claude Code binary itself, persists across launches, and works before any session starts.

Files you can touch, and updates you can see

• File peek. Click any file the agent mentions and it opens in a themed in-app preview — markdown renders as a document, code gets line numbers (kept out of your selection), images preview, huge files show their head with an "open in editor" escalation. Only files that actually exist light up; select/copy inside, or one-click copy text / copy path. Esc closes and the session keeps streaming behind it.
• One vocabulary for agent actions. Tool calls show their target as a token chip (paths) or ink command chip (bash) with live ✓/✗ status; task lists render as a real checklist; errors get a boxed treatment; links are blue, underlined, with a pointing-hand cursor.
• Visible updates. Atelier now checks automatically and shows the standard update dialog with release notes — no more silent installs. Also fixed the "old version running in the background" bug: newest launch wins, closing the window quits, the legacy terminal window never opens at launch.
• Quality of life. The model picker reads the CLI's own catalog (new models appear the day they ship); a New project tab creates a blank folder — optionally git init'ed — straight into a session; the message copy button is always visible.

Faster, with status you can hear

• Performance. Long replies now stream at steady speed instead of slowing as they grow — the whole streaming path was reworked (cached parsing, ~30fps coalesced updates, a lazy transcript). Scrolling stays smooth in long conversations.
• Tabs you can see and hear. Tabs show a clear status — working (pulsing dot + live timer), done · unseen (finished while you were on another tab), and needs you (blocked on approval) — with a summary in the title bar. Optional sound notifications nudge you when a background tab finishes or needs you.
• MCP, managed in the app. See every server a project is configured with, each with a brand logo and its real connection state, and sign in to one in a click — no visible terminal. A red dot flags anything that needs sign-in.
• Transcript. Markdown tables render as tables; one-click copy on code blocks and under each message.
• Polish. The header and composer adapt to width instead of wrapping; Light / Dark / System is a menu; your composer draft is kept per tab.

Project home, git, and a real command palette

• Project home. Clicking a project opens a per-project dashboard — stats plus a grouped sessions list titled by what each conversation was actually about (the first prompt, not the last "/clear"). The session row is the start button.
• Git, built in. A Changes tab with real git: staged/unstaged files, live diffs, stage / unstage, and commit — plus "ask Claude to write the commit message" from your staged diff.
• Slash commands. Type / for a command palette — built-ins plus your own commands from .claude/commands, with $ARGUMENTS.
• Add a project. A prominent flow to open a folder or clone a repo, with a "detected" git / CLAUDE.md / stack panel.
• Polish. A context-window meter sourced from Anthropic's spec, Chrome-style tabs, projects ordered by recent activity, "+ New session" that just starts, full-width chat, bigger click targets, and errors shown instead of silently dropped.

Permissions that stick, full state visibility, retry

• Default permission mode is now "accept edits." Claude edits files without a prompt per edit, still asks for riskier tools. Dial up to bypass or down to plan / default anytime.
• Your permission choice sticks across new tabs, restarts, and resumed sessions — and changing it mid-conversation applies to the live session immediately.
• See all of claude's states. Stop-hook output, informational notices, and connection-retry errors now appear inline instead of being silently dropped. A flaky connection shows "retrying (n/N)" instead of looking hung.
• No more dead air after sending. An immediate "Working…" cue shows and the transcript auto-scrolls to it; the stale result footer clears the instant a new turn starts.
• Retry. A retry button on the result footer re-sends your last message.

Making v2 usable for daily work

Six chat-surface bugs from the first sessions of dogfooding v2 — all the kind that bite within minutes of real use.

• Transcript scrolls during streaming. It used to only scroll on a new message, so a streaming reply ran off the bottom. Now it pins to the bottom as the reply comes in, and jumps to the bottom on a resumed session.
• New chats stop "replacing" the current tab. The strip is now global — every open chat is a visible tab (like browser tabs), with a project label when you span more than one.
• Permission requests are a real modal. The whole window dims and the Approve / Deny request sits front and centre, instead of a small inline card that was easy to miss.
• Each tab keeps its own draft, attachments, and scroll position. No more half-typed messages bleeding between tabs.
• Enter no longer fires a second turn mid-stream. You can keep typing your next message; it sends once the turn finishes.
• "esc to interrupt" actually works now — it was advertised but never wired.

Atelier 2.0.1 — v2 actually opens this time

Hotfix on top of 2.0.0. The v2 Window scene declaration in WorkApp.swift was still wrapped in #if DEBUG, so when 2.0.0 shipped as a Release build the Window(id: "v2-preview") scene didn't exist — V2AutoOpen.openWindow(id: "v2-preview") silently no-op'd and Atelier kept opening into the v1 chrome.

This release drops the #if DEBUG guard so the v2 scene is registered in Release too. Same code as 2.0.0 otherwise; just makes the v2 default actually take effect.

Atelier 2.0 — the v2 chat surface ships

The native chat surface we've been building on v2-redesign is now the default. Atelier opens directly into v2; the legacy v1 chrome is still around (minimised in the Dock) if you need it for any editor we haven't yet ported.

New in v2

• Native chat against claude -p --output-format stream-json — token-by-token streaming, live permission card, tool-use / thinking blocks, markdown rendering, ⇧⏎ for newline.
• History rail — scrub past sessions across every project, bucketed Today / Yesterday / This week / Older. Click any row to resume with the last 40 turns preloaded into the transcript before claude even spawns.
• Image + file attachments — paperclip, paste from clipboard (⌘V), or drag in from Finder. Claude reads them via @-path references, and Read of attached files is auto-allowed (no permission prompt for files you just picked).
• Inline model picker in the session header. The catalog is discovered from your real session history — no hardcoded version list. Default model lives in @AppStorage("v2.defaultSpawnModel") (currently claude-opus-4-8).
• Usage view — month / 30-day / year / all-time stats with by-model and by-project breakdowns, recent-sessions table, and an estimated-spend column.
• Collapsible right dock defaults to a 40pt strip so per-session panels (loop, harness, agents, MCP) don't burn 360pt of screen full-time.
• Open any folder as a project — ⌘O or the + next to the PROJECTS rail header.

Quality + reliability

• Initialize handshake on spawn — sessions no longer hang on "Initializing".
• Subprocess orphan + stderr-deadlock fix in the loop / harness orchestrators.
• Tab + project switching click bugs (nested-button dead zones, focus-stealing composer) eliminated.
• Render-time perf: rail sort + history aggregation now cache across renders.

Known still-in-progress

v2 is labelled "preview" in the window title because we're still grinding through the audit list. Some surfaces (Plugins / Skills CRUD, Marketplace) still route to the v1 Extensions tab. v1 stays accessible in the Dock as a fallback if you hit anything we haven't ported yet.

The new mark - Atelier's dovetail

A few days after the rename, the brand finally has a mark to match.

Atelier's new logo is a dovetail joint: a square frame split by a single seam that interlocks two halves without a nail. It's a joinery technique woodworkers have used for thousands of years because it gets stronger the harder you pull on it. A workshop's mark should be a piece of joinery. This one is.

What's new in this build

• New macOS app icon. Graphite squircle, ivory mark, uniform stroke weight, the exact dovetail geometry. After this update lands, your Dock, Finder, App Switcher, and Cmd+Tab all show the new mark.
• New favicons + site icons. Browser tab, iOS home screen, OG cards - every visible icon surface is now the new mark.
• No functional changes. This is a brand release. Everything you can do with Atelier 1.4.0 you can still do here, just with a better-looking icon in your dock.

The mark was designed against an explicit brief: quiet, precise, owned. The kind of thing you'd recognize stamped on the bottom of something you didn't expect to find it on. Monochrome at heart, geometric, no flourishes.

Atelier - same app, better name

"Work" was a placeholder. It said nothing. It told you nothing about what was inside. Work is what you do when you'd rather be doing anything else - a verb pretending to be a noun, a name that admits defeat.

An atelier is the opposite. It's where a craftsman keeps their tools, their unfinished pieces, their drawings on the wall. The work happens there - but the room itself has a name, a feel, a smell, a door you close behind you when it's time to make something.

That's what this app actually is. Six live Claude sessions in one window. Real terminals, real PTYs, a polished surface over the messy filesystem Claude Code already writes to. It's a workshop. It deserved to be named like one.

What changed under the hood

Almost nothing. The dock label, the menu bar, every alert and tooltip in the app now says "Atelier" instead of "Work." That's it.

The bundle identifier stays com.munyamakosa.work, so your install updates in place via Sparkle - no manual reinstall, no /Applications/Atelier.app showing up next to your existing /Applications/Work.app. Next launch, you'll just see the new name. The on-disk filename is still Work.app because changing it would orphan every install on Earth.

What about the URLs?

work.munyamakosa.com stays live forever. Every binary out there checks it for updates, and we don't break things that work. The new home - atelier.dev - is where the marketing and docs migrate over the coming weeks. Both will resolve to the same content; Sparkle will keep updating your install from the old URL until the heat death of the universe.

Why now

"Work" was never going viral. Searching for it returned the dictionary. People couldn't recommend it to a friend without three sentences of explanation. A name should do work for you - sit in someone's head, make them curious, render well on a screenshot. "Atelier" does. "Work" never did.

If "Work" already lived in your head, mine too. It'll feel weird for about a week. Then "Atelier" will feel obvious and we'll wonder why it took this long.

Memory diet - large sessions no longer balloon Work's RAM

• Byte-walk JSONL parsing. Opening a conversation used to allocate the full session file as a Swift String just to start parsing - a 191MB session produced a ~400-500MB heap peak before a single message was rendered. Work now memory-maps the JSONL and walks line boundaries directly, emitting one Data slice per line. The mmap'd region is the only large allocation, and it's pageable - the kernel reclaims it under pressure.
• One source of truth for tool output. Every tool result was being stored twice - once in the message's kind enum and again in a sibling text field. The text field is now a computed property that returns a 500-char preview for tool results, so multi-megabyte file dumps and grep outputs only live in one place. Views and exports that wanted the full output read it from the enum directly.
• Smarter semantic search index. The embedding index used to chunk every message - including 5MB tool output dumps - into 512-char fragments, each paired with a 512-float vector. For a 191MB session that built a ~1GB in-memory index just to power semantic search. Work now skips .toolResult rows entirely (you rarely semantic-search a find . -name dump) and caps any single message at 32 chunks. User prompts and assistant text replies still index normally.

Expected net result: a session view that used to hold 1.5-2GB resident drops to roughly 150-300MB. Multi-session navigation should feel snappier, and Work should no longer feature in Activity Monitor's top spenders after an afternoon of browsing.

Skip-permissions prompt on every new chat

• Get asked, every time. Whenever you start a new chat - Cmd+T, sidebar "+", resume from the session list, continue last, or start-on-project-add - Work now asks whether to launch Claude with --dangerously-skip-permissions for that session. No more digging into the terminal to skip prompts on the runs you know you trust.
• Per-session choice. The decision is scoped to the tab you're starting - pick "Skip permissions" for the throwaway scratch session, pick "Use normal permissions" for the production-touching one, side by side in the same window.
• Restart preserves the mode. Use the tab chip's "Restart session" action and Work re-spawns Claude in whichever mode the tab was originally launched. Skip stays skip; normal stays normal.
• Off switch in Preferences. The gear icon's popover has a new "Ask before starting" toggle. Turn it off and Work always starts in normal mode without asking - no chance of accidentally leaving skip on as a default.

Safety note: Skip mode runs Claude without confirming tool use. Faster, but only safe in projects you trust completely. The dialog defaults to surfacing this choice every time precisely so you don't forget which mode you're in.

Usage tab now shows what your Claude Code use is actually worth

• API-equivalent value, per range. A new hero in the Activity card shows the dollar value of the Claude API tokens you used this week, month, or year. If you're on Pro or Max, you are NOT billed this - the number is framed against your subscription so you can finally see whether your $20 or $200 is paying off. "≈ 2.4× a month of Claude Pro · 0.2× a month of Claude Max" tells the story at a glance.
• Per-model token attribution. Work now reads message.model from every JSONL line and splits each session's tokens across the models it actually used - Opus 4.8 at $25/M output, Sonnet 4.6 at $15/M, Haiku 4.5 at $5/M. The dollar number is honest about the model mix rather than guessing.
• Heatmap cells now have tooltips. Hover any day on the 52-week heatmap to see date, token count, and dollar value. Native macOS tooltip - pre-computed so hover never triggers a recompute.
• Tokens ↔ Value chart toggle. The activity bar chart can switch between token counts and dollar amounts. Y-axis labels and colour change with the mode - one chart, your choice of unit.
• Top sessions, sortable by value. The Top projects list gets a Value column, and there's a new Top 10 sessions list right below. Toggle between "Tokens" and "Value" sort to find the session that ate the most of your week.
• Pricing freshness without an app release. Pricing data is fetched from work.munyamakosa.com/pricing.json on launch (24h cached, silent fallback to the embedded table on any failure). When Anthropic adjusts prices, your Work install picks up the change without waiting for the next release.
• Cache schema bump. First launch after upgrade re-parses every session JSONL once to populate per-model breakdowns - a couple of seconds for most users, then back to instant.

Heads up for Claude Pro and Max subscribers: the dollar figures shown in the Usage tab are the API-equivalent cost of the tokens you actually used - they are NOT a bill. Your billing is the flat subscription you already pay. The number is for visibility only.

MCPs tab, now matching Claude Code's full feature surface - plus in-place session restart

• Three real scopes, not two. The MCP editor now distinguishes User (every project, only you), Local (only this project, only you - what claude mcp add does by default), and Project (shared with the team via .mcp.json). Previously "Just me" silently dumped MCPs into every project - now it stays put.
• HTTP Headers editor. Bearer-token MCPs (GitHub, Sentry, internal APIs) no longer require hand-editing ~/.claude.json. Add Authorization, X-API-Key, anything - values matching common secret patterns are masked by default with an eye toggle to reveal.
• OAuth fields for HTTP/SSE servers. A new "Advanced auth" section lets you pre-configure clientId, callbackPort, scopes, and authServerMetadataUrl for servers that don't support Dynamic Client Registration.
• Always-load + per-server timeout. "Advanced server options" exposes the alwaysLoad toggle (skip Tool Search deferral, load tools every turn) and a per-server tool-call timeout in seconds.
• ${VAR} expansion in .mcp.json values. Both ${VAR} and ${VAR:-default} syntaxes are now expanded against the host environment when parsing - matching Claude Code's documented behavior. The editor still shows the raw ${VAR} form so you can see what's in the file.
• streamable-http alias recognized. Servers configured with the newer streamable-http transport type now parse correctly (canonicalised to http on save).
• Restart-session in place. New "Restart session" action on the tab chip context menu and in the live-session header's "Running" menu. SIGTERMs the Claude process and respawns it on the same session - so you can pick up newly added MCPs, hooks, or skills without leaving the terminal. If the session was brand new (no sessionId assigned yet), Work uses claude --continue so your just-typed prompts aren't orphaned. The new tab keeps its original position in the bar.

Snappier tabs + a clean-up pass

• Tab switching is instant. The previous 280ms cross-fade animation between tabs made every click feel laggy because the UI had to wait for the fade to finish before content was interactive. Removed.
• No more double-fire on tab clicks. Clicking a tab chip was running the navigation handler twice - once via the direct callback, once via the activeTabId onChange. Cascading state mutations all happened twice per click. Consolidated to a single firing path.
• Scrollback cap now actually applies. The 5000-line cap was declared but never assigned to the SwiftTerm terminal - long sessions could grow the in-memory buffer without bound. Fixed.
• AppleScript escaping is honest. Paths or commands containing stray newlines / tabs were silently dropping those characters when embedded into AppleScript literals; now they get properly escaped instead.
• Cleaner file permission flags. Two cache files were being chmod'd with the wrong integer type (Int16 vs mode_t). Aligned.
• CRLF-encoded SKILL.md files parse correctly. Skills authored on Windows or copy-pasted from CRLF sources no longer break YAML frontmatter detection.

Add Project - one sheet, three paths

• New "+" button in the sidebar toolbar. Single sheet with three segmented tabs: Open folder, Clone, New folder. Cmd+Shift+N opens it. Same end state for all three - the project appears in the sidebar, is persisted to ~/.claude.json, and can optionally start a Claude session immediately.
• Open folder. Pick any directory, optionally name the first session, Work registers + opens it.
• Clone. Paste a GitHub URL, SSH URL, or owner/repo shorthand. Live streaming clone log. When it finishes, the freshly-cloned repo is already a known project ready for a session.
• New folder. Pick a parent, type a folder name, Work creates the directory, registers it, and can spawn a session in it. Great for kicking off something fresh from scratch without hopping to Finder first.

Self-relocate to /Applications + drag-to-install DMG

• Bug fix: "Work can't be updated if it's running from the location it was downloaded to." Some users were launching Work straight from the DMG or Downloads, then hitting a dead-end Sparkle dialog. On first launch from any location outside /Applications, Work now offers to move itself there and relaunch. Declining is remembered - we won't nag.
• Drag-to-install DMG. The disk image now includes an Applications symlink alongside Work.app, so you can drag Work across to install - the standard macOS install experience.

GitHub Dark terminal, plus 35 bugs squashed

• New default terminal theme. Work's embedded terminals now open with a GitHub Dark palette (#24292e on #d1d5da), matching what most devs already live in via VS Code/Cursor. One-line revert path; a Terminal Settings pane with Basic / Homebrew / VS Code Dark+ presets is coming.
• "Project Not Found" fixed. Starting a session in a directory Work hadn't seen before sometimes rendered a "Project Not Found" empty state in the detail pane. Synthetic projects are now inserted into the store synchronously so navigation never misses.
• Open in Terminal.app no longer strands you. If AppleScript automation is denied (or any error surfaces), the in-app PTY is preserved - previously you lost both the tab and the Terminal window. Launcher now reports success/failure and the caller only tears down on success.
• Marketplace plugin installs work on fresh Macs. `claude plugin install` now inherits the enriched PATH (node/npx/git/uv) that embedded terminals already use, instead of launchd's stripped default.
• No more "No sessions yet" flash. Empty state is gated on load completion - initial launch no longer briefly shows it while JSONL parses.
• Directory picker remembers your choice. Fresh directories opened via "Open directory…" now register in `~/.claude.json` so they survive a Work restart even before Claude writes a JSONL.
• MCP rename collision safety. Renaming an MCP to a name that already exists now throws DuplicateName instead of silently overwriting the other entry.
• Sidebar lists every approved project. Projects you've opened with Claude but whose JSONL history got cleaned up now appear (canonicalised by path). Previously only projects with live history were surfaced.
• MCP status detection is tighter. Running-status checks now require BOTH the command basename AND a distinctive arg, so `ls node` no longer false-matches every node-based MCP.
• Dead exited tabs no longer accumulate. Resuming a previously-exited session prunes its ghost chip before spawning.
• Session slug recovery on huge files. `readSlugFromTail` falls back to a 64KB pass if the 4KB tail missed the customTitle line that straddled the boundary.
• Store.load() recovers from wedged reads. A hung load over 30s no longer silently blocks every subsequent refresh; the flag auto-releases.
• Usage aggregate race guarded. Token-totals re-aggregation checks a load generation before publishing, so a slow aggregate from an older load can't clobber newer totals.
• Big perf win on usage aggregation. Replaced `Array(data)` on memory-mapped JSONL with `withUnsafeBytes` - no more full-copy allocation that defeated `.mappedIfSafe`.
• MCP config writes preserve key order. `~/.claude.json` writes no longer alphabetize top-level keys, so hand-ordered config isn't shuffled on every save. Permissions now use mode_t and surface chmod errors.
• Flat `.mcp.json` mixed content rejected. Writing to a `.mcp.json` that mixes MCP entries with non-MCP top-level keys now fails loudly instead of silently breaking the file.
• Tab focus no longer steals across switches. The terminal-first-responder async block re-checks the active tab before claiming focus, so switching tabs mid-render doesn't bounce focus back.
• Dynamic Type friendly popover rows. The project-picker popover row height now scales with accessibility text sizes instead of a hard-coded 40pt.
• Skill operations don't freeze the UI. Auto-invoke/user-invocable toggles, clone-to-personal, and delete now run file I/O on a background task instead of blocking the main thread.
• Cmd+W respects system close-window. When no tab is active, Cmd+W now falls through to closing the current window instead of being swallowed.
• SIGKILL escalation on wedged renames. ClaudeRenamer escalates a timed-out SIGTERM to SIGKILL after a 1s grace instead of leaving a zombie process.
• PID-recycle guard before SIGKILL. Tab close re-verifies the target pid still belongs to a Work descendant before the 3s-later kill, so we can't accidentally signal an unrelated process that reused the pid.
• Misc. Scope tooltip fixed (`~/.claude.json`, not `~/.claude/settings.json`). `force` parameter on close() honored. `sendInputWhenReady` sleep clamped to timeout. AppleScript escaping consolidated. Conflict filter no longer dead-coded. ContentUnavailableView empty-state flashes fixed.

"Open directory" new sessions are reachable now

• Fresh directories actually work. Starting a session via "Open directory…" on a folder Work hadn't seen before left you with a tab you couldn't click into and a sidebar that didn't show the new project. Fixed: the picked folder now enters the store synchronously, `selectedProject` points at it, and the new terminal takes over the detail pane immediately.
• No more "project not found" flash. Store.load() (which runs on the file watcher tick or every 30s) was blowing away the ephemeral project and nil-ing selectedProject, causing a layout shift + error state. It now preserves any project the user is actively on until real on-disk data replaces it.
• No eager reload after picking a directory. Removed the extra async reload that was triggering an isLoading skeleton + layout shift seconds after the picker closed. The file watcher catches the real JSONL when Claude writes it.

New-session navigation + live busy indicator

• Bug fix: new sessions in a different project are now reachable. Opening a new session for a project you weren't viewing left a tab chip in the bar that couldn't be clicked into - the detail pane kept showing the old view. Fixed: session-less tabs now navigate the sidebar to their project and render the live terminal in the detail pane.
• Tabs turn orange while Claude is cooking, green when it's ready. Per-tab activity indicator driven by a lightweight idle timer (zero parsing, zero polling). Orange during streaming, back to green 700ms after output stops.
• Red dot on crash/kill. Failed exits and killed sessions now render red instead of orange, so the color no longer collides with the busy state.

Embedded terminals + integrations, built for Opus 4.7

• Embedded Claude Code terminals. Run six Claude sessions in one window instead of juggling Terminal.app. Real PTY processes, proper scrollback, drag to reorder, hover to close. New Session popover picks the project, optionally names the session, or opens a fresh directory.
• Tab bar with Chrome-style chips. Each open session is a tab at the top of the detail pane. Right-click for Close, Open in Terminal.app. Cmd+1-9 to switch instantly.
• Per-project Integrations panel. Two-click install curated MCPs (Linear, Notion, Sentry, GitHub, Supabase, Stripe, Filesystem, Puppeteer) into any project. Installing during a live session spawns a fresh Claude tab and auto-runs /mcp for OAuth, so you're one click away from connected.
• PATH auto-fix. Embedded terminals now inherit a real developer PATH (~/.local/bin, Homebrew, Cargo, Volta, Node) so claude resolves without shell config edits. No more "Native installation exists but ~/.local/bin is not in PATH" warning.
• MCP writer fixed to match Claude Code 2.1+. User-scope MCPs now write to ~/.claude.json (the canonical location Claude actually reads), not the legacy ~/.claude/settings.json. If you installed an MCP in an earlier version that never loaded - this is why.
• SwiftUI close-confirm dialog. Replaced the old NSAlert on tab close with a SwiftUI alert, so the destructive button actually renders on dark mode.
• Static live-pulse indicator. The streaming-status dot no longer pulses - clean halo + solid dot instead.
• Faster Usage + sidebar. Memoized filtered projects, session search results, and heatmap cells. Big projects with many sessions no longer re-compute on every keystroke.
• Tuned for Opus 4.7. New model defaults aligned with Claude Code v2.1.112+, xhigh effort as the recommended setting, and the new tokenizer's larger max_tokens floor respected when opening sessions.

Skills, reimagined

• Full skill metadata. Expanded SKILL.md parsing: when_to_use, allowed-tools, model, effort, paths, argument-hint, user-invocable, disable-model-invocation, license - all surfaced as typed metadata chips in the detail view.
• Rendered SKILL.md preview. Click "View SKILL.md" on any skill to read the full body rendered as Markdown (with proper code blocks, headings, lists). No more guessing what a skill does.
• References + scripts explorer. Each skill's bundled files shown with sizes. Click any one to open it in your default editor.
• Precedence viewer. When a skill name exists at multiple scopes (personal + plugin, project + personal), Work shows which copy Claude actually uses - crown badge for the winner, warning badge for shadowed versions.
• Scope picker. Filter the Skills list by All / Personal / Project / Plugin. Each skill row shows a scope tag (USER, PROJ, PLUG, ENT) at a glance.
• Symlink dedupe. Skills symlinked between ~/.claude/skills/ and ~/.agents/skills/ no longer show twice.
• .skill zip archive support. Packaged skills (like obsidian-brain.skill) now parse and render correctly.
• Plugin-as-skill detection. Plugins with SKILL.md at the root (like claude-reflect) now appear in the Skills list too.
• Skill operations. Create a new skill from scratch (scaffold wizard), clone a plugin skill into your personal folder for editing, toggle auto-invoke and slash-command availability, delete to Trash. Right from the detail view.
• Plugin enable/disable switches. Flip any plugin on or off - Work writes enabledPlugins to ~/.claude/settings.json atomically.
• New Marketplace tab. Browse plugins from every marketplace installed on your machine. Install / Update / Uninstall via Claude's CLI with one click.
• Today token counter. The Usage tab now leads with a hero card showing today's tokens, vs-yesterday delta, and a Input/Output/Cache split.

Roomier on first launch

• Bigger initial window. First-launch size bumped 15% (1010 × 670) so the new home screen, sidebar, and Usage charts breathe properly out of the box.

Existing users keep their saved window size - only first-time installs see the new default.

Renames that actually persist + a usage page worth opening

• Renames now propagate to Claude. When you rename a session in Work, Work invokes claude --resume <id> --name <newname> headlessly to write the name into Claude's own session file. The new name shows up in claude --resume's picker and in the terminal title - not just in Work.
• Usage analytics with Week / Month / Year. A new Activity card on the Usage tab shows tokens this period, daily average, peak day, and a clean bar chart. Switch ranges with the segmented control.
• GitHub-style daily heatmap. 52 weeks of activity at a glance, color-binned by adaptive quartiles. Active days, current streak, and longest streak shown above the grid.
• Token usage now caches. First load scans every session file once and writes a per-session cache to Application Support. Subsequent launches feel instant - only files Claude has touched since last run get re-parsed.
• Token counts go to billions and trillions. K, M, B, T suffixes so heavy usage still reads cleanly.
• Polish. Skeleton loading state for the Usage tab while scanning. Activity card chart redesigned with weekly bars for the Month view (no more dead-thin daily lines).

Big numbers, bigger reach

• Token counts now scale to billions and trillions - K, M, B, T suffixes so huge usage totals stay readable.
• Rename from the home screen - right-click the feature card or any "Jump back in" card to rename. A subtle pencil icon appears on hover for discoverability.
• Fixed background auto-updates - Sparkle's feed URL is now correctly baked into the app bundle. Updates land silently while you work.

First release with working silent auto-update. From now on new versions download in the background and flip the badge to "Relaunch to update" when ready.

Session superpowers

• Redesigned home screen - App Store-style feature card shows your most recent session with one-click resume. "Jump back in" grid shows the next 4.
• Cross-project session search - type in the sidebar to search sessions across every project by name, project, or message content.
• Name sessions at launch - type a name in the New Session popover and Work applies it automatically as the session starts.
• Rename existing sessions - right-click any session → Rename. Names persist across launches.
• Hide old sessions - right-click → Hide to declutter. Toolbar toggle to show them again.
• Home button - go back to the home screen from anywhere via the new 🏠 icon in the sidebar toolbar.
• ⌘N from home - keyboard shortcut to start a new session without touching the mouse.

All aliases and hide flags live in ~/Library/Application Support/com.munyamakosa.work/ - nothing Work writes touches Claude's files.