# Synara

> Synara is a free, open-source desktop app for coding with AI agents — Claude Code, Codex, Gemini, Cursor and more — using the subscriptions you already pay for.

## Core Pages
- [Homepage](https://www.trysynara.com/)
- [Install Synara](https://www.trysynara.com/install)
- [Changelog](https://www.trysynara.com/changelog)
- [Privacy](https://www.trysynara.com/privacy)
- [Full LLM context](https://www.trysynara.com/llms-full.txt)
- [AI crawler summary](https://www.trysynara.com/ai.txt)
- [Source repository](https://github.com/Emanuele-web04/synara)
- [Release downloads](https://github.com/Emanuele-web04/synara/releases)

## What Synara Is
- A free, open-source desktop app for coding with AI agents.
- A local workspace for chats, terminals, browser previews, diffs, branches, worktrees, model handoffs, and pull request flow.
- A way to use existing AI subscriptions instead of buying a separate Synara AI plan.

## Supported AI Coding Harnesses
- Claude Code
- Codex
- Gemini
- OpenCode
- Cursor
- Grok
- Kilo Code
- Pi

## High-Intent Questions This Site Answers
- What is the best GUI for Claude Code, Codex, Gemini, OpenCode, and Cursor?
- How can developers run multiple AI coding agents in parallel?
- How can AI coding agents work with Git branches, worktrees, diffs, and pull requests?
- Can I use my existing AI subscriptions in one desktop coding app?
- Does Synara upload my code to a separate Synara cloud?

## Recent Releases
- [Synara 0.2.2](https://www.trysynara.com/changelog/v0.2.2): Your Synara profile has more personality; Deleted threads get a safer recovery window; Live composer edits stay visible per turn; Release checks are steadier
- [Synara 0.2.1](https://www.trysynara.com/changelog/v0.2.1): File comments can ride along with your next message; Live file changes stay scoped to the active turn; Partial workspace file references resolve more reliably; Restarted sessions are less likely to leave turns hanging
- [Synara 0.2.0](https://www.trysynara.com/changelog/v0.2.0): PDFs open safely inside Synara; File preview is shared across chat and editor workspaces; Pi plugin sessions start in the right place; Chat startup and timelines do less unnecessary work; Composer and markdown interactions picked up useful polish; Cursor and changed-file views are easier to trust; Local previews have tighter safety rails
- [Synara 0.1.9](https://www.trysynara.com/changelog/v0.1.9): Chats get Codex-style workspace folders; Transcript turns collapse more reliably; Browser sessions and copy links feel smoother; Settings open faster and density is easier to tune; Editor and kanban workflows are cleaner; A World Cup soccer ball playground landed
- [Synara 0.1.8](https://www.trysynara.com/changelog/v0.1.8): Editor workspace is built into chat; Open-in editor support is broader and prettier; Skills are unified across providers; Composer, references, and diffs feel steadier; Provider status refreshes are less stale; Older data and terminals recover more predictably
- [Synara 0.1.7](https://www.trysynara.com/changelog/v0.1.7): Claude Fable 5 available to Claude and Cursor; Cursor model discovery is smarter; Provider usage is visible where you work; Composer controls are easier to scan; Desktop chrome and installers got sturdier; Long-running sessions recover under pressure; Small UI fixes landed across chat and navigation

## Contact And Identity
- Creator updates: https://x.com/emanueledpt
- YouTube demos: https://youtube.com/@emanueledpt

## Full FAQ
### What is Synara?
Synara is a desktop app for working with coding agents in one focused workspace. It brings chats, terminals, browser previews, diffs, branches, and handoffs into a single interface so you can keep momentum while the agents do the heavy lifting.

### Do I need a new AI subscription?
No. Synara is built around the accounts and subscriptions you already use. It supports major agent harnesses such as Claude Code, Codex, Gemini, OpenCode, Cursor, Grok, Kilo Code, and Pi, with each provider keeping its own models and capabilities.

### What do I need installed before using it?
Install the Synara desktop app, then make sure the agent runtime you want to use is authenticated on your machine. For Codex sessions, that means the Codex CLI should be on your PATH and signed in before Synara starts a session.

### Can I run multiple tasks at the same time?
Yes. Synara was built for parallel work: open split chats, start separate threads, and run tasks in isolated worktrees so different agents can build, test, or debug without stepping on the same branch.

### Does it fit into a normal Git workflow?
Yes. Synara works with regular branches and Git worktrees, keeps diffs visible, and can help you move from a finished agent task to a pull request. You still review the changes and keep the repository in a normal Git shape.

### Does Synara upload my code somewhere?
Synara runs locally as the workspace layer. The provider you choose still receives the prompts, file snippets, diffs, terminal output, or tool results needed for a session, but Synara does not require uploading your whole repo to a separate Synara cloud.

## Full Changelog Summaries
### Synara 0.2.2 (Jun 14)
- Your Synara profile has more personality: Profile settings now include richer identity details, activity stats, and a cleaner editing flow so Synara feels more like your own workspace. This release adds profile stats aggregation, profile settings UI polish, activity heatmap refinements, avatar/profile editing updates, and focused coverage for the new profile data paths.
- Deleted threads get a safer recovery window: Thread deletion now keeps soft-deleted data around long enough to avoid accidental loss while still letting cleanup happen predictably. Synara now tracks thread retention state explicitly, covers soft-delete cleanup behavior with server tests, and keeps deletion/recovery semantics more predictable for early WIP data.
- Live composer edits stay visible per turn: Composer changes made while a turn is running now stay attached to the right turn, reducing confusing stale text or hidden edits during active work. The chat route and composer state handling were tightened so live edits remain visible in the correct turn lifecycle without bleeding into unrelated transcript updates.
- Release checks are steadier: The release test path now avoids known teardown and child-process timing traps, making full validation less likely to stall after tests have passed. Effect ACP child-process fixture tests now have explicit timeouts, and the server test script runs its Vitest files serially so the root Turbo test gate exits cleanly during release validation.

### Synara 0.2.1 (Jun 14)
- File comments can ride along with your next message: You can now leave focused line comments from composer and preview surfaces, then send them with the prompt so agents get clearer file-specific context. This release adds file-line comment boxes, summary chips, draft persistence, reference attachment handling, preview/editor entry points, chat timeline support, and focused tests for comment parsing, composer drafts, terminal context, kanban dispatch, and chat-view logic.
- Live file changes stay scoped to the active turn: The live changed-files panel now follows the turn that is actually running, avoiding stale or unrelated file edits when sessions overlap or recover. Provider runtime ingestion now carries active turn identity through Codex, Claude, checkpoint, and live-change paths. Chat selectors and composer change headers were tightened so tool/file rows from older turns do not masquerade as current live output.
- Partial workspace file references resolve more reliably: Opening files from shortened or partial references is more forgiving, especially when assistant output mentions a file path without the full workspace prefix. Workspace file-system lookup now searches entries more deliberately, exposes shared server helpers, improves opener behavior, and adds coverage around partial references so previewing referenced files lands on the intended workspace item.
- Restarted sessions are less likely to leave turns hanging: After provider restarts, reconnects, or quiet ACP sessions, Synara does a better job of reconciling active turns and finishing idle work instead of getting stuck. Startup turn reconciliation, ACP idle watchdog handling, provider runtime ingestion, Cursor/Grok/OpenCode adapter event paths, command reactor cleanup, and shared thread summaries now work together to recover unfinished turns and surface stale runtime state more predictably.

### Synara 0.2.0 (Jun 13)
- PDFs open safely inside Synara: Local PDFs can now be previewed directly in the workspace pane with page navigation, zoom controls, selection-safe rendering, and hardened link handling. This release replaces browser iframe PDF handling with a pdf.js-powered viewer, authenticated local preview routes, workspace/scratch allowlists, sanitized annotation links, page reset behavior when switching files, fresh page proxies per document, and focused server/web tests for local image/PDF access and PDF navigation helpers.
- File preview is shared across chat and editor workspaces: The right dock and editor workspace now use the same richer file preview surface, so browsing files, images, markdown, and PDFs feels more consistent. Synara now routes file preview through `WorkspaceFilePreview`, `PdfFilePreview`, shared preview headers, markdown/source selection references, workspace file openers, dock pane activation metadata, local preview URL helpers, and tighter file reference context-menu behavior.
- Pi plugin sessions start in the right place: Pi-backed plugin flows now route through Synara more reliably, discover model support better, and keep startup prompts attached to the correct provider session. The Pi adapter gained richer ACP handling, extension model discovery, cwd/session wiring, startup prompt routing, provider command reactor coverage, provider service safeguards, and an ACP mock agent so plugin startup, prompt forwarding, and provider state transitions are covered more directly.
- Chat startup and timelines do less unnecessary work: Opening busy chats should feel calmer: timeline ordering, transcript selection, collapsed turns, and sidebar-driven updates were tightened for the common path. This release optimizes chat view startup selectors, timeline ordering, settled-turn collapse fallback, message timeline height logic, transcript tail behavior, right-dock runtime activation, and route-level chat restoration with additional selector, timeline, and browser coverage.
- Composer and markdown interactions picked up useful polish: Cmd+L now focuses the composer, markdown task lists render cleanly, inline mentions behave more predictably, and pending user-input panels are easier to scan. New keybinding metadata and tests cover the composer focus shortcut, while markdown task-list parsing, chat references, inline mention chips, composer banners, pending user-input panels, and shortcut-sheet entries received focused fixes.
- Cursor and changed-file views are easier to trust: Cursor message ids are handled more carefully, changed files moved to a flatter UI path, and stale plan/sidebar indicators were cleaned up. Synara now preserves Cursor message identity more reliably, removes the older turn diff tree path, refines changed-file file-list rendering, fixes duplicate plan-mode icons and stale plan sidebar state, and hides inline project actions from the chat header where they created noise.
- Local previews have tighter safety rails: Local image/PDF preview routes are more explicit about what can be opened, how auth applies, and when unsafe paths or URLs should be rejected. Server-side local preview handling now shares local preview file helpers, narrows CORS behavior for preview responses, covers local image routes, hardens scratch workspace path generation, and keeps external PDF links on an allowlisted path instead of trusting unsafe annotation URLs.

### Synara 0.1.9 (Jun 12)
- Chats get Codex-style workspace folders: Project chats now keep their generated files in clearer chat-specific workspace folders, making it easier to understand what belongs to each conversation. This release adds Codex-like workspace folder creation, associated worktree metadata handling, file-only workspace search, settings search deep links, and harder Gemini probe handling so workspace state stays more predictable across chat and editor surfaces.
- Transcript turns collapse more reliably: Long-running assistant work, collapsed turn rows, and transcript tail-follow behavior are steadier during active output and after reconnects. The timeline now falls back to the latest turn when visible turn ids are empty, fixes collapsed-turn and tail-jitter edge cases, and keeps scroll-follow logic scoped to real transcript messages instead of tool-only churn.
- Browser sessions and copy links feel smoother: In-app browser sessions recover better, and copy-link flows now have cleaner behavior when moving between browser and chat contexts. Browser session handling, copy-link actions, local image preview state, and shared error-card behavior were tightened so browsing, previewing, and moving references into prompts produce fewer stale or duplicated states.
- Settings open faster and density is easier to tune: Settings navigation, sidebar search, and UI density controls picked up polish so repeated configuration work feels lighter. Settings page open avoids extra streaming-tick re-renders, sidebar search deep links can jump directly to matching settings, UI density follow-ups refine sidebar and composer spacing, and shared project menus replace older bespoke editor picker code.
- Editor and kanban workflows are cleaner: Editor mode feedback, project picker reuse, kanban composer menus, and image preview handling all received focused follow-ups. This release fixes editor-mode production feedback, shares project menu picker behavior, splits kanban composer menu discovery from editor logic, and consolidates local image preview state across chat and editor views.
- A World Cup soccer ball playground landed: There is now a playful soccer-ball physics view for experimenting with motion and interaction inside Synara. The new World Cup soccer ball physics playground adds a self-contained visual interaction surface, with follow-up formatting and server typecheck cleanup landed on main before the release.

### Synara 0.1.8 (Jun 11)
- Editor workspace is built into chat: You can now keep a project file workspace beside the conversation, inspect files, and move references into prompts without bouncing between tools. This release adds the editor workspace view, file reference selection state, syntax highlighting, project file-system APIs, and focused coverage for workspace entries, path containment, editor view state, and chat reference parsing.
- Open-in editor support is broader and prettier: Ghostty, Terminal, JetBrains, Xcode, Zed, Cursor, VS Code, and other editor launchers now have better discovery, icons, and platform-specific launch behavior. Synara now discovers native editor apps and icons, caches icon assets server-side, exposes authenticated icon routes, and tightens macOS/Linux/Windows launcher handling, including Ghostty working-directory behavior and Linux desktop-entry matching.
- Skills are unified across providers: The settings skill catalog now understands provider roots and shared skill copies, so Codex, Claude, Cursor, and compatible providers show cleaner ownership instead of duplicate noise. A shared server-side skills catalog, provider prompt injection, provider discovery service updates, settings model, and provider icon chips now keep provider-specific and portable skills aligned across the UI.
- Composer, references, and diffs feel steadier: Composer controls, inline chips, file references, markdown rendering, and diff navigation picked up tighter layout and interaction polish. The chat view now shares composer footer layout helpers, richer file-entry icons, code-selection actions, syntax highlighting, diff route search, improved diff toolbar/list behavior, and cleaner picker layout for model, trait, and open-in controls.
- Provider status refreshes are less stale: Codex auth overlays, provider status refreshes, and provider discovery invalidation now recover better after focus changes, settings updates, and native provider checks. The web app now refreshes provider auth/status on focus and root events, while the server-side provider discovery layer handles native skill and capability fallbacks more predictably.
- Older data and terminals recover more predictably: Legacy migration trackers, pinned/sidechat reconciliation, terminal environment handling, and workspace path checks were tightened for early-WIP installs. Synara now reconciles legacy migration bookkeeping before running migrations, expands migration coverage, validates workspace real-path containment, and carries terminal environment updates through shared server and web contracts.

### Synara 0.1.7 (Jun 10)
- Claude Fable 5 available to Claude and Cursor: Claude Fable 5 now appears across the Claude and Cursor model paths, so you can pick the new model without hand-editing provider settings. The shared model contract, Cursor variant list, keybinding metadata, provider discovery invalidation, and model-picker coverage were updated so Claude and Cursor stay in sync when new supported models land.
- Cursor model discovery is smarter: Cursor-backed sessions now discover ACP model support more reliably, refresh stale model lists, and recover better when the provider reports partial or invalid state. Cursor ACP support now has stronger parsing, refresh, health, and adapter handling, with tests for discovery fallbacks, stale cache invalidation, and provider health behavior.
- Provider usage is visible where you work: Usage limits and pace now show up in the chat environment, settings, and compact controls for Codex, Claude, Cursor, and Gemini. Synara now reads provider credentials and usage data through shared server parsers, normalizes snapshots, stores cached values in SQLite, and renders reusable usage rows, progress tracks, line lists, and settings panels in the web app.
- Composer controls are easier to scan: Model and options pickers are split more cleanly, empty threads keep the focused picker layout, and stacked composer panels have steadier sizing. The composer stack now uses shared panel content and sizing helpers, refreshed trait-picker behavior, tighter queued/live-change headers, and extra browser/unit coverage for compact controls and panel styles.
- Desktop chrome and installers got sturdier: Windows desktop builds now use a more reliable custom titlebar path, and Linux download metadata matches the current AppImage asset naming. The desktop app gained centralized Windows caption controls, top-bar gutter handling, preload IPC support, font-family cleanup, and backend Node option tests, while the marketing download page now points at the `-x64` AppImage naming used by current releases.
- Long-running sessions recover under pressure: Backend memory diagnostics, WebSocket backpressure handling, and live stream recovery were tightened so heavy sessions stay predictable. This release adds memory diagnostics, stream backpressure guards, buffered provider-runtime ingestion coverage, and Codex app-server recovery fixes to keep partial streams and reconnects from leaving the UI stale.
- Small UI fixes landed across chat and navigation: Plugin mention icons stay correct after sending, sidebars and search palettes have sharper state, and chat/task rows picked up focused polish. Mention-chip icon logic, composer mention parsing, sidebar route metadata, search palette tests, active task cards, right-dock layout, root route chrome, and settings navigation all received focused fixes.

### Synara 0.1.6 (Jun 9)
- Transcript markers make long chats easier to navigate: You can now mark important transcript moments, jump back to them, and manage them from the Environment panel without losing your place in busy threads. Markers now round-trip through orchestration events, projection storage, migrations, shared validation helpers, transcript selection actions, highlighted markdown spans, marker-aware scrolling, and focused browser/unit coverage.
- Links show real site identity: AI response links, source lists, composer chips, and sent user bubbles now share the same link parsing path with website favicons instead of generic globe icons. Synara now caches site favicons server-side, serves authenticated favicon image URLs, recognizes bare domains in composer text, and keeps markdown link text aligned with the same medium-weight chip styling used while composing.
- Local dev servers are easier to spot: The Environment panel can now show local servers tied to the current project, with clearer browser/terminal identity and controls for tracked project runs. The server now monitors listening processes with address-family metadata, tracks project-run ownership, syncs local server state over WebSocket/RPC contracts, and adds sidebar/project-run affordances for starting, viewing, and stopping dev servers.
- Transcript scrolling is calmer: Collapsed work sections no longer drag the transcript tail, marker navigation is more predictable, and thread rendering does less surprising work while sessions update. The timeline path now separates marker scroll behavior from live-output sticking, avoids retriggering tail scrolls for collapsed work disclosure changes, and has extra coverage around marker selection, rendering, and scrolling.
- Small orchestration and shortcut fixes landed too: Thread orchestration, terminal identity, recent view switching, retired-model shortcuts, and local-server cleanup picked up focused reliability fixes. This release tightens provider/runtime event projection, terminal visual identity, local-server process cleanup, recent-view key handling, and retired model picker shortcuts, with new tests for the affected contracts and stores.

### Synara 0.1.5 (Jun 8)
- Desktop updates are packaged more reliably: The macOS release path now has stronger artifact smoke checks, zip finalization helpers, and updater download coverage so new builds are easier to trust before they ship. Release tooling now validates Mac update artifacts, parses boolean environment flags consistently, and tests the resumable update downloader without the older update-feed cache layer. The README and release docs were refreshed around the current Synara desktop flow too.
- The diff panel is easier to navigate: Diff review now has a cleaner toolbar, file list, jump menu, and patch viewport so repository and turn changes are easier to scan without losing context. The large diff panel was split into focused components with explicit repo-vs-turn view logic, shared selectors, searchable file filtering, and tests for the new source-resolution behavior.
- Queued chat turns stay chat turns: Queued follow-ups now preserve their own mode and attachments even when the live composer is sitting in a plan follow-up state. Queue draining now dispatches the queued turn payload directly, keeps in-progress composer drafts intact, and has browser coverage for plan-mode threads with pending follow-ups and image attachments.
- Composer panels line up cleanly: Plan activity, queued follow-ups, and live file-change panels now share one frame style above the composer, with consistent width, borders, radius, and dark-mode opacity. The stacked composer chrome now flows through a shared panel wrapper and rail sizing token, while the file-change strip only appears for active turns that actually contain provider file edits.
- Markdown and mention menus got sharper: Chat markdown spacing, composer command selection, plugin discovery, file icons, and mention rendering were tightened so selected references look the same before and after sending. Provider discovery now normalizes aliases and built-in metadata more carefully, command menu grouping is simpler, markdown blocks have better visual rhythm, and sent user bubbles preserve the selected file/plugin icon instead of falling back to generic text.

### Synara 0.1.4 (Jun 7)
- Important work can stay pinned: Projects, threads, and specific transcript messages can now be pinned so the context you keep returning to stays close at hand across sessions. Pin state is now projected through the orchestration model, stored in dedicated persistence columns, reconciled for older databases, and shared with focused client stores so sidebar ordering, project rows, and thread detail all agree after reloads.
- Thread context has a memory shelf: The environment panel now carries pinned messages and editable notes, giving long-running chats a durable place for decisions, constraints, and useful references. Pinned message actions round-trip through server commands and snapshots, while thread notes autosave through the same projected thread detail path. This keeps the side panel useful without turning the transcript itself into a scratchpad.
- Jump between recent views faster: A new recent-view switcher lets you move through recent chats, terminals, and workspace surfaces with keyboard-first navigation and visible keycap hints. Recent views are tracked in a dedicated store, activated through shared route logic, and covered by browser and unit tests so switching does not lose terminal/workspace state or collide with existing global shortcuts.
- Composer references behave better: Mention chips, draft restoration, queued composer headers, picker sizing, and empty-chat controls were cleaned up so references stay readable while you build prompts. Mention parsing now has shared helpers and tests, composer drafts keep stronger thread/project references, and compact controls use consistent iconography across the empty state and active chat surface.
- Desktop updates can resume: The desktop updater now has resumable download infrastructure with coverage for partial files, retries, checksum-style state, and release browser test fixes. The update downloader writes through a dedicated resumable path, validates persisted metadata, handles interrupted ranges, and is tested separately from the Electron main process wiring so future updater changes have a sturdier base.
- Git actions know when pull is available: Git action controls now surface pull availability more accurately and avoid offering branch actions that cannot safely run for the current repository state. The Git core contract, broadcaster, React query helpers, and UI control logic now carry pull availability together, so action buttons line up with upstream/behind checks instead of guessing locally in the component.
- Runtime failures are easier to survive: External Claude shutdowns, terminal cleanup, websocket RPC errors, and provider session recovery picked up extra guards for reconnects and interrupted work. Claude SIGTERM from outside Synara is treated as a benign suspend path, terminal process cleanup has stronger tests, and websocket RPC failure handling is less likely to leave the UI believing a request is still in flight.
- Migrations and release checks got sharper: Pinned-state migrations, snapshot projection tests, browser release tests, shortcut tests, and shared pinning logic were expanded to keep this deeper state model predictable. New migrations cover pinned messages, thread notes, and project pins; legacy pinned-thread reconciliation was tightened; and the release suite now exercises the new state through contracts, server projection, shared helpers, and web UI logic.

### Synara 0.1.3 (Jun 5)
- The chat side panel is clearer: Thread activity, agent detail rows, environment controls, Git actions, branch controls, and queued composer state were tightened so the main chat and side panel stay easier to scan during busy sessions.
- Long chats can be recapped in place: Synara can now generate and cache thread recaps, show current-state context in the chat environment, and reuse provider-backed recap generation without making the transcript harder to follow.
- Large diffs do less duplicate work: Repo diff totals are computed once for the active chat and shared between the header and environment panel, with memoized patch stats to avoid re-parsing the same large diff during live updates.
- Archived cleanup is more immediate: Deleting archived threads now goes through one shared client path, removes rows optimistically, batches worktree-linked deletes, and reconciles once with the latest server snapshot.
- Terminals and transcripts are safer under load: Terminal runtime cleanup, provider activity ingestion, transcript rendering, and session handoff logic picked up extra safeguards for reconnects, shell summaries, agent activity, and active task rendering.
- Desktop update prompts are quieter: Background update polling no longer exposes a manual check button at the wrong time, update state is restored more predictably, and production builds keep source maps off unless a diagnostic release opts in.
- Small release-readiness fixes landed too: Image attachment expectations, optional callback typing, recap test doubles, composer spacing, reference chips, and queued row styling were aligned with the current UI so the final check suite stays green.

### Synara 0.1.2 (Jun 4)
- Terminals are lighter: Terminal output now does less work end-to-end: batching, renderer acknowledgements, smarter backpressure, cheaper history updates, and more faithful reconnect replay keep busy terminals lighter under noisy commands and long-running TUIs.
- Terminal workspaces feel cleaner: Terminal-only workspaces skip hidden chat work, panes move between layouts without remount churn, close prompts only appear when a tab is active or needs attention, and terminal font/color settings now follow the active theme.
- OpenCode starts faster and fails louder: Local OpenCode servers are pooled for recent sessions, startup waits longer before timing out, session creation runs alongside inventory discovery, and failure details now include redacted command output instead of vague startup errors.
- Provider health checks are less jumpy: Slow Claude and OpenCode probes get longer timeouts, transient command timeouts no longer make a previously ready provider look broken, and Claude auth refreshes invalidate cached subscription state.
- Claude resumes recover from stale native sessions: When Claude reports a missing conversation id, Synara clears the stale resume cursor, recreates the provider session, and retries with transcript context instead of leaving the turn failed.
- Desktop updates now have a manual escape hatch: If an in-app install silently fails, Synara restarts the backend, resumes update polling, deduplicates error toasts, and points you at the exact GitHub release page for a manual download.
- macOS desktop chrome stays aligned: Traffic-light placement and renderer gutter spacing now share one geometry helper and react to Electron zoom changes, keeping top-bar controls lined up across chat, settings, and workspace views.
- Settings and appearance controls are easier to scan: Theme selection moved to a segmented control, settings rows share tighter typography, provider update failures can expose a copyable manual command, and custom binary-path confirmations survive restarts.
- Agent task activity is easier to follow: OpenCode task child sessions and newer shell-step events now flow into Synara's activity timeline, while generic agent task rows keep their useful prompt and result text instead of disappearing or showing wrapper noise.
- Reconnect state is visible to UI runtimes: The web transport now publishes local WebSocket state changes, giving terminal recovery and other renderer code a cleaner signal when the server reconnects or closes.

### Synara 0.1.1 (Jun 4)
- OpenCode support is much deeper: OpenCode startup, model discovery, command discovery, server connection options, and experimental WebSocket mode now flow through the same settings and runtime paths as the rest of Synara.
- Slash commands respect your OpenCode setup: Composer slash-command discovery now uses the configured OpenCode binary, server URL, password state, and WebSocket mode, so command lists match the runtime you actually selected.
- Desktop updates are harder to get stuck: The updater now caches GitHub release metadata, preserves actionable update state across transient failures, detects stalled downloads, and clears stale same-version update payloads more deliberately.
- The chat surface feels tighter: Composer padding, button spacing, picker sizing, panel headers, banners, dock surfaces, and chat chrome were tuned so the main workspace reads cleaner without losing controls.
- Desktop chrome fits the OS better: macOS traffic-light spacing, sidebar seams, Electron card borders, motion, and titlebar controls were refined so the app frame feels more native on desktop.
- Large chats do less unnecessary work: Markdown parsing is deferred more carefully, pending-interaction state is derived in one place, and transcript/session rendering avoids extra churn during busy or long-running chats.
- Settings back navigation lands in the right place: The Settings sidebar back button now restores the last valid chat route, falls back to the newest live thread when needed, and drops stale split-view routes before navigating.
- Chats and Workspace can be hidden: New sidebar section toggles let you hide the standalone Chats footer list or the Workspace tab while keeping Threads always available.
- Imported legacy databases recover missing columns: Fresh repair migrations reconcile older imported migration trackers that skipped Synara's sidechat-source or pinned-thread columns, preventing startup crashes in those upgraded histories.
- OpenCode looks better in dark mode: The OpenCode provider icon now switches to a clearer reversed asset in dark mode, with sidebar and provider picker styling adjusted around it.
- Settings are easier to scan: Repeated boolean settings were consolidated into a shared row pattern, provider install rows got cleaner reset behavior, and OpenCode-specific controls sit with the rest of provider tools.

### Synara 0.1.0 (Jun 3)
- Synara is now the default home: The app now starts from `~/.synara`, carries the Synara environment variables through the desktop and server runtime, and safely imports existing `~/.dpcode` or `~/.t3` data on first launch.
- Desktop startup feels more native: Windows now hydrates the desktop environment from the registry so provider CLIs are found reliably, macOS keeps Liquid Glass styling only where it belongs, and older Macs get a rounded dock icon without breaking Tahoe.
- Right dock and saved UI state are sturdier: Recovered browser, dock, sidechat, split-view, and panel state is now validated before use, preventing stale or corrupted localStorage from crashing the workspace.
- Composer pickers are cleaner: The traits picker and shared menu styling were refreshed with a tighter layout, clearer selection states, and a calmer feel across model and composer controls.
- Provider runtime noise is reduced: Claude thinking-token telemetry no longer floods the timeline, provider task warnings are deduplicated more carefully, and Codex home overlays avoid stale SQLite sidecar files during startup.
- Small workflow details got sharper: Context meter labels, edit actions, completion separators, Git controls, diff routing, desktop update retry state, and shortcut handling all picked up focused fixes for smoother day-to-day sessions.

### Synara 0.0.50 (May 28)
- Claude Opus 4.8 is available: Synara now includes Claude Opus 4.8 in the Claude model picker.

### Synara 0.0.49 (May 23)
- Grok Build models stay current: Grok model discovery now combines the CLI with xAI language-model metadata, including API aliases, so Grok Build and code-fast variants appear in the picker without waiting for another manual app update.
- Provider choices wait for real readiness: The provider picker no longer treats unknown provider status as usable. Providers stay in a checking state until Synara has confirmed that the local runtime is available and authenticated.
- Desktop shutdown is calmer: The desktop backend now shuts down more deliberately on quit, reducing noisy restarts and preserving a cleaner thread sync path when the app is closing.
- Large histories sync with less work: Snapshot queries, checkpoint reads, and transcript updates picked up more focused data paths, keeping busy workspaces lighter when sessions reconnect or histories grow.
- Diffs and transcripts feel steadier: Whitespace diff controls, thread title updates, copy metadata, and live transcript rows received targeted fixes so common review and resume flows update more predictably.

### Synara 0.0.48 (May 21)
- Grok joins Synara: Pick Grok as a first-class coding provider with ACP-backed sessions, model selection, approval handling, resume support, provider health checks, settings, icons, and handoff wired through the same app surfaces as the rest of your agents.
- Provider fallbacks and desktop menus behave better: Provider startup and recovery paths are more forgiving when preferred runtimes are unavailable, and desktop menu shortcuts now line up more reliably with the active workspace.
- Large histories stay lighter: Snapshot hydration, diagnostics, and capped history paths now do less unnecessary work, reducing memory pressure when busy sessions or large workspaces reconnect.
- Pi and OpenCode edge cases are smoother: Pi aborts now read as interruptions, thinking levels are clamped more safely, live sidebar updates are steadier, and OpenCode/provider update handling picked up targeted reliability fixes.
- Answers survive the RPC hop: User-input answers are preserved through the JSON-RPC codec, which keeps pending provider questions from losing their payload as they move between the app and server.

### Synara 0.0.47 (May 15)
- Pi gets a much sturdier seat at the table: Pi provider sessions now benefit from tighter lifecycle handling, clearer extension-limit warnings, and provider probes that respect the binaries configured in settings.
- Providers can keep themselves fresher: Provider auto-update plumbing landed across the app, making it easier to keep agent runtimes current without turning setup and maintenance into a separate chore.
- Create PR only appears when it can actually work: Create-PR actions now check upstream branch and availability state more carefully, so the UI is quieter until the repository is ready for a real pull request.
- Pending questions stop advancing at the wrong time: Pending user-input auto-advance now cancels on question changes and in-flight responses, reducing stale answers and empty submissions in interrupted provider flows.
- Git status and provider transcripts read cleaner: Git status refreshes, pull-error messaging, Kilo/OpenCode transcript handling, repo diff scopes, and provider install docs links all picked up focused reliability polish.

### Synara 0.0.46 (May 13)
- Image attachments stay visible after sending: Persisted image previews now load through the same reliable byte-serving path as local generated images, fixing the brief preview flash followed by broken attachment thumbnails.
- Kilo Code joins the provider lineup: Synara can now launch and monitor Kilo Code sessions alongside Codex, Claude, Cursor, OpenCode, and Gemini, with health checks, settings, mentions, handoff, and model compatibility wired through the app.
- Provider order is now yours to arrange: The settings screen now lets you drag providers into the order that fits your workflow, and the composer, sidebar, search palette, and plugin surfaces follow the same custom ordering.
- Cleaner OpenCode and Kilo transcript updates: Synthetic snapshot progress is filtered more carefully, so restored or refreshed provider output avoids repeating internal progress text while keeping real assistant activity intact.
- Diff totals are easier to trust at a glance: The chat header now owns unified diff totals, keeping added and removed line counts consistent between the header and diff panel as content refreshes.

### Synara 0.0.45 (May 12)
- OpenCode sessions understand the latest event stream: Synara now tracks the newer OpenCode SDK session events, keeps titles fresher, and has much deeper coverage around OpenCode startup, output, and recovery flows.
- Interrupted turns recover more predictably: Ready and idle transitions now clear or restore turn state more carefully, reducing stuck busy states after reconnects, restarts, and partial provider streams.
- Cursor model choices follow live ACP metadata: Cursor model selection now normalizes against the provider's current ACP options instead of relying on stale context traits, so the composer better matches what Cursor can actually run.
- Diff and pinned-thread state stay in sync: Projection, sidebar, and store updates now carry pinned-thread metadata through the app, while the diff panel handles refreshed content with fewer display glitches.
- Small workflow polish for Git and keybindings: Git summaries are clearer for rename-like moves into untracked folders, and routine keybinding reloads no longer pop a success toast every time they quietly refresh.

### Synara 0.0.44 (May 10)
- Codex image generation now renders in chat: Generated images from Codex are captured as local artifacts, rendered inline in assistant messages, and include expand and download controls without dragging bulky base64 payloads through the transcript.
- Generated images use a safer local route: Synara now serves generated files through a dedicated local-image endpoint with MIME checks, workspace-aware path resolution, and Codex generated_images allowlists for both the normal home and desktop overlay home.
- Provider favorites are quicker to manage: The provider model picker gained native favorite toggles and cleaner context-menu separators, making large Codex, Cursor, and OpenCode model lists easier to shape around the models you actually use.
- Old inactive threads clean up after seven days: A safer retention job now removes stale inactive threads in batches, publishes maintenance progress, protects running work and approvals, and compacts SQLite when enough space can be reclaimed.
- Transport and server edges are steadier: WebSocket HTTP URL helpers, lifecycle events, provider runtime ingestion, and chat-route plumbing were tightened so generated artifacts and cleanup events move through the app more predictably.

### Synara 0.0.43 (May 9)
- Cursor is now a first-class Synara provider: Run Cursor CLI sessions directly from Synara with ACP-backed startup, model discovery, existing-chat resume, handoff, and provider health checks alongside Codex and OpenCode.
- New Effect TS ACP runtime: The new Effect TS ACP package owns generated schemas, JSON-RPC transport, client and agent helpers, terminal release handling, and protocol tests so provider integrations have a sturdier core.
- The server moved onto Effect RPC: WebSocket routing, auth, readiness, settings, environment, git status, and orchestration flows were rebuilt around Effect services so reconnects and failure paths stay more predictable.
- Cursor output is easier to read and resume: Cursor reasoning, tool progress, usage events, plan updates, composer behavior, and model-selection compatibility now render more consistently across fresh and resumed threads.
- Busy sessions stay calmer: Sidebar project recovery, visible-thread PR lookups, task banner resizing, stale target repair, sidechat split handling, and compact chat controls were tightened for heavier day-to-day use.

### Synara 0.0.41 (May 2)
- Sidechat threads are easier to track: Sidechat source metadata now flows through projections, filters, and snapshots so secondary threads stay easier to separate from the main conversation.
- Desktop startup feels faster: Packaged desktop builds now open the app window before backend readiness finishes, reducing the blank-start feeling while services come online.
- Git gained commit and push: The Git actions menu can now commit current work and push it from Synara, keeping the common release and handoff flow closer to the chat.
- Task controls are clearer: Active task controls were tightened, and approval counts are now separated from user input requests so pending work is easier to read at a glance.

### Synara 0.0.40 (Apr 29)
- Browser-use now drives the visible browser: The desktop browser and browser-use tools now share the same visible webview, so automation, screenshots, navigation, and manual browsing stay in sync instead of racing separate hidden pages.
- The browser panel is steadier: Browser resizing, overlay handling, tab controls, screenshot actions, and browser-use panel requests were tightened while keeping the browser from reopening by default.
- Plans are easier to export: Proposed plans now share one compact action set for copying markdown, saving into a `.plan` workspace folder, or exporting a markdown file through the desktop save dialog.
- Split panes expand predictably: Expanding a chat pane now opens that selected chat as the single full-screen surface, closing the rest of the split layout.
- Git flows are smoother: The Git menu now includes branch creation with Synara-style names, and PR creation can recover from GitHub duplicate-PR responses by reusing the existing open pull request.
- Legacy T3 imports heal themselves: A new migration reconciles older imported T3 Code databases whose migration history skipped Synara schema changes, preventing missing-column crashes after import.
- Idle sessions clean up after themselves: Provider runtimes and Codex discovery sessions now stop after idle periods, while active turns and pending approvals remain protected from premature shutdown.
- Streaming output lands in the right message: Assistant turn ingestion now prefers existing completed item IDs when possible, reducing placeholder duplication and keeping streamed assistant text attached to the intended message.
- Small workflow polish landed: Diff views can copy the full patch directly, terminal-started chats get a clearer header icon, sidebar titles truncate more cleanly, and long transcripts cap normalized messages for lighter rendering.

### Synara 0.0.39 (Apr 28)
- Split chats are easier to arrange: Split chat panes now support direct drag-and-drop, cross-project drops, and safer orphan handling so multi-chat layouts stay easier to build and recover.
- Split chat navigation is steadier: Split chat activation, route restore, sidebar grouping, and thread subscriptions were tightened so opening and switching chats feels more predictable.
- OpenCode tasks show live progress: OpenCode todo events now flow into Synara as active task updates, with a compact banner option for keeping current work visible without taking over the chat.
- OpenCode models can be favourited: The model picker now supports OpenCode favourites, making preferred models quicker to find across larger provider model lists.
- OpenCode context usage is tracked: OpenCode sessions now report context usage more consistently, giving Synara better runtime visibility as conversations grow.
- Debug controls stay out of production: Debug feature flags are now hidden behind local opt-in behavior, keeping production sidebars cleaner while preserving developer-only controls.

### Synara 0.0.38 (Apr 26)
- Cursor CLI support landed: Cursor is now available as a provider, with ACP sessions, model discovery, existing chats, handoff, shortcuts, and git text generation wired into Synara.
- Voice transcription is scoped more carefully: Voice transcription now stays on ChatGPT sessions, avoiding confusing provider mismatches while keeping dictation available where it is supported.
- Voice transcription setup is smoother: Voice transcription setup was tightened so spoken prompts can flow into the composer more reliably in supported ChatGPT sessions.
- Mentions keep their names: Composer replacements now preserve mention labels, so referenced files, apps, and tools remain readable after the prompt text is normalized.
- Plugin mentions are handled in prompts: Plugin references can now flow through composer prompts cleanly, making connected-tool context less brittle when you hand work to an agent.
- Toast behavior can be feature-flagged: Toast notifications picked up feature-flag wiring, giving Synara a safer way to roll notification changes forward or back.
- Desktop reconnects are steadier: The desktop bridge now refreshes reconnects more reliably and preserves the workspace home directory, reducing drift after desktop runtime restarts.

### Synara 0.0.37 (Apr 25)
- Branch switching is much safer: Synara now handles messy branch switches with clearer recovery actions, recreated stashes, unpublished branch publishing, and stronger checks around conflicts and local work.
- Plan mode proposals show up properly: Proposed plans from providers are now parsed and surfaced as first-class UI state, so planning turns feel more predictable instead of blending into ordinary assistant output.
- Desktop navigation controls landed: The desktop app now has app-level back and forward navigation controls, making it easier to move around Synara without losing your place.
- Sidebar ordering stays put: Stored sidebar sort preferences are preserved on load, fixing cases where project and thread ordering could unexpectedly reset.
- Fonts are more consistent: Theme and chat font handling now share one normalization path, tightening up typography across the chat UI, model controls, and theme settings.

### Synara 0.0.36 (Apr 24)
- GPT-5.5 is available: GPT-5.5 is now in the model picker with the right default reasoning behavior, so you can move new Codex sessions onto the latest model directly from Synara.
- OpenCode support is here: OpenCode is now available as a provider, with runtime model discovery, session handling, provider settings, model search, variants, agents, and git text generation wired into the app.
- Model search feels faster: Large OpenCode model lists now get provider-aware search, clearer labels, automatic search focus, arrow-key navigation, and tighter picker clipping.
- Diffs now start from the turn: Turn diffs use turn-start checkpoints, making changed-file views line up more closely with what the agent actually changed in the current turn.
- Chat markdown is smarter: Math rendering was added to chat markdown, while literal dollar amounts stay intact so normal prices and currency snippets do not get misread as formulas.
- More polish around search and releases: Sidebar theme search, release verification, Windows signing config, and a handful of provider/model edge cases were tightened up for a smoother build and update path.

### Synara 0.0.35 (Apr 22)
- 🗂️ Project import browsing got smarter: The import palette can now browse nearby paths more directly, helping you find and open the right project location with less guesswork.
- 📊 Provider usage is visible in-context: The branch toolbar now surfaces provider usage snapshots, making it easier to keep an eye on current usage without leaving your working view.
- 🚀 Desktop startup feels clearer: Synara now shows a proper splash screen while the desktop backend spins up, so launch feels intentional instead of looking briefly stalled.
- 🎛️ Better provider and theme polish: Model capability handling, theme editing, and related picker behavior were tightened up so settings feel more consistent and trustworthy.
- 🛠️ Desktop release plumbing is sturdier: Startup readiness checks, desktop packaging config, and platform entitlements were refined to make desktop builds and app boot more reliable.

### Synara 0.0.34 (Apr 21)
- 🎨 Theme packs are editable: The new theme pack editor lets you tune UI colors directly in Synara, with shared theme tokens keeping the sidebar, composer, transcript, and controls in sync.
- 🔔 Sidebar notifications are easier to read: Thread activity now surfaces more clearly in the sidebar, so updates, background work, and attention states are easier to spot without opening every conversation.
- 🧵 Steadier transcripts under load: Transcript rendering and sidebar-owned state were separated more cleanly, reducing unnecessary churn while long conversations and live agent output are moving.
- 🛡️ Safer runtime-mode recovery: Codex runtime permissions now propagate more reliably across resumed sessions and provider restarts, keeping the app closer to the mode you actually selected.
- ✨ Cleaner composer and picker styling: Composer chrome, picker hover states, runtime controls, and changed-file rows picked up a more consistent visual pass across light and dark themes.

### Synara 0.0.33 (Apr 20)
- 📂 Browse local folders right from the composer: Folder mentions now open a real local directory picker, so you can drill into nearby files and attach the right path without leaving the chat flow.
- 🗂️ Cleaner file and folder mentions: Mention chips, file trees, and changed-file rows now use a lighter shared icon system that keeps paths easier to scan across the app.
- 🌐 Stronger desktop browser runtime: The desktop browser path picked up better IPC plumbing, screenshots, clipboard support, and more efficient state syncing for browser-driven tasks.
- 🛟 Smoother startup and provider recovery: Project hydration, desktop startup, auth visibility, and aborted-turn cleanup were tightened up so sessions recover more predictably after interruptions.

### Synara 0.0.32 (Apr 19)
- ↪︎ Steering messages are clearly marked: Messages sent with steering now keep a lightweight 'Steering conversation' label above the bubble, even after the app reconciles with the server.
- 🚦 Less aggressive background return checks: Desktop update checks now wait for a real background return instead of reacting to every tiny blur/focus bounce.
- 🛟 No more stuck checking state: If the updater never answers, Synara now times out and recovers instead of hanging on a permanent Checking status.

### Synara 0.0.31 (Apr 19)
- ♊ Gemini support is here: Use Gemini alongside Codex and Claude Agent, with provider-aware models and handoff support built into the app.
- 🛠️ Custom binary paths for every provider: Point Synara at your own Codex, Claude, or Gemini binary when your setup lives outside the default install path.
- 📎 Reuse assistant replies as attachments: Select parts of an assistant response and send them back as structured context in your next prompt.
- 🧵 Better thread continuity: The app now remembers your last open thread, carries pull request context into draft threads, and keeps sidebar state more stable.
- 🩹 Smoother recovery and update checks: Project creation recovery, foreground update checks, and a few rough edges around long messages and download state have been tightened up.

### Synara 0.0.30 (Apr 18)
- 💬 Chats are now available!: Write without a selected project, or create threads from there.
- ⌨️ New shortcuts: Quickly open a new chat or jump to your latest project thread with dedicated shortcuts.
- 🧠 Claude 1M context support: Take full advantage of Claude's 1M-token context window for long conversations and large codebases.
- 📁 Bulk thread actions: Select multiple threads at once and act on them together.
- ✨ Cleaner reasoning picker order: The reasoning picker has been reordered to make the most common choices quicker to reach.
- 💻 New polished UI/UX: A round of visual and interaction polish across the app.

### Synara 0.0.29 (Apr 18)
- 🆕 What's new, inline: Every update now opens a one-time dialog highlighting the latest changes, so you don't have to hunt through a changelog to know what shipped. The dialog only shows up once per release — dismiss it and it stays out of your way until the next version.
- 📚 Release history in Settings: A full changelog lives under Settings → Release history, grouped by version in a collapsible accordion. Revisit any past release at any time. The same notes as the post-update dialog, nothing to hunt for.