Happier Update - August 2026

[leeroybrun]

Hey Happier fam!

This update is long overdue.

If you've joined us on Discord or followed the commit history, you already know that Happier is continuing to move a lot. I've worked on many new features, fixes and larger internal changes over the past few months.

Development is now happening on two tracks: stabilizing the public v0.2.x dev channel before promoting it to preview and stable, while also building the new v0.3 architecture in an unpublished worktree.

Latest updates on the dev channel

A lot changed in the latest dev releases.

The main transcript renderer has moved from FlashList to LegendList. That migration touched much more than the list component itself, including scrolling, pagination, position restoration, following new messages and handling large transcripts.

I've also made substantial changes to:

• pending messages and how Happier delivers input while an agent is busy or reconnecting
• runtime activity, so the UI has a more accurate view of what an agent is doing
• Claude's unified terminal runtime
• Connected Services and Connected Accounts, including account health, quotas, pooling and account selection

These changes affect some of Happier's busiest code paths. I'm keeping them on dev for now while I fix issues reported by the people using it, before pushing the long-overdue updates to preview and stable.

If you're using stable or preview and running into an issue, there's a good chance it has already been fixed on dev and will reach you soon. You can see the full changelog between the current stable/preview releases and dev at the end of this post for a clearer picture of what's coming.

If you encounter an issue on dev, please report it through GitHub Issues or Discord. Feel free to open a PR directly when the fix is relatively straightforward. Any help, in any shape or form (testing, reporting issues, suggesting features or improvements, fixing issues) is deeply appreciated!

Upcoming v0.3: a unified runtime and public plugin system

At the same time, I'm continuing to work on Happier v0.3.

v0.3 changes the project's architecture around a unified agent runtime and a new plugin system. It builds on the existing code and features, but changes who owns the shared behavior.

Historically, each agent integration implemented some combination of session handling, message delivery, transcripts, activity tracking, permissions, recovery and process management. Similar logic ended up spread across several agents. Some integrations were also forced through ACP-shaped paths even when their native runtime behaved differently.

This made new agents harder to add and maintain. Improvements to shared behavior often had to be implemented several times.

In v0.3, Happier's runtime owns the shared parts: session and turn lifecycle, pending input, transcripts, permissions, activity, persistence and recovery.

Agent plugins own the behavior specific to Claude Code, Codex, OpenCode, Pi, Antigravity and other executable coding agents. This includes launching their CLI, speaking their native protocol, interpreting their events and declaring their capabilities.

ACP still has an important role for agents that support it, but it is now an adapter rather than the shape every agent must follow.

This should make new agents easier to add while allowing shared runtime improvements to benefit every compatible integration.

The Happier Plugin SDK

The v0.3 source now treats first-party agents as plugins. Claude, Codex, OpenCode, Antigravity and the other bundled agents use the same plugin architecture being prepared for external authors.

The authoring workflow includes commands such as:

happier plugins create
happier plugins dev
happier plugins test
happier plugins pack

Plugins are not limited to agents. They can contribute model providers, actions, hooks, events, settings, UI, managed dependencies, MCP integrations and other capabilities.

They can be packaged as npm-compatible archives and shared through npm or other supported sources. Happier's daemon handles installation review, trust, enablement, rollback and removal.

The authoring experience takes inspiration from Pi's extension workflow: create a small plugin, run it in development mode, edit the source and let Happier validate and reload it. The workflow is also designed to work well with coding agents. You can ask an agent to help create or customize a plugin while happier plugins dev handles validation and reload through the daemon.

Plugins are trusted code, much like editor extensions or other local development tools. They are not sandboxed. Happier will show what a plugin declares and ask for trust where appropriate, but you should still review third-party code before installing it.

The public Plugin SDK has not been released yet. It will have its own version number, separate from the Happier v0.3 application release, and will initially ship as a Developer Preview.

What else is coming with v0.3

The new architecture has also given me a better place to finish several larger features:

• Guided desktop onboarding: install and configure the CLI and background service, choose Happier Cloud or a self-hosted relay, authenticate the machine and verify that everything is running. Basically, you install the desktop app, follow the guided process, and you can have everything installed and configured automatically for you (including your self-hosted relay, remote access through Tailscale or Cloudflare Tunnels, etc)

• Remote SSH hosts: configure and manage remote machines, install the CLI and daemon, and optionally host a relay through SSH.

• An embedded browser workspace: open external pages and local previews, use tabs and navigation, inspect diagnostics, capture browser context for a session, record supported targets and optionally allow agent automation.

• Better terminal rendering: experimental native renderers based on Ghostty on iOS and Termux components on Android

• A rebuilt Voice system: Local Voice, OpenAI Realtime, experimental Codex Live, Grok Realtime, configurable speech providers and local speech model packs. Codex Live attaches the conversation to a real Codex session so it can delegate coding work, use tools and follow the same permission model.

• Antigravity support: Antigravity is being implemented as a native Happier agent plugin, including its CLI runtime and external-session support.

• Better usage and context data: more accurate token, cost, quota and context-window reporting, together with an in-session instrument strip, richer usage charts and recap views.

• First-class support for models providers and local models: we were already integrating external model providers in Happier using profiles in v0.2 (Deepseek, Minimax, etc). In v0.3 you will be able to add any kind of providers and models to your agents, detect and use local models (Ollama, LM Studio), use CLIProxyAPI (running OpenAI models in Claude for example), etc in a much better and integrated way.

• & much much more :-)

Development effort, contributions and next steps

My immediate priority is still to stabilize the public v0.2.x dev release so it can move to preview and stable, while continuing v0.3 work in parallel.

I'm trying to avoid large new features on v0.2.x for now. Every change there also has to be manually ported to the v0.3 worktree, which takes time away from finishing both releases.

Bug-fix contributions and PRs are especially welcome and deeply appreciated. Larger features may be better coordinated around v0.3, depending on their scope, so please talk with me first on our Discord or Github issues if you are considering one.

The v0.3 work is not public yet. Once it is stable enough for outside testing, I'll push it to a dedicated branch. It will eventually replace the current dev line.

Feel free to join us on Discord if you have questions, run into issues or want to discuss an idea. I'm always happy to hear what you think and to understand how I can make you even happier with Happier ;-)

Full changelog between 0.2.1 (preview) and current dev

New agents and models

Grok Build

Grok joins Claude, Codex, Cursor and the other bundled coding agents as a fully supported Happier agent.

• Pick Grok from the standard engine popover and start a session without using a separate workflow.
• Models come from what Grok advertises instead of a hardcoded fallback list. Reasoning controls appear only when the selected model supports them.
• Grok's question flow works end to end, including freeform questions, questions without predefined options and "Other" with notes.
• Generated images pass through Happier's shared media pipeline, render inline and remain available after a reload.
• Grok uses Happier's existing permissions, history, lifecycle and MCP surfaces instead of adding parallel implementations.

Thank you @jaylfc for contributing Grok Build in PR #195.

Cursor

Cursor is now a fully supported Happier agent alongside Claude and Codex.

• Create, load, resume, MCP pass-through and session ID tracking are wired through the ACP backend, with failures surfaced instead of silently ignored.
• Ask, plan, todos, tasks and image generation map through Happier's standard contracts.
• Runtime model changes use the exact configuration values reported by Cursor's ACP implementation.
• Output from cursor-agent models feeds the model picker, including Composer fast, GPT reasoning and fast modes, and Claude thinking, effort and fast modes.
• Cursor has its own logo and provider entry across the new-session picker and session chrome.
• Provider scenarios and real smoke coverage were added for the integration.

MiniMax profiles

Two built-in MiniMax profiles are available for the global and China endpoints.

• MiniMax-M3 is the default model and MiniMax-M2.7 is the small or fast model.
• The profiles use MiniMax's Anthropic-compatible and OpenAI-compatible endpoints.
• They wire the appropriate ANTHROPIC_* and OPENAI_* environment variables.
• Both profiles work with the Claude and Codex agents.
• Profile metadata, documentation and translation strings are registered in the UI.

Thank you @octo-patch for contributing the built-in profiles.

Claude Opus 5

• Opus 5 is now the leading selectable Claude model, and the shared flagship identifier points to its concrete catalog entry.
• The catalog records a one-million-token context window and effort levels from low through max, including xhigh and ultracode support.
• Earlier Opus descriptions remain in chronological order so clients can present the lineage accurately.
• Existing pinned model selections remain unchanged.
• An invariant test prevents the flagship identifier from drifting to an unavailable model.

Current supported agents list

Claude, Codex, Cursor, Grok, OpenCode, Gemini, Copilot, Qwen, Kimi, Auggie, Kilo, Kiro and Pi.

---

Transcript

The transcript now uses LegendList across web, iOS and Android. Main transcripts, sidechains and public or read-only transcripts share the same renderer.

This was more than a list-component replacement. It changed how Happier owns scrolling, pagination, restoration, streaming growth, navigation and first-paint behavior.

Scrolling and position

• Streaming stays put. Long assistant replies no longer drag the view back to the bottom while you read further up.
• Once you scroll away, bottom follow remains disabled until you return or tap the jump button.
• Dragging the list turns follow off. Selecting text, tapping controls and expanding rows do not.
• Sending keeps you at the tail. Passive incoming messages do not steal that behavior.
• Older messages load in place. Pagination keeps the same message and position visible, including at the exact top.
• Older pages can prefetch without visible jumps.
• Opening a tool result or thinking block no longer moves the transcript unexpectedly.
• Touching or scrolling cancels automatic bottom following so the view stops fighting you.
• Initial bottom stabilization now ends promptly instead of continuing for up to eight seconds.
• Your position survives reloads. Reopening a session restores where you were reading across browser tabs and cold restarts.
• Tail jumps respect the user's reduced-motion preference.
• Typing focus stays with the transcript instead of bouncing to the page body.
• Late-decrypted and forked transcripts no longer remain stuck behind the first-paint placeholder.

Navigation rail and message pins

Long transcripts now have a dedicated navigation surface.

• Pin user, assistant and eligible tool messages.
• Jump back through earlier user turns without manually scrolling.
• Limit navigation to pinned messages.
• Jump beyond loaded history. Happier loads the target first and reports success only when it is visible at the requested alignment.
• A hover-preview rail appears on web when the viewport has enough room.
• Narrow screens use a panel or sheet.
• Navigation is available as a right-panel tab on desktop and a Cockpit tab on mobile.
• Returning to the live tail after a jump does not leave follow state confused.
• No plaintext previews or labels are stored on the server.

Message selection and send to session

• Tap a transcript message to begin selecting one or more messages.
• Copy selected messages or send them to another session.
• Send to session creates a draft using the selected content.
• Selection drafts survive route changes.

---

Message delivery and pending queue

Sending is now durable, visible and restart-safe.

• A new message first shows "Saving" or "Waiting for connection."
• It becomes Pending once the server has durably accepted it.
• Queued prompts survive restarts. They remain pending after closing the app or restarting the CLI.
• Sending to an inactive session wakes and reattaches it, then processes the message on the first viable attempt.
• Drag pending messages to change their delivery order.
• Deliver any message now. Pick a specific pending message instead of waiting for its turn.
• Happier steers when the Agent supports it, interrupts then sends when required, or sends normally when idle.
• Steer only when supported. The control appears only when capability evidence proves it is available.
• A blocked message shows one clear state and a written reason.
• Choose between always enqueue and always steer where supported.
• Choose delivery after foreground readiness or after all runtime activity becomes idle.
• Blocked pending deliveries count as attention in the session list.
• tmux, zellij and plain PTY sessions use a fast paste path with recovery for collapsed or mangled prompts.
• Oversized zellij pastes become visible durable errors instead of silent no-ops.
• One queue owns delivery. There is no second hidden delivery path.

---

Goals, workflows and work state

Goals describe what a session is trying to accomplish. Workflows show how that work is distributed, while runtime activity distinguishes the current foreground turn from background tasks that may continue afterwards.

Session goals

• Active writable Claude sessions show a goal chip before a goal exists.
• Goals reflect Claude's native /goal state rather than a parallel Happier representation.
• Goal usage appears as one line with time and tokens.
• A progress meter appears only when a budget exists.
• Budget setup lives behind "Add a budget limit (optional)."
• Goal status appears as text rather than a pill.
• Claude sessions never show Codex-only goal controls.
• Goal controls are disabled when the viewer lacks write access.
• Multi-line goal text is sanitized before /goal is sent.
• Codex goals start with /goal. You can inspect the active goal and remaining budget, then edit or cancel it from the composer.
• Blocked goals show a consistent reason.

Workflows and subagents

• Workflow runs show status, agent count, token use and duration in the transcript.
• A compact workflow line appears above the composer.
• Workflow detail is available from the shared work-state surface.
• Per-agent panels can be opened without losing detail while newer data arrives.
• Popovers no longer flicker, close or reorder unpredictably during refresh.
• Goal token and time use stays current, and expired workflow records stop appearing active.
• Subagent completion uses provider-native evidence rather than inferred activity.

Work state across providers

• Claude TodoWrite and Task state feed the shared work-state UI.
• Bounded OpenCode todo snapshots appear in the same surface.
• Add context, steer or pause a running goal from the composer control bar.
• Claude, OpenCode and ACP-backed sessions share the same work-state behavior instead of using provider-specific UI rules.

Runtime activity and background tasks

• Foreground turns and detached background work are shown separately, so you can start another turn while background work continues.
• Ready notifications fire at true foreground completion.
• Send, steer and wait behavior comes from an explicit input-readiness state
• "After runtime idle" waits for proof rather than elapsed time.

---

Session organization

Pins, folders and tags are now server-backed, so they remain consistent across devices and reloads.

Folders

Folders are enabled by default.

• Create, rename, nest, move, delete, collapse, expand and focus folders.
• Assign sessions through drag and drop or the context menu.
• Drag a session to the workspace root to remove its folder assignment.
• Open a focused folder view with breadcrumbs.
• Use the shared web, iOS and Android drag-and-drop pipeline with drag scrolling and edge targets.
• Offline changes roll back when the server rejects them.

Tags

Create, assign, remove and filter by tags, including filters containing several tags.

Pins

• Pinned sessions appear during the first load of long lists without requiring a scroll.
• The behavior was validated with 192 pinned sessions.
• Archived sessions do not consume pin quota, expose pin actions or appear in pinned lists.

Multi-select for sessions list

Long-press a row or use its menu, then archive, delete, move or mark several sessions as read. Selection survives list updates and scrolling.

Read state

Mark a session read or unread from the row menu, context menu, header or detail actions. Marking unread returns it to attention surfaces, and the change reaches connected devices immediately.

---

Cockpit on mobile

Cockpit provides all of the in-session tools necessary to work from your phone.

• Six tabs are available: Chat, Files, Git, Navigation, Tabs and Terminal.
• The Chat tab uses the active Provider name.
• Send from any Cockpit surface without opening the full compose flow.
• Session chrome survives nested routes and switches between normal and Cockpit views.
• Each tab keeps its own navigation state.
• Source-control state no longer flickers during tab changes.
• Background Cockpit tabs stop doing unnecessary work.

---

Claude unified terminal

Claude Unified runs the real Claude Code TUI inside a shared terminal host that can be controlled from both the terminal and Happier.

It is opt-in in Happier's Claude settings.

• tmux is used on POSIX, and bundled zellij is available everywhere, including Windows.
• The shared terminal replaces the previous mid-session switch between a terminal and the remote Agent SDK.
• Happier captures the TUI and streams it to connected devices.
• TUI permission requests appear in Happier's approval flow.
• Happier can inject queued messages without switching runtime modes.
• Queued input can interrupt and run through tmux or zellij.
• Claude dialogs are detected and displayed in Happier's UI
• Detached launches, foreground Windows hosts, pane liveness and socket trust checks were hardened.
• File following and sidechain observation now share one controller with bounded cleanup.

Runtime controls

• Model, reasoning effort, permission mode and plan mode are handled and applied from Happier's UI
• Permission requests, AskUserQuestion and ExitPlanMode are displayed in Happier's UI

Large-session resume

Choose between ask every time, resume from summary and resume the full session.

• Happier recognizes Claude's heavy-session resume dialog.
• Non-ask options can answer automatically.
• Ask every time holds startup without timing out.
• Answering in the terminal cancels the pending in-app question.
• Unknown dialogs fail closed instead of being guessed.

Clear a blocked composer

When leftover text in Claude's terminal blocks a queued message, Happier offers a Clear composer action.

• Explicit confirmation is required.
• Real user drafts are never cleared automatically.
• Outcomes distinguish already empty, refused during generation, unsafe dialog and actionable failure.
• The blocked pending message continues after a successful clear.

---

Connected Services

Connected Services lets you link Codex and Claude accounts directly to your Happier account, then use them in sessions across your machines.

Instead of signing in separately on every machine, you connect an account once in Happier. When you start a session, Happier materializes the selected authentication on the machine running it without modifying your global ~/.codex or ~/.claude home.

Connected Services remains experimental and can be enabled under Settings, Features.

Link once, use across machines

• Connect Codex and Claude accounts directly from Happier.
• Use the same account in multiple sessions and on multiple Happier machines.
• Choose an individual account or an account pool when starting a session.
• Inspect account health, remaining quota, reset times and available usage resets without leaving Happier.
• Reconnect accounts when credentials expire or required permissions are missing.

Account pools

Add several accounts for the same service to a pool and let Happier choose which one should be active.

• Reorder accounts to control fallback priority.
• Enable or disable individual pool members.
• Choose between priority-based, least-limited and manual selection.
• Configure the remaining-quota threshold that should trigger an early switch.
• Limit how many switches can happen during a turn or within an hour.
• See the combined available capacity of the pool.

Pools are shared by every session using them. When the active account changes, Happier applies the new pool generation to the other sessions bound to that pool instead of making each session discover the same exhausted account independently.

Hot account switching

Codex and Claude can switch accounts without restarting the session.

For Codex, Happier applies the new authentication directly to the running app-server and verifies that it adopted the expected account.

For Claude, Happier rematerializes and verifies the authentication inside the pool's managed Claude home. The session keeps its existing state and continues with the new account.

Before committing a switch, Happier checks that the target account and session state are reachable. A switch is reported as successful only after the running session proves that it adopted the new account.

If a live switch cannot be verified safely, Happier fails closed and can use an explicit restart-and-resume path where supported.

Soft-limit switching and pool-wide protection

Happier can switch before an account reaches its hard limit.

Before starting a turn, it can move to another account when:

• the current account is exhausted
• its remaining quota falls below the pool's soft threshold and a better account is available
• the account is stale or unavailable
• authentication has expired or become invalid
• credential refresh fails or the active account changes unexpectedly.

If one session discovers that the active pool account has reached a usage limit, Happier switches the pool and distributes that change to the other sessions using it. Those sessions can adopt the replacement account before they encounter the same limit themselves.

Switch limits prevent a broken pool or repeated authentication failure from causing an endless switching loop.

Automatic continuation

When a session reaches a hard usage limit, Happier can switch to another account and continue automatically.

After the new account is active, Happier can:

• resume with its standard continuation prompt
• send a custom continuation prompt
• resume without sending a prompt
• wait for the current account's limit to reset when no replacement is available.

Continuation preferences can be remembered for an account and overridden for an individual session. You can also ask Happier to switch accounts immediately instead of waiting for automatic recovery.

Quotas and reset times

Monitor connected-account usage directly from Happier.

• See remaining quota, account health and reset times for every connected account.
• View Codex usage windows and their next reset times.
• Monitor Claude usage alongside Codex accounts.
• See daily and weekly limits where the service reports them.
• Let the composer display the most constrained quota automatically.
• View pool capacity and the quota available from each member.
• See the same canonical usage data in the services list, account detail and session surfaces.
• Monitor native Codex, native Claude and environment or API-key authentication alongside Connected Services accounts.

Quota gauges show what remains, so 30% means 30% left. Warning colors appear as the remaining quota gets low.

Codex usage resets

Some Codex accounts receive usage-limit resets from OpenAI. Happier lists how many resets are available, when they expire and the individual reset credits reported by Codex.

Usage resets can be applied directly from Happier. Use "Apply usage reset" from the Connected Services account details, session quota gauge or usage-limit recovery banner. You do not need to visit a separate account page or restart the session.

Happier reports whether the reset succeeded, there was nothing to reset, no credit remained or the credit had already been used. A blocked session can continue once Codex accepts requests again.

Visible switches and notifications

Account switches appear as events in the session transcript, including why the switch happened and which account became active.

Happier can also notify you about meaningful quota, authentication and account-switch events using your existing notification preferences and quiet hours. Routine low-quota observations stay out of the transcript so they do not bury the conversation.

---

Agent autonomy

Happier already supported session creation and cross-session messaging in v0.2.1. This cycle makes those capabilities much more useful by exposing session creation directly to in-session Agents and expanding the coordination controls around it.

Coordination between sessions

Agents can create additional sessions with session.spawn_new, assign them work and continue while those sessions run independently.

They can also:

• send messages to existing sessions
• list sessions they are allowed to see
• inspect permitted session status and history
• coordinate work across sessions in the same workspace
• discover available Agents, models, modes, profiles and Connected Services
• choose the workspace, machine, model, mode and permission settings for a new session
• request terminal-backed or Windows sessions where available.

Child sessions inherit the relevant runtime and Agent context from their parent.

Permissions cannot be escalated. A child session cannot receive more authority than the calling session already has.

Coordination policy

Session creation and normal coordination are allowed by default, with Off and Ask-first controls available per action.

Useful runtime actions such as changing the model or mode and managing usage-limit recovery can be enabled separately. Destructive actions such as stopping or archiving another session remain disabled by default.

Session-spawn policy and pending-message timing are configurable from Settings.

Action approvals

Happier actions can pause execution and show a blocking approval request directly in the composer.

• Each action declares whether approval is required and whether the caller must wait.
• Approving or rejecting resumes the blocked caller with the real outcome.
• Disconnecting the caller does not destroy the approval request.
• Provider MCP prompts are suppressed when Happier already owns the approval decision.
• Approve is the first action across approval surfaces.
• Approval requirements can be configured by surface.

This avoids duplicate approval prompts while keeping sensitive cross-session actions visible and controllable.

---

Code review and source control

Review comments

Review comments turn diff review into a complete feedback workflow. Mark individual lines while browsing changes, collect comments across several files, then send the structured feedback to the current session or another session in the same workspace.

• Mark individual lines in unified diffs.
• Accumulate drafts across files in the same workspace.
• Inspect the pending count from the Agent input badge.
• Include or exclude comments before sending.
• Edit saved Markdown comment drafts.
• Send comments to the current session or a new session in the same workspace.
• Preserve structured review_comments.v1 metadata alongside a readable prompt.

Pull requests and branches

These features are experimental.

• Reuse an existing pull request when one already exists for the branch.
• Detect GitHub pull requests through connected credentials, with gh as a fallback.
• Push a branch or create a GitHub remote from the session.
• Create, switch and delete branches from the CLI.
• Parse remote HEAD and synchronize transfer targets.
• Limit review to selected files in large changesets.
• Initialize Git repositories from folders that do not have one.
• Keep branch summaries stable while state refreshes.

Codex native review

Codex review runs now use the native review/start app-server API where the request can be represented safely.

• Happier's review.start remains the product entry point.
• ReviewTarget::Custom preserves user instructions.
• enteredReviewMode and exitedReviewMode appear in the transcript.
• Results normalize into review_findings.v2.
• /codex.review starts an inline review.

---

Content and rendering

Mermaid on mobile

Mermaid diagrams render on iOS and Android. The runtime is bundled locally with no CDN fallback, and native network, message and navigation boundaries are sanitized.

Markdown rendering

• Streaming Markdown updates incrementally without rebuilding the full message.
• Only genuinely appended text is revealed.
• Enriched Markdown is selectable on iOS through native UITextView rendering.
• Tables, code fences and lists render consistently.
• Lists shrink-wrap safely on native.
• Static placeholder animation is suppressed on web.
• Compaction events appear as timeline cards.
• Session updates stream over sockets without polling.
• File details include Markdown preview.
• Source ranges stretch correctly.
• Ordered-list continuation was refined.

Rich Markdown editor

Edit markdown using the TipTap integrated editor and Notion-like slash commands.

• Supports headings, emphasis, inline code, task lists, blockquotes, code blocks, rules and links.
• Shows a formatted preview while editing.
• Falls back to raw when round-tripping would lose content.
• Falls back when the editor bundle is unavailable or the file is too large.
• Switching between raw and rich preserves content with synchronous flush behavior.
• Tables, math, Mermaid, images and a dedicated link dialog remain future work.

Generated images

Images produced by an Agent are treated as durable session media rather than temporary local paths or large base64 values embedded in transcript metadata.

• Codex, Cursor, Grok and ACP-backed Agents can publish generated images.
• Images use Happier's shared session media pipeline.
• Metadata survives protocol and session-state round trips.
• Native transfers support encrypted chunks.
• Images render inline and appear as media cards in file details.
• Missing or inaccessible media appears as unavailable instead of breaking the transcript.

---

Desktop and interaction

Custom themes

Create, edit and share custom theme profiles under Settings, Appearance, Themes.

• Clone Adaptive, Light, Dark or Classic Dark.
• Edit tokens grouped by canvas, surfaces, borders, active states and status colors.
• See changes immediately.
• Export versioned JSON.
• Import with validation and useful error messages.
• Keep Classic Dark read-only and cloneable.
• Apply the active theme to syntax highlighting, diffs, Monaco, CodeMirror, Shiki, startup, crash recovery, web CSS and native system UI.

Navigation transitions

• Layered directional slides now behave consistently across iOS, Android and web.
• Nested navigators preserve depth instead of flattening into cross-fades.
• Theme changes animate on web and desktop.
• The status bar follows the selected theme.

Keyboard shortcuts and commands

• Inspect and customize shortcuts from Settings.
• Send a pending message without opening the full composer.
• Shortcuts respect focus context and modal scope.
• Open the command palette with /.
• Search built-in commands, custom prompts and Happier commands.
• Navigate by keyboard with caret-anchored positioning on web.

Desktop shell

• Editors follow the active color scheme.
• OTA update status moved into the sidebar.
• Safe-area insets protect controls on notched Macs.
• Dark-mode shadows are quieter.
• Sidebar history state is visible.
• Startup routing and window lifecycle are more reliable.

Visual refresh

• App surfaces now use one curated icon system.
• Glass controls and unified status badges replaced several competing composer treatments.
• Appearance settings include tab-bar blur and refined active-state highlighting.
• Pane metrics, indicators, icons and compact actions are more consistent.
• Status dots pulse through native animation rather than JavaScript.
• FAB spacing, chevrons, picker controls, session headers and Provider icon sizing were refined.

Avatars

Avatar styles are deterministic across devices. Users can choose between several variants. Completed and archived sessions render in monochrome, while active sessions retain color.

Drafts and message history

• Per-session drafts survive navigation, tab changes and restarts.
• Arrow up and down browse previous messages from an empty composer.
• Recalled messages remain editable temporary drafts.
• Leaving history navigation restores the original draft.
• Selection and scroll behavior use one platform API.
• The caret remains visible on native.
• Oversized text survives edits.
• Attachments clear atomically after send.
• The optimistic clear that caused flicker was removed.

New-session picker

• Model, path, worktree and Agent options share one selection-list system.
• A light SCM snapshot appears immediately.
• Worktree counts load in the background.
• The model chip appears in under a second on real repositories.
• Favorite models sort first.
• Favorite Agent selections apply atomically.
• Agent targets and drafts survive wizard steps.
• Web pickers remain inside their modal boundary.
• Spawn hints pre-fill model, workspace and target.
• Authoring drafts and service bindings follow the selected Agent.
• The UI distinguishes the selected model from the model that actually applied.

Enter to send

Mobile has an enter-to-send setting. Web handling was refined to avoid accidental sends in multi-line input.

---

Sharing and privacy

• Public share capability URLs are redacted from logs, telemetry and server labels.
• Share tokens publish only after creation finishes.
• Public access is atomic and canonical.
• Envelopes validate and reads are capped.
• Public and read-only transcripts enforce their own action capabilities.
• Remote images require consent or a proxy.
• File and media grants are derived rather than assumed.
• Approval delegation clears on view-only shares.
• Broad shell permission grants are limited to simple commands.
• Session message retention is configurable.
• Durable local authority state is protected.

---

Terminal

Authenticated pairing

• Provisioning responses are sealed with a QR-only secret when available.
• Compatibility remains for older terminals.
• Pairing state survives deep links, web hashes, account redirects, scanner navigation and server-scoped pending state.
• Zellij socket roots are attested.
• Host attachment ownership is enforced.
• Daemon launch intents and terminal serviceability use typed contracts.

Reliability

• Terminal connections survive server switches.
• tmux and zellij recovery is more reliable.
• Pane cleanup and trusted-host liveness were repaired.
• Windows Terminal separators are escaped correctly.
• Window names survive reattachment.
• PTY backends were migrated.
• Web input writes are serialized.
• Stale input transport is avoided.
• xterm disposal waits for viewport synchronization.

---

CLI, daemon and development stack

happier status

Produces a read-only setup report covering authentication, relay health, background service, CLI installation and Connected Services.

happier service

happier service start | stop | status | repair provides explicit lifecycle control.

• Process trees clean up correctly through KillMode and AbandonProcessGroup.
• Daemon ownership and respawn supervision are more reliable.
• Stale default services repair automatically.
• Credentials validate before startup.

happier doctor repair

• One convergence command handles installation, updates and repair.
• Supports --report-only and --yes.
• Reports when the relay exists but is missing from $PATH.
• Selects the relay safely for the active channel.
• Uses consistent relay terminology.

Built-in commands

• /happier-diagnose creates a structured diagnostic snapshot.
• Provider state, session ID and optional attachments are included.
• Built-in commands appear alongside custom prompts.
• Bug reports can include attachments and a pre-filled session ID.

MCP

• Every session receives its own scope through session_agent.
• Execution-run waits use configurable MCP timeouts.
• happier mcp and --mcp-server are available.
• Built-in ports can be requested.
• Prompt registry installation passes through daemon RPC.
• Shell bridge context is opt-in and scoped.
• Remote metadata and tool schemas are forwarded.
• MCP context binds to the active runner and standard Provider sessions.

Local memory search

Local memory search builds a semantic index from previous conversations, allowing session-list search to find relevant work even when the exact words differ. It focuses on what you and the Agent said instead of treating every tool result or internal event as useful memory.

• Indexes only user and Agent message content by default.
• Excludes tool output, internal events and binary data.
• Uses role-filtered paginated fetching.
• Supports a bounded fallback for older sessions without role metadata.
• Covers the full session instead of stopping after 40 messages.
• Uses configurable shard budgets.
• Persists queue, progress and diagnostic state.
• Reports honest readiness in Settings.
• Adds memory results to session-list search.

Provider runtime improvements

• OpenCode: Live events own turn completion instead of periodic history repair. Compaction summaries remain out of normal assistant content. Completion waits for live idle evidence, and orphaned servers are reaped.
• Pi: Compaction events drive turn lifecycle correctly, with pending liveness and authentication continuity preserved.
• Gemini: Connected-service authentication continuity and usage-limit recovery are wired through recovery paths.

Session runner migration

Tracked sessions move to the new runner after a CLI update or restart.

• The UI can inspect live runner status.
• Stale-runner actions require matching daemon-machine identity.
• A restart reports success only after respawn completes.
• Timeouts and failures are typed and visible.

Development stack

• yarn tui and yarn dev reload without dropping sessions.
• A default-on stack proxy keeps the address stable.
• The UI shows "server restarting" during planned reloads.
• One owner controls daemon and server startup, replacement and shutdown.
• Schema changes cannot reload under a stale plan.
• Failed rebuilds preserve the last working server.
• Ambiguous port checks remain inconclusive instead of killing a process.
• Unchanged workspaces skip duplicate install and postinstall work.
• Remote targets are supervised independently.
• SQLite snapshots, Mutagen publication and tunnel retries are isolated.
• Corepack-managed Yarn is supported.
• Cross-stack daemon pollution and missed file-watch events are fixed.

Release pipeline and OTA

• Server promotion binds to one authorized SHA.
• Retries bind to immutable source identity.
• Rolling promotion is byte-audited.
• Binary publication is split into audited phases.
• Hosted releases have an immutable recovery path.
• Workflow credentials and actor guards are constrained.
• Versions sort semantically.
• Packaged server selection and migration runtime are included.
• System Status shows the installed channel, version and pending updates.

---

Performance

Thirty-five measured improvements landed across the app.

Transcript and lists

• Live rows subscribe by message reference.
• Cold projection builds from a bounded suffix.
• Session rows use stable incremental models.
• Search text derives from visible inputs.
• Badge subscriptions are narrower.
• Pane prefetch is deferred.
• Attachment references are stable.
• Agent-event selectors have independent revisions.

Rendering

• Streaming Markdown caches by message revision.
• Shiki tokenization is reused.
• Large inline payloads are bounded.
• Workflow cards are lighter.
• Usage chart formatting is reused.
• Reduced-motion subscriptions are shared.
• Authentication context is stable.

Data and crypto

• Decryption work is bounded and cached.
• Worker decryption batches.
• Sync histories are bounded.
• Cold machine hydration is bounded.
• Diff identities derive from bounded evidence.

Server and CLI

• SQLite WAL checkpointing prevents starvation.
• Shutdown maintenance is sequenced.
• Incremental vacuum is bounded.
• Unchanged migrations are skipped.
• Relay authorization caches per session publisher.
• Ownership lookups are narrower.
• Profile snapshots are cached.
• File logging is buffered with separate retention.
• Claude SDK metadata caches by runtime fingerprint.
• Transcript directories are watched.
• Socket payload observation is sampled.
• SCM updates batch.
• Remote dependency freshness is reused.
• Inline diff payloads are bounded, and large evidence is hashed.

---

Other features

Voice

• Voice sessions use the latest ElevenLabs real-time SDK.
• Stopping resets speaking and status state.
• Pending approvals read session-scoped transcript state.
• Voice sends bypass the pending queue.
• Text turns have durable ownership.
• Adapter handoff identity is preserved.

Pets

• Desktop companions support momentum dragging, tray bubbles and remembered dismissal.
• Native hover and notched-display sizing are supported.
• Desktop and mobile share one activity tray.
• Pet libraries store per account.
• pets.sync controls synchronization.
• Local Codex-compatible packages can be discovered, validated and imported.
• Native animation policy and activity behavior were improved.

Notifications and connectivity

• Push permission follows explicit user intent.
• Required native updates stay visible.
• Stale downgrade notices are suppressed.
• Notification operations are bounded.
• Endpoint authentication is supervised continuously.
• Sessions reconnect after credentials refresh.
• Planned restarts appear as neutral reconnects.
• Waits scope to the current turn.
• Active RPC degrades safely when a machine is briefly unavailable.
• Read cursors and sockets keep activity consistent.
• Client and session compatibility are negotiated across transports.

Session handoff

• Handoff contracts are target-aware.
• Provider runtime metadata survives local handoff.
• Pending external outcomes are explicit.
• Prepare-target ownership is fenced.

Windows

• Packaged binaries are preferred over Node for session startup.
• Terminal window names survive reattachment.
• Windows home paths resolve throughout the CLI and UI.
• Scheduled task detection is corrected.
• HAPPIER_HOME_DIR is respected.
• PATHEXT .cmd shims are preferred.
• Terminal arguments are quoted safely.
• Doctor repairs wrong-channel startup.
• Payload promotion survives contention.
• Publication locks retry.
• Daemon ownership authenticates.
• Patches work through workspace junctions.
• Atomic locks use wx.

Self-hosting

• SQLite connection limits are configurable.
• Server-light supports migration-only startup.
• Readiness probes and database telemetry are explicit.
• Startup diagnostics are sanitized.
• Pre-compressed UI assets are served directly.
• @fastify/compress reduces mobile transfer size.
• CORS preflight caching is configurable.
• Unreleased migration identifiers are portable.
• MySQL key widths are synchronized.
• OpenAI device-auth transactions persist securely.
• Validated ghops credentials use Keychain.

---

Fixes

Claude

• Sessions resumed from an assistant turn. They now resume from the last user turn.
• Subagent completion sent false ready notifications. It is now excluded from the ready path.
• Result-only turns did not advance lifecycle. Tool-result turns now count as turns.
• Global Claude installs could not be resolved. npm-installed Claude now resolves through process.execPath.
• Startup recovery and direct authentication use aligned paths.
• SDK transport, task identity and permission routing are preserved.
• Remote prompt delivery binds to Provider evidence.
• Killed tasks are terminal, and stale task activity expires after an idle recheck.
• Account state reconciles correctly across isolated and shared homes.
• Hook plugins, statusline transitions and runner exit handling remain stable across restarts.
• Resume-summary turns are fenced, and unavailable transcripts fail closed.
• Structured dialog choices work, duplicate submission is prevented and stale residue settles.
• Unified terminal preserves Provider-pending prompt state.
• Multiline command artifacts and internal Claude records stay hidden.
• The PreToolUse authentication scrub hook no longer rewrites Bash commands in PR fix(cli-claude): stop rewriting Bash commands in PreToolUse auth-scrub hook #202.
• Invalid assistant records fail softly in PR fix(protocol): fail-soft on malformed Claude assistant transcript rows #196.
• Claude internal record types remain out of transcripts in PR fix(claude-transcript): skip internal Claude record types in transcripts #206.

Codex

• Transcript writes bypassed the session port. They now use the canonical route.
• Permission identity used unstable tool titles. It now uses tool.id.
• MCP elicitation was dropped. Requests now reach Happier's approval flow.
• Duplicate simultaneous permission requests share an allowlist.
• Restart guards prevent the metadata watcher from hanging.
• Default mode and fast controls survive restarts.
• App-server overrides reconcile before turns.
• Resume IDs and local paths are sanitized from logs.
• Prompt and authentication work serialize.
• Rollout boundaries persist.
• Execution-run control identities survive.
• Selected Connected Services homes are probed, and group affinity is retained.
• Aggregate reset credits are handled.
• Goal status and timestamps normalize.

OpenCode, Pi, Gemini, Grok and ACP

• OpenCode turns could remain stuck after installer repair. The idle transition is now stable.
• OpenCode supervisor command overrides now apply.
• Managed-server turn ownership has one owner, and children bind to process-birth identity.
• Pi lost pending-turn liveness during auth switches. That state is now preserved.
• Stale Pi startup failures are fenced.
• Gemini authentication continuity and usage-limit recovery are connected.
• Grok's invented fallback model was removed.
• ACP prompt completion correlates correctly.
• ACP timeout failures include stderr.
• Wrapped sessions preserve Provider arguments.
• Brokered prompt delivery is replay-safe.
• Failed Provider catalog hooks retry.

Connected Services and authentication

• Credential writes, refreshes and mutations are revision-fenced.
• Quota-driven switching converges without duplicate fan-out.
• OAuth refresh entitlement and exchange credentials are verified.
• Runtime-auth outbox retries are bounded.
• Durable recovery has one owner.
• Account adoption binds to the current runtime.
• Broker readiness binds to exact custody.
• Endpoint descriptors validate strictly.
• Provider type survives handshakes.
• Explicit selections remain selected.
• Recovery credits can route through any online daemon.
• Usage hydrates only from proven source snapshots.
• Native credential diagnostics stay out of production logs.
• Authentication success diagnostics no longer leak.
• Canonical active endpoints are used after interruption.

Sessions and transcripts

• Deleting a session navigates away immediately.
• Interrupted request context survives input dismissal.
• Permission state clears on reload.
• Provider context and usage badges return after navigation.
• Tool groups expand after collapse.
• Native transcript actions render again.
• New-session targets survive wizard steps.
• Duplicate user echoes are removed.
• User socket connections no longer trigger spurious wakes.
• Hidden sessions still receive new-message updates.
• Active and unread failures remain promoted.
• Progress and real runtime work are distinguished.
• Visibility survives aliases and route exits.
• Inactive wrappers unsubscribe.
• Failed server sessions remain in durable attention results.
• Runner status survives remounts.
• Transcript activity survives hydration.
• Viewport records are isolated.
• Launch and spawn identity survive retries.
• Handoff ownership is atomic.
• Stop requests and confirmed exits remain distinct.
• Resume state derives from lifecycle evidence.
• Manual unread survives without transcript data.
• Offline recovery and released v0.2.1 compatibility are preserved.
• Session turns terminate without successor drift.
• Child sessions inherit model options.

Transcript rendering and composer

• Monochrome avatars render for inactive sessions.
• Ordered lists and native list sizing are corrected.
• Static placeholder animation no longer causes web jank.
• Native send crossover is atomic and visible once.
• Row measurements survive layout changes.
• Viewport writes and reader intent each have one owner.
• First paint reveals at the first usable frame.
• Older pagination preserves anchors.
• Web jumps land reliably.
• Held-tail state survives layout changes.
• Tool-row chrome and message-bound detail remain stable.
• Read-only interaction policies are enforced.
• Unsupported placeholders are localized.
• Web keyboard events belong to the composer.
• Android layout ignores duplicate measurements.
• Insets update without same-frame lag.
• Selection survives draft adoption.
• Oversized text waits for safe flush points.
• Goal popovers reserve keyboard space.
• Drafts survive stale writes and host synchronization.

Interface

• Voice stop clears stale status.
• Voice approvals use session state.
• Voice sends use the immediate path.
• Cockpit chrome survives nested routes.
• Approve remains the primary action.
• Web popover portals no longer remount repeatedly.
• Picker favorites appear above text.
• Android new-session scaffolding remains anchored.
• Synchronization recovers after connectivity returns.
• Aggregate code-search results are honest.
• Native subagent tasks render correctly.
• Web fonts are awaited at startup.
• Modal focus restores correctly.
• SVG previews are sanitized.
• Diffs settle before reveal.
• Crash recovery and list lifecycle are hardened.
• Drop targets and composer autosize are stable.
• Public share generations are isolated.
• Permission dispatch is deduplicated.

CLI, daemon, server and release

• Session metadata writes retry with backoff.
• Terminal sessions survive server changes.
• Dead settings locks are reclaimed.
• Valid macOS Agent aliases pass the daemon guard.
• setup-relay preserves the selected server.
• Doctor uses consistent relay terminology.
• Setup channel detection is correct.
• Duplicate metadata refreshes are removed.
• Tailscale polling respects its deadline.
• Replacement server IDs are adopted.
• Failed snapshots stay out of best-effort delivery.
• Session-end socket mutations are acknowledged.
• Daemon publication carries owner proofs.
• Restarts coalesce.
• Launch environments are pinned.
• Builds use immutable source generations.
• Abandoned build sources are reclaimed.
• Runtime entrypoints resolve from validated snapshots.
• Restart storms are bounded.
• Endpoints refresh before retry.
• Service teardown fails closed.
• Cross-platform runtime resolution is normalized.
• Access keys fail after machine retirement.
• Public sharing redacts capabilities.
• Encryption mode transitions serialize.
• Tool policies fail closed.
• Opaque identifiers survive end to end.
• Secret-like model options are redacted.
• Atomic JSON ownership survives contention.
• File watchers finish teardown.
• State-sharing lock failures retry.
• Docker release runtime loads before publishing.
• Finalization remains dependency-free.
• Dry-run planning stays out of secrets.
• Native patches build from source.
• Windows staging and payload promotion are hardened.
• Missing sherpa-native and sessionHookAttribution modules are included.
• Asynchronous daemon spawns settle in the testkit.