v0.1.5

Tempest v0.1.5

The Isolation release. An agent you have to supervise line by line is not saving you much. This release is about the boundaries that let you stop watching: its own database, its own sandbox, its own quotas — and a config file the repo carries so those boundaries travel with the code.

What's in this release

Database Branches

Each agent session can get its own isolated clone of your Postgres. Migrations, seed data, and schema changes happen in the branch — the shared database is never touched.

A new dbiso crate (built on bollard) snapshots your Postgres into a base Docker image, then cuts a fresh branch container per session and injects DATABASE_URL, PGHOST, and PGPORT into the PTY environment. The agent connects to its clone without knowing anything changed.

Strategy	What it captures
pgdump	Full logical dump — Supabase-compatible
basebackup	Physical base backup
schema-only	Structure without rows

Base images are named per project, so multiple projects can hold snapshots side by side. The whole subsystem is a silent no-op when Docker is unavailable or no base image exists — nothing breaks, sessions just open against your real database as before.

Isolation is toggled per project in Project Settings → Database, not globally. Different projects, different risk.

Project Settings — Now Enforced

The Project Settings panel previously only had teeth for database isolation. Every other section was decorative: sessions spawned against a hardcoded allow-list regardless of what the panel said. Now every session reads the project's settings blob.

Section	Governs
Sandbox	Off / Monitor / Enforce posture for the session
Network	Permissive or restrictive policy, allow-list and block-list of hosts
Filesystem	Read & Write and Read Only path lists
Permissions	Whether the skip-permissions bypass may be used
Resources	Memory, process count, disk write, and CPU weight quotas
Agents	Which agent types may launch in this project
Database	Per-session isolated database branch

Plain terminals are governed identically to agents. A shell reaches the network either way, so treating it as trusted was a hole rather than a convenience.

Launch policy checked in Rust. Non-permitted agents and blocked skip-permission flags are refused before the PTY opens, with the reason surfaced in the UI. Filtering the new-session menu is presentation; the refusal is the enforcement.

Sandbox fixes underneath. The host matcher was replaced with one where a block-list beats an allow-list, hosts are normalized for ports and IPv6 brackets, and suffix impersonation is fixed — evil.com no longer matches an allow of api.anthropic.com merely by ending with it. Windows now starts the CONNECT proxy, injects http_proxy/NO_PROXY, and maps CPU weight onto Job Object rate control. Proxy denials return 403 with the blocked host echoed instead of 407, which had been making curl prompt for proxy credentials.

tempest.yml — Config That Ships With The Repo

A project can now commit a tempest.yml at its root, and the conventions travel with the code:

instructions: |
  This service talks to Stripe. Never write to the live keys.

preview:
  port: 5173

env:
  RAILS_ENV: development

sandbox:
  mode: enforce
network:
  policy: restrictive
  allowHosts: ["api.anthropic.com"]

• instructions becomes the Chat system prompt for the project — the file wins over whatever this machine had saved.
• preview.port opens Live Preview straight at your dev server instead of the port picker.
• env is injected into every agent session's environment.
• Security fields merge over your panel settings.

The file may only tighten. A checked-in config arrives with code you may not have written, so security fields merge in the tightening direction only: a stricter sandbox mode wins, block-lists union, allow-lists intersect, quotas take the lower value, and the skip-permissions bypass can be revoked but never granted. A repo can lock itself down further than your panel allows. It can never loosen it.

env cannot become code execution. Loader variables (PATH, NODE_OPTIONS, LD_PRELOAD, DYLD_INSERT_LIBRARIES, PYTHONSTARTUP, BASH_ENV, and the rest) are stripped, as are the DB-isolation variables — a repo must not be able to point an isolated session at some other database. Rejected keys are reported in the console rather than silently dropped.

The clamp is applied for display and enforcement but never persisted, so editing or deleting the file takes effect on the next session with nothing stuck in your settings.

A malformed tempest.yml degrades to "no config" plus a warning. A typo must not stop a terminal from opening.

SQLite Persistence

All persistence moved from runtime-state.json and localStorage to a single SQLite database (tempest.db).

Sessions gained real UUID identity with project, branch, and parent foreign keys, replacing the composite path-string keys that had been standing in for identity. Projects, branches, sessions, recents, tabs, and chat history now live in relational tables; app-global preferences live in an app_state key/value table. Each store keeps a synchronous in-memory mirror hydrated at startup with async write-through, so reads stay instant.

BYOK API keys and the GitHub PR token deliberately stay in localStorage — credentials belong in an OS keychain, not in an application database, and that is the next move for them.

Right Sidebar — Bottom Panel

A tabbed panel now sits at the bottom of the right sidebar.

Tab	What
DB Clones	Live view of the database branches for this project
Run	Detected package.json scripts plus custom commands saved per project
Terminal	Streams output from whatever the Run tab started, with a stop button

Scripts are read from the project's package.json automatically. Custom commands are stored per project, so the ones you actually use are one click away in the project that uses them.

In-App Updates

Releases have been signing update artifacts and publishing latest.json since the release workflow landed — but no client ever read them. The updater is now wired up: Tempest checks on startup and once every 24 hours.

The notice takes whichever surface is already there:

• On Overview, where there is no footer, one drops in over 550 ms carrying the line on the left, Update and dismiss on the right. ✕ retracts it and the canvas glides down into the space.
• Inside a session, the status bar becomes a one-row viewport over a two-row track and rotates the update line in alongside Indexed and Isolated every 7 s. Nothing is displaced, and the bar never changes height.

Two targets, deliberately. The sentence opens the release notes; only the word Update starts the upgrade. From a workspace, that word opens a confirmation naming the sessions that will close and warning separately about agents mid-turn — those turns are the only work that cannot be resumed afterwards. Overview installs directly, since nothing is running there to interrupt. Dismissing hides the notice until the next 24-hour check.

Performance — The UI Freezes Are Gone

Tauri v2 runs a plain #[tauri::command] fn on the main event loop; only async fn gets a worker thread. 68 of 80 commands were synchronous, so every git subprocess, SQLite query, and directory scan froze the UI for its full duration.

Worst offenders, both now fixed:

• Branch deletion hang — git_delete_branch with deleteRemote runs git push origin --delete, putting a network round-trip on the UI thread. An unbounded freeze whenever auth was slow.
• Workspace delete — close_and_remove_worktree kills the PTY, waits in a 40×25 ms loop, then retries worktree removal 6 times with 500 ms sleeps: roughly 4 seconds of deliberate main-thread sleeping per delete.

The 68 blocking commands are now marked (async). Attribute-only — no command logic changed.

Startup got three cuts as well: project .tempest/ scanning moved from a sequential await loop to one Promise.all; db_load ran three separate times with chat serialized behind the rest and now shares one in-flight snapshot across all six stores; and applyTheme moved from a passive useEffect (after first paint) to useLayoutEffect.

The Diff pane's "all files" view renders every hunk of every changed file — content-visibility: auto now lets off-screen blocks skip layout and paint entirely.

Global MCP Configs

Agents that read MCP servers from a global config file can now be wired to Atlas in one click, from Settings → Token Intelligence:

Agent	Writes to
Goose	~/.config/goose/profiles.yaml
Codex CLI	~/.codex/config.toml

Each row checks whether the config is already present and shows its state, so a second click is never needed.

Fixes and Polish

Tooltip stacking — tooltips moved to a portal with viewport clamping, so they no longer get trapped under adjacent stacking contexts or clipped at window edges.

New-session menu clipping — the menu now clamps horizontally and flips above its anchor when there is no room below; the nine-agent submenu scrolls within whatever space it has.

Themes renamed — the origin-dark and origin-light theme folders are now tempest-dark and tempest-light. Documentation updated to match.

Global settings — the Database tab is gone (isolation is per project now), the modal is wider at 800×580, and the About section shows the correct version.

Filesystem "Always Denied" list removed — with the allow-lists exhaustive under Enforce, a separate deny-list was...

v0.1.4

Tempest v0.1.4

The Orchestration release. Running a fleet of agents is one thing. Knowing which ones need you — and getting there in two keystrokes — is another. This release aims to close that gap.

What's in this release

Command Palette (Ctrl+Shift+P)

Press Ctrl+Shift+P from anywhere in the app to open a searchable command hub. Type a few characters to filter 13 commands across four sections:

Section	Commands
Navigation	Next Tab, Previous Tab
Layout	Toggle Left Sidebar, Toggle Right Sidebar, Split Side by Side, Split Top/Bottom
Workspaces	Open Project, New Workspace, Close Tab, Broadcast to Agents, Open Message Queue
Appearance	Open Settings, Switch Theme

Arrow keys navigate, Enter runs, Escape dismisses. Each command shows its keyboard shortcut inline. The palette is registered in the keybindings store automatically, so it appears in Settings → Keyboard and is rebindable like any other action.

Sidebar Orchestration

The sidebar now reflects what every session is doing, even when you are not looking at it.

Activity rollup — each project header shows the highest-priority state across all of its sessions: spinner while any session is working, green dot when everything is done, orange dot when any session needs attention. This is visible even when the project is collapsed.

Attention signals — a new attention state sits above done in the priority hierarchy. Two signals transition a session to it: the OSC 1337 RequestAttention sequence (Claude Code's "I'm blocked" signal, emitted when it needs a permission granted) and Gemini CLI's ✋ terminal title. Either produces an orange dot on the session tab, the sidebar badge, and the project header immediately — no tab focus required.

Attention Pill — an orange bell and count appear in the right end of the toolbar whenever any session is waiting. Clicking it triggers the same jump as Ctrl+Shift+A.

Jump to waiting (Ctrl+Shift+A) — a new keybinding that filters sessions with attention or done state, sorts attention-first, finds the next one after the current tab, and wraps around. One keystroke to reach whatever needs you without breaking flow.

Inline quick-create — click + on a project header to expand an autofocus input at the bottom of the session list. Press Enter and a new Claude Code root session opens immediately with that task. Right-click + still opens the full session menu for other agent types and options.

Drag-to-reorder — project groups and individual worktrees within a project are both draggable. A blue border shows the drop target. Order persists across app restarts.

Claude Permission Dialog — Reliability Fix

Claude Code's permission dialog was previously only detected reliably when the tab was focused. Two underlying issues:

1. Regex mismatch — the \b word-boundary anchors failed when Claude Code's PTY rendered the dialog cell-by-cell, compressing whitespace to "1. Yes2.Yes,allow…" with no boundary between option text and the next digit. Fixed with a negative-lookbehind (?<!\d) that matches the compressed form while rejecting digit-prefixed numbers like 31.

2. Split PTY reads — the fingerprint could arrive split across two PTY chunks, neither of which matched alone. Fixed with a 4 KB rolling window that reassembles the tail across reads.

Additionally, markDone() now spawns deferred rechecks at 3 s, 8 s, and 20 s, scanning the session buffer each time. Late-arriving permission dialogs upgrade the green dot to an orange bell without requiring tab focus.

First-Run Onboarding

New installs open a four-page onboarding flow before the main app:

Page	What
Welcome	Tempest wordmark, "The Agentic IDE" tagline, landing screenshot (dark/light adaptive), Get Started
BYOK	Provider grid, API key entry with show/hide toggle, custom model selector — keys stay on-device and power the Chat tab
Agents	All supported CLI agents with ready/missing badges and one-click install links — informational only, no selection required
Configure	Token Intelligence, Agent Isolation, Bypass Permissions, and Co-author toggles with defaults pre-set

onboardingComplete is written to runtime-state.json — survives localStorage clears and WebView resets.

Settings — API Keys

A new API Keys section in Settings manages all nine BYOK provider keys in one place.

Each provider row has three states: no key set (Add key button), key set (masked sk-••••••••3f9a display with show/hide, edit, and delete), and editing (full-width monospace input with Save/Cancel). A brief checkmark flashes on save. Ollama shows a "Local · no key needed" badge instead of an input.

Inline Code Review

The Diff pane now supports inline comments that you can send directly to an agent.

Per-line comments — hover any diff line to reveal a + button. Click to open an inline form below the line. Ctrl+Enter or the Comment button saves. Escape cancels.

Multi-line range — shift-click a second line to extend the selection. All selected rows get an indigo wash and a 3 px continuous bar segment. One square + button appears at the center of the range.

Comment on hunk — a button in the hunk header selects the full hunk as a comment range in one click.

Delivery — the Review Comments Bar appears at the bottom of the pane when pending comments exist. Pick a live agent session and click Send. Comments are written directly to the agent's PTY via write_to_pty — the same path as typing in the terminal — so the agent receives them immediately, not on its next idle cycle.

Comments persist across file switches within a session, scoped by working directory.

MSI Installer + Atlas on npm

Two infrastructure improvements that simplify setup:

MSI installer — Windows users can now install Tempest as a native .msi package alongside the existing NSIS .exe.

Atlas on npm — @usetempest/atlas is now published as an external npm package. A postinstall script stages it from node_modules/ into the Tauri resources directory automatically on every npm install. No manual build, copy, or bundle commands needed — npm install is the only setup step.

UI Polish

A focused round of targeted fixes across the interface:

Prompt picker — moved to a createPortal / position: fixed dropdown anchored by getBoundingClientRect. The toolbar's overflow: hidden no longer clips it. Copy button uses inverted colors with a label-only "Copied" state (no color change). Manage Prompts button changed to ghost style.

Agent tab group chips — hardcoded color: #fff replaced with var(--tempest-bg-base) so chips read correctly in both themes. A close-all × button (12 px, strokeWidth 2.2, matching the tab close button) fades in on hover with a gradient mask on the project name.

Diff comment cards — all hardcoded hex values replaced with --tempest-* CSS variables. Comment text uses var(--tempest-bg-base) for legibility on the yellow background in both themes. Left border accent removed. Hunk header buttons no longer stretch to match wrapped hunk range text (align-items: flex-start).

Tooltips — background changed to --tempest-fg-default, text to --tempest-bg-base, arrow updated to match — crisp inverted chip in both light and dark themes.

Settings keyboard nav — clicking the keyboard shortcut icon was opening Settings on the "appearance" tab instead of "keyboard". Fixed.

Changes tab (Right Sidebar) — +N -N line count badges on each changed file. Expandable inline diffs per file with a loading spinner and diff cache. Wrap Lines and Expand/Collapse All toolbar above the list. Stage All / Unstage All show a spinning loader and disable the button while running.

Codex CLI and Antigravity — added to the agent registry with proper SVG icons. All nine agents sorted alphabetically.

Platform Support

Platform	Status
Windows 11 (x64)	Supported. Pre-built binary available. MSI and NSIS installers.
macOS	Supported
Linux	Supported

Windows requires WebView2 (bundled automatically when necessary).

What's next

• Database branches: each agent gets its own isolated clone of your production database — run migrations, seed data, and make schema changes without touching the shared database
• Per-agent configuration: flags, environment variables, working directory set once and applied to every session for that agent type

v0.1.3

Tempest v0.1.3

The Chat release. Agents are for building. Chat is for thinking. This release ships the missing half — and this is only the beginning of it.

Why Chat alongside agents

Agent sessions in Tempest are execution tools. You give one a task, it writes code, you review the diff. That workflow is fast when you already know what to build.

But most engineering work starts before that — understanding a system, researching an approach, debugging a failure, reviewing a design, making a decision. That work does not belong in a terminal. It belongs in a conversation.

Chat is your personal engineering companion inside Tempest. It has full access to your codebase through Atlas, can read files and git history, and understands your project the way a senior engineer would. When a conversation reaches the point where implementation is needed, Chat can spawn an agent session to handle it — and you stay in the conversation while the agent works in a background tab.

Chat is where you figure something out. Agents are where you get it done. They are not the same surface.

What's in this release

Chat Tab

Open Chat from the + tab picker. It runs a live agentic loop — up to 24 sequential reasoning steps per response, with full tool use at every step. While the AI is thinking, a shimmer indicator shows it is working. Each tool call appears as a collapsible step card with the tool name, arguments, and result inline.

Chat sessions are per-project. Your conversation, tool calls, and any spawned-agent cards all persist across tab close and app restart. Nothing is lost between sessions.

Built-in tools:

• read_file — reads any file in the project
• list_files — lists directory contents
• run_git_log — recent commit history
• run_git_status — current working tree status
• propose_agent_task — spawns a new agent session (see below)
• All atlas_* tools via the Atlas MCP bridge — symbol lookup, callers, callees, cross-file relationships

Atlas MCP Bridge in Chat

Chat connects directly to Atlas via a Rust-side MCP bridge. When you ask about your codebase, the AI queries the live knowledge graph rather than reading files from scratch. Symbol lookups, call chains, and cross-file relationships are answered in milliseconds with zero wasted tokens.

The bridge starts automatically alongside the Chat tab. No configuration required.

Agentic Step Cards

Every tool call the AI makes is shown as a step card in the conversation.

• Status dot: amber pulse while running, hollow ring when complete
• Icon + label: each tool has a distinct icon — file, folder, git, terminal, database for Atlas tools
• Args preview: compact mono one-liner showing what was passed
• Expand / collapse: click any card to see the full result, with smooth height animation
• Fade-in on mount: each card appears with a subtle slide-up as the step starts

Propose Agent Task

When Chat reaches the point where implementation is needed, the AI proposes an agent task. A card appears in the conversation with the agent type, model, task description, and the AI's reasoning. Click Launch — a new agent tab opens in the background, receives the task prompt, and begins working immediately. You stay on the Chat tab.

Model selection is AI-controlled. The chat AI specifies the exact model variant (claude-haiku-4-5-20251001, claude-sonnet-4-6, etc.) and Tempest passes it directly to the agent CLI via --model. The right model for the job is chosen in the conversation, not in a settings menu.

Proposal cards persist after launch. The Launch button becomes disabled and shows "Launched" — you always know what was sent and when. Dismiss cards you don't want to act on. Both states survive tab close and app restart.

The work-done badge on the launched agent tab (spinner → green dot) appears immediately, before the agent produces any output.

@ File Mentions

Type @ in the chat input to open a file picker. Search by name, select a file, and it appears as a chip in the input. When you send, Tempest reads the file and prepends its full contents as context — no need to paste manually or ask the AI to read it. Multiple mentions are supported in the same message.

/ Command Palette

Type / in the chat input to open a command palette. Keyboard-navigable.

Background Agent Start Fix

Agent sessions launched from Chat — or from any background trigger — previously would not start their CLI until you physically clicked the tab. The process was alive but idle, waiting for a terminal resize signal that never came while the tab was hidden.

This is fixed. Tempest now sends resize_pty immediately after spawning the agent, using the current workspace dimensions. The agent CLI starts and begins executing the task the moment it is launched, regardless of which tab is active.

Platform Support

Platform	Status
Windows 11 (x64)	Supported. Pre-built binary available
macOS	Supported
Linux	Supported

Windows requires WebView2 (bundled automatically when necessary).

What's next

• Command palette (Ctrl+K)
• Per-agent configuration: flags, environment variables, working directory — set once and applied to every session for that agent type
• Database branches: each agent gets its own isolated clone of your production database. Agents can run migrations, seed data, and make schema changes freely without ever touching the shared database.

v0.1.2

Tempest v0.1.2

The Token Intelligence release. Agents now get a pre-built semantic code graph injected automatically. No setup required. Plus a completely rewritten work-done detector and a smarter recent projects list.

What's in this release

Token Intelligence

Tempest now ships a built-in code knowledge graph powered by Atlas, a local, offline semantic index of your project.

When Token Intelligence is enabled, Tempest indexes your project's codebase and injects a live MCP server into every agent session. Agents can query the graph to find callers, callees, symbol definitions, and cross-file relationships, without reading entire files from scratch every turn.

The result: fewer wasted tokens, faster responses, and agents that understand your codebase the way a senior engineer would.

How it works:

• Enable Token Intelligence in Settings → Token Intelligence
• On first open of each project, Tempest asks whether to index it
• Indexing runs entirely in the background; a toast in the bottom-right corner tracks progress and disappears when the index is ready
• Once indexed, every agent session in that project gets the Atlas MCP server injected automatically. No configuration needed.

MCP config files are written automatically for:

• Claude Code, Cline, Roo, Zed, Windsurf (.mcp.json)
• Cursor (.cursor/mcp.json)
• Gemini CLI (.gemini/settings.json)
• Kiro / AWS Q (.kiro/settings/mcp.json)
• opencode (opencode.jsonc)

All generated files are gitignored automatically. Re-index any project at any time via right-click on the project header in the sidebar.

Auto-index mode: turn on "Auto-index new projects" to skip the prompt entirely. Every new project is indexed silently on first open.

Atlas indicators appear in the sidebar next to indexed projects and their agent sessions so you can see at a glance which sessions have Token Intelligence active.

The index lives at <project>/.tempest/atlas/ alongside Tempest's other per-project data, excluded from git automatically.

Work-Done Detection: Full Rewrite

The agent work-done detector has been rebuilt from scratch into a 9-layer state machine based on publicly documented terminal standards, plus a new title-based authoritative signal layer for agents that emit terminal titles.

The old 2-layer implementation (OSC 9 + byte-quiet timer) had a latent false-positive bug: \x1b]9;4;3 (ConEmu indeterminate-progress, meaning busy) matched the OSC 9 prefix and incorrectly called done mid-run. Any agent or subprocess emitting a progress update could cause Tempest to signal completion prematurely.

A second false-positive was also fixed: the 5 s byte-quiet timer was arming immediately on Enter, so Claude Code's silent pre-output thinking window (which can exceed 5 s on complex prompts) would fire a spurious done signal before any output appeared.

Detection layers (in priority order):

Layer	Signal	Effect
OSC 0/2 title	Claude Code spinner → ✳ transition	Authoritative done (no timer wait)
OSC 0/2 title	Gemini ✦/✋ → ◇ transition	Authoritative done (no timer wait)
OSC 9	Shell notification (Claude Code turn end)	Immediate done
OSC 9;4;0	ConEmu progress cleared	Done
OSC 9;4;1-4	ConEmu progress busy/error/indeterminate/paused	Busy (was false-positive before)
OSC 133;B/D	FinalTerm prompt ready / command finished	Done
OSC 133;C	FinalTerm command executing	Busy
OSC 777;notify	urxvt/VTE notification dialect	Done
?2004h	Bracketed paste enabled (readline back at prompt)	Done
?2004l	Bracketed paste disabled (about to execute)	Busy
?1049l	Alt-screen leave (vim/fzf/lazygit exited)	Done
Byte-quiet	5 s of no PTY output (≥200 bytes received)	Done
Hard ceiling	12 s maximum working state	Done (safety net)

Cross-chunk sequence reassembly is also new: OSC and CSI sequences that split across PTY chunk boundaries are now correctly matched via a per-session tail buffer, so split sequences can never be missed.

Overview: Pagination and Remove

The recent projects list in the Overview splash screen has been improved.

• Pagination: navigate across all recent projects with ← / → controls, 5 per page
• Remove: an × button on each row removes that project from the recents list without opening it

Platform Support

Platform	Status
Windows 11 (x64)	Supported. Pre-built binary available
macOS	Supported
Linux	Supported

Windows requires WebView2 (bundled automatically when necessary).

What's next

• Bug fixes from testing
• Command palette (Ctrl+K)
• Per-agent configuration: a dedicated settings view to customize how each agent starts globally — flags, environment variables, working directory, and more
• Agent isolation: Agents run in a fully isolated environment with complete, permissionless capabilities so workflows can run end-to-end without intervention. Choose from multiple isolation mechanisms based on your setup and security requirements.
• Chat window: an agentic GUI chat interface built into Tempest. Use it like any other agent session, or use it to create plans, write design documents, and think through problems before writing code.
• Database branches: each agent gets its own isolated clone of your production database. Agents can run migrations, seed data, and make schema changes freely without ever touching the shared database.

v0.1.1

Tempest v0.1.1

A major quality-of-life release focused on making Tempest a better daily driver. Better Git workflows, reusable prompts, persistent workspaces, queued agent tasks, cross-platform releases, and dozens of improvements across the editor and UI.

Cross-platform releases

Tempest now ships native releases for Windows, macOS, and Linux.

Every release is built automatically through GitHub Actions and published with platform-native packages:

• Windows: Portable .exe, NSIS installer, and MSI installer
• macOS: .dmg installer
• Linux: .AppImage and .deb packages

Automatic update manifests are generated alongside every release, making future updates seamless across supported platforms.

No source build required.

What's in this release

Prompt Library

Prompts are now first-class citizens inside Tempest.

Create your own reusable prompt library, organize prompts however you like, and reuse them across every workspace.

• Built-in prompts for Review, Tests, Security Review, Explain Changes, and Commit Messages
• Create, edit, clone, delete and reset prompts
• Drag-and-drop reordering
• Enable or disable prompts individually
• Prompt picker directly in the workspace toolbar
• Deep-link directly into Prompt settings
• Built-in prompts automatically appear after upgrades without overwriting your customizations

Message Queue

Sometimes an agent finishes while you're busy.

Instead of interrupting your workflow, queue messages for any agent. Tempest automatically sends the next queued instruction the moment that agent finishes its current task.

• Per-agent message queues
• Queue panel (Ctrl+Shift+Q)
• Queue badges on session tabs
• Automatic dequeue after work completes
• Remove individual items or clear the queue entirely

Perfect for chaining long-running agent workflows without babysitting every response.

Branch Management

Managing Git branches is now significantly easier without leaving Tempest.

• Branch picker directly inside the Diff pane
• Switch branches without opening a terminal
• Delete local and remote branches
• Force-delete support for unmerged branches
• Current branch indicator
• Worktree branches automatically hidden from the picker

Switching branches is now safer too.

If your working tree contains changes, Tempest automatically stashes them before switching branches and restores them afterward, ensuring work is never lost.

Safer Push Workflow

Pushing code is now separated from committing code.

Previously, clicking Push could automatically create a commit before pushing.

Now:

• Push never creates commits
• Push only pushes the current branch
• Create and push a brand new branch directly from the Diff pane
• Automatically opens a Pull Request after creating a new branch
• Rollback protection if branch creation fails

File Editor Improvements

The built-in editor is now fully writable.

• Save files with Ctrl+S / Cmd+S
• Dirty indicator for unsaved changes
• Reliable save pipeline
• Fixed opening Git diffs from editor tabs

Workspace Persistence

Tempest now remembers considerably more about your workspace.

After restarting the application:

• Session order is preserved
• Active session is restored
• Editor tabs reopen
• Diff tabs reopen
• Live Preview restores its URL
• Workspace layout is restored exactly as you left it

Runtime State

All application state has moved from browser storage into a dedicated runtime JSON file.

Projects, sessions, settings, prompts, keybindings and workspace state now survive browser cache clears and WebView resets.

Split Panes

Split panes received another large round of improvements.

• Better nested sub-session rendering
• Unlimited recursive split sessions
• Correct sidebar hierarchy
• Cleaner pane borders
• Improved resize behavior
• Better session identity across restores
• Fixed duplicate sessions after restart

Git Improvements

Numerous improvements landed across the Git experience.

• Better staging workflow
• More reliable commit flow
• Improved diff loading
• Better branch switching
• Cleaner push flow
• Fixed several edge cases around hidden panes and background tabs

UI & UX

Lots of polish throughout the application.

Highlights include:

• Improved Prompt Picker
• Better copy feedback animations
• Cleaner branch menus
• Improved staging interface
• More responsive dialogs
• Better keyboard shortcuts
• More consistent button styles
• Improved Broadcast dialog
• Numerous layout and scrolling fixes

Stability

This release fixes dozens of issues discovered after the initial launch, including:

• Editor save reliability
• Diff pane loading
• Branch switching edge cases
• Hidden pane click interception
• Push safety
• Prompt picker usability
• Broadcast dialog rendering
• Session persistence bugs
• Various Git workflow issues

Platform Support

Platform	Status
Windows 11 (x64)	Supported. Pre-built binary available
macOS	Supported
Linux	Supported

Windows requires WebView2 (bundled automatically when necessary).

What's next

• Database Branches
• Token Intelligence
• Per Agent isolation
• Multi-agent coordination

v0.1.0

Tempest v0.1.0 — Initial Release

The first public release of Tempest. Run a fleet of AI coding agents in parallel — each isolated, none colliding.

---

What's in this release

Multi-agent workspace

Every agent session runs in its own git worktree — a real, isolated branch with its own working tree. Agents write to their branch. Your main branch is never touched. You can have five agents working in parallel on five different features and none of them will ever see each other's files.

Supported agents out of the box: Claude Code, Gemini CLI, Opencode, GitHub Copilot CLI, Cline, Cursor Agent, Goose.

---

Terminal & agent sessions

• PTY-backed terminal sessions (PowerShell on Windows, $SHELL on Unix)
• Agent sessions wrap the CLI so exiting the agent drops back to a live shell — no frozen terminal
• Custom prompt — pass an opening instruction at spawn time; the agent starts on the task immediately without waiting for user input
• Per-session tab bar with drag-to-reorder, inline rename, and close
• Split panes — split any terminal vertically (Ctrl+Shift+|) or horizontally (Ctrl+Shift+_); sub-sessions nest under their parent in the sidebar with an L-connector; splitting a sub-session works recursively

---

Work-done detection

Tempest watches each agent session and signals when it has finished:

• OSC 9 — Claude Code emits a shell notification on task completion; Tempest catches it instantly
• Byte-quiet timer — 4-second silence after output stops triggers done for all other agents
• Tab bar and sidebar show a spinner while the agent is working and a green dot when it finishes
• Clicking the active tab while done resets to idle

---

Staging area

Full git staging UI accessible via the Eye button in the right sidebar:

• Staged / Unstaged file lists with per-file stage (+), unstage (−), and discard (✕) buttons; Stage All / Unstage All one-click actions
• Files with both staged and unstaged changes appear in both sections simultaneously
• Per-file diff — click any file to see git diff --cached (staged) or git diff (unstaged); untracked files rendered as all-added lines
• Commit form — title input + optional description textarea; Ctrl/Cmd+Enter submits; co-authored-by Tempest toggle (synced with Settings → Attribution)
• Push / Open PR — solid green header buttons; push detects staged content and commits only that; falls back to stage-all only when nothing is staged

---

File editor

Click any file in the right sidebar's Files tab to open it in a CodeMirror 6 editor tab:

• Syntax highlighting for JS, JSX, TS, TSX, CSS, HTML, Rust, Python, JSON, Markdown
• Theme hot-swap — editor chrome and syntax colors update instantly when switching themes
• Markdown preview — Raw / Preview toggle for .md files; rendered with react-markdown + GitHub-accurate theming (dark and light); local images resolve correctly via Tauri's asset protocol

---

Live Preview

Open a native embedded browser tab pointed at your local dev server. Watch changes land in real time as agents edit files — no switching to a separate browser window.

• URL bar with Back, Forward, Reload
• Tracks SPA navigation automatically
• Webview is destroyed when hidden and recreated on reveal — no idle memory cost

---

Right sidebar

• Files tab — lazy-loading file tree of the project root; directories expand on click
• Changes tab — git status against the active worktree; auto-refreshes every time an agent finishes a turn
• Resizable via drag handle (180–560px); collapses via PanelRight toggle in the sub-bar

---

Settings

• Appearance — theme picker (Origin Dark / Origin Light), sidebar font size (12–18px)
• Terminal — font size, font family (7 presets), cursor style, cursor blink, scrollback; all settings hot-swap on open sessions without restarting
• Git — branch prefix (prepended to every new worktree branch), commit message template
• Keybindings — rebind any action
• Attribution — toggle the Co-authored-by: Tempest trailer on commits

---

Session persistence

All app state (sessions, projects, settings, keybindings, recents) is stored at:

• Windows: %APPDATA%\com.user.tempest\runtime-state.json
• macOS: ~/Library/Application Support/com.user.tempest/runtime-state.json
• Linux: ~/.local/share/com.user.tempest/runtime-state.json

Sessions restore on restart. Closing a tab leaves a ghost entry in the sidebar — clicking it resumes the agent conversation from where it left off (--resume for Claude Code, -s <id> for Opencode, etc.).

---

Performance

• DashMap — per-session writer locks replace a global mutex; session A's slow write never blocks session B
• Channel<T> — per-session unicast channels replace a shared broadcast event; each terminal receives only its own output
• WebGL pool — up to 6 GPU-accelerated xterm.js contexts shared across sessions; LRU eviction to canvas fallback prevents Chromium context exhaustion at 9+ sessions
• Headless Session Manager — ring buffers and work-done detection run independently of visible panes; switching tabs never loses output
• Junction links — node_modules and .venv are junction-linked (Windows) or symlinked (Unix) into each worktree instead of copied; branch creation goes from 30–120s to under a second
• OnceLock shell probe — shell binary resolved once at startup; per-session probe penalty eliminated

---

Overview page

Dashboard shown when no session tab is active:

• Live list of all open workspaces — work-state dot, agent icon, branch name, changed file count
• Rows sorted: done → working → idle
• Open / Eye (diff) / PR buttons per row
• Splash screen with recent projects and keyboard shortcut reference when no sessions are open

---

Broadcast

Send the same prompt to multiple agent sessions simultaneously via the Megaphone button in the tab bar (Ctrl+Shift+M). Useful for cross-agent instructions like "commit your changes" or "run tests".

---

CI / CD

• .github/workflows/ci.yml — type check + frontend build + cargo check on every push and PR to main
• .github/workflows/release.yml — full Windows build, artifact upload (NSIS installer, MSI, portable .exe, .sig files), and latest.json updater manifest published on every v* tag
• In-app auto-updater wired via Tauri's updater plugin (quiet install mode)

---

Platform support

Platform	Status
Windows 11 (x64)	Supported. Pre-Built binary available
macOS	Build from source (untested)
Linux	Build from source (untested)

WebView2 is required on Windows (ships with Windows 11; installer bundles a bootstrapper for older systems).

---

Known issues

• Zen mode blank screen — opening a project in Zen mode results in a blank white window; the child WebviewWindow is created but the React app does not render
• Orphaned PTY on delete (unconfirmed) — the .tempest-pid sidecar fix is logically sound but has not been tested with a real orphaned process after restart
• History nav blank — the History sidebar button sets a nav state but nothing renders for it; navigating to History shows a blank content area

---

What's next

• macOS support — native .app bundle and DMG distribution
• Linux support — .AppImage and .deb packaging for major distributions