What's new in Synara.

Synara 0.3.0

• Automations are a real workspace surface — Synara now has first-class Automations for scheduled agent work, with sidebar navigation, list/detail pages, run history, triage actions, and inline editing.

  This release wires automation contracts, persistence, scheduler leases, run tracking, RPC methods, sidebar badges, Current/Paused views, detail routes, editable fields, previous-run history, and result triage so scheduled work lives inside the same thread/provider/worktree pipeline as normal chat work.

• Heartbeat automations can stop when the goal is met — Heartbeat automations can store an AI-evaluated stop clause, evaluate it after successful runs, and disable themselves with a recorded reason when the condition is satisfied.

  Completion policies now support natural-language stop conditions, dedicated background evaluation, visible completion results, timeout handling, stale-result guards, legacy-row defaults, and archive/read preservation so a stop check cannot silently undo user triage state.

• Automation creation understands natural prompts — The composer can turn automation-style prompts into scheduled drafts, including intervals, daily/weekly timing, cron-like schedules, heartbeat targets, and review dialogs.

  Automation intent parsing now covers explicit and generated prompts, English and Italian stop/schedule phrasing, bounded fast-loop safety, draft review, source-thread handling, restored plan source metadata, inline editing from composer text, and stricter confirmation for LLM-generated automations.

• Scheduled runs are harder to lose or corrupt — Automation scheduling, recovery, and run reconciliation were hardened so crashes, duplicate wakes, approval waits, stale cache updates, and cleanup failures are handled more predictably.

  The automation service now has occurrence dedupe, scheduler leases, crash replay, failed-run rollback, startup recovery, bounded completion-evaluation queues, recovery/lease observability, approval ownership re-checks, standalone worktree cleanup, equal-timestamp cache merging, and DST/long-downtime schedule coverage.

• Files attach, preview, and download more reliably — Chat now supports generic file attachments alongside images, with better chips/cards, safer upload normalization, worktree-aware previews, and in-app local image downloads.

  File attachments now flow through contracts, upload storage, composer paste/drop, provider prompts, Kanban dispatch, recap/bootstrap surfaces, optimistic timeline rendering, caps/rollback, attachment-bearing plan follow-ups, explicit unsupported-file rejection, worktree-backed file preview roots, and blob-based download handling that keeps failed local image downloads inside Synara.

• Providers and models stay scoped to the right project — OpenCode and Claude startup paths are more careful about cwd, model discovery, config scope, and sticky plan mode so new threads inherit less accidental state.

  OpenCode model discovery can fall back to opencode models --verbose, managed OpenCode/Kilo paths run in the request/session cwd, warm server reuse is scoped, file config is no longer replaced with synthetic empty config, OpenCode resume preserves cwd, and fresh Claude threads avoid inheriting plan mode from the previous active thread.

• Chats and side panels stay in sync — Deleted chats disappear immediately, the Environment panel behaves better in constrained layouts, automation cards show up in the transcript, and file previews avoid extra full-thread subscriptions.

  Client projections now use delete tombstones and responsive archived bulk-delete updates, environment-panel open/close preferences survive chat switches, constrained/floating layouts stay calmer by default, thread automation summaries appear in the environment panel, created automation cards render in chat, and file preview routing avoids unnecessary full thread subscriptions.

• Profile skill counts reflect more real work — Profile stats now count repeated /skill and $skill usage more accurately, including retained history that should still contribute to your local activity picture.

  Skill aggregation now includes retention-hidden threads while still excluding manually deleted data, counts repeated slash/dollar skill tokens inside one prompt, avoids double-counting structured references, and has regression coverage for retained threads and repeated skill invocation.

Synara 0.2.41

• Hand off chats from the header again — The chat header now has a compact Hand off menu, so you can start a provider handoff without hunting through the rest of the workspace.

  The header handoff action now offers only usable target providers, checks provider availability before creating the handoff thread, and keeps the action disabled while the current thread is busy or waiting on approvals/input.

• Project scripts stay out of the way — Project action dialogs remain available, but the old inline script runner no longer crowds the chat header controls.

  Project script controls stay mounted for the shared Open-in/project-action dialog path, while the visible header play/chevron runner is hidden to keep the top bar focused.

Synara 0.2.4

• Restarts bring you back to the right chat — Synara now waits for one fresh server snapshot before giving up on a remembered chat route, so app restarts are less likely to dump you onto an empty fallback screen.

  Chat route restore now validates remembered thread/split routes against refreshed orchestration state, holds fallback while startup data is still empty, and has focused coverage for missing-thread and empty-startup recovery paths.

• Disabled providers recover more predictably — Provider health refreshes now have regression coverage around re-enabling disabled providers, making settings changes less likely to leave stale unavailable states behind.

  Provider health and Pi adapter paths were tightened with coverage for disabled-provider re-enable behavior, while provider badges and menu icons were kept aligned with the refreshed availability state.

• The chat header is quieter — The old handoff shortcut has been removed from the chat header, leaving the main conversation controls easier to scan during active work.

  The chat header no longer renders the handoff action path, reducing duplicate top-bar controls and keeping project/thread actions focused on the surfaces that still own them.

Synara 0.2.3

• Your profile understands more of your work — Synara now tracks richer local profile stats, including your most worked project, skill and agent usage, active hours, provider/model mix, and prompt activity.

  Profile stats now derive more signal from Synara's local projection database: most-worked project, prompt/thread activity, skill and agent usage, provider/model usage, reasoning patterns, active-hour windows, and token heatmap data are all represented in the profile contract and settings panel.

• Large pastes become cleaner composer cards — Big pasted blocks now collapse into tidy attachment-style cards, keeping the composer readable while still letting you restore or remove the full text.

  Large pasted text blocks are serialized separately from the visible prompt, shown as compact cards in the composer, expandable in sent messages, and counted with line/character metadata so long prompts are easier to review.

• Pasted text survives message edits — Editing a message now preserves pasted text blocks instead of dropping or flattening them, so larger prompts stay intact when you refine them.

  The composer draft, edit, assistant-selection, terminal-context, and WebSocket send paths now preserve structured pasted text blocks instead of folding them into fragile plain text. Focused tests cover pasted text, draft persistence, terminal context, timeline height, and edit behavior.

Synara 0.2.2

• 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

• 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

• 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

• 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

• 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

• 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

• 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

• 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

• 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

• 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

• 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

• 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

• 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

Synara 0.0.49

• 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

• 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

• 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

• 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

• 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

• 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

• 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

• 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

• 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

• 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

• 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

• 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

• 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

• 🗂️ 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

• 🎨 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

• 📂 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

• ↪︎ 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

• ♊ 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

• 💬 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

• 🆕 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.