Wake

Wake

A native desktop app that gathers every coding-agent session on your machine into one place — browse, full-text search, and resume any conversation in seconds. Built with Rust + GPUI (gpui 0.2 + gpui-component 0.5). macOS first; experimental Linux support since v0.2.5, experimental Windows support since v0.2.7.

Your agent history is scattered across ~/.claude, ~/.codex, and a dozen other private directories. Wake reads them all, read-only, and gives you one fast window into it. Everything stays local; Wake only contacts GitHub when you explicitly check for an update.

Features

• Unified browsing — all sessions grouped by agent / project, with Grok Build subagents nested under their parent and live file watching for incremental updates
• Full-text search (⌘K / Ctrl+K) — SQLite FTS5 trigram index; handles CJK text and code substrings (like useEffect() equally well; jumps straight to the matched message in the transcript
• Transcript view — per-message rendering with user/assistant bubbles, inline images (copy or save them), collapsible tool-call clusters, thinking summaries, tree-sitter code highlighting (30+ languages)
• One-click resume — reopens the session in your terminal (Terminal/iTerm on macOS; native terminal hosts on Linux and Windows) at the original project directory (claude --resume, codex resume, …)
• Manage — star/pin (stored in Wake's own DB, original files untouched), export to Markdown or save an inline image through the system Save dialog (Wake remembers the last folder), delete (system Trash + tombstone so deleted sessions stay deleted)
• Insights — a stats page for your whole library: GitHub-style activity heatmap with streaks, hour / weekday / month breakdowns, and Agents / Projects / Models leaderboards switchable between sessions, tokens, and prompts
• Remote hosts — mirror the sessions on your other machines over SSH (Settings → Remote hosts); they show up next to local ones with an @host badge, searchable like everything else, and resume through a copied ssh -t command
• Connect your agents (MCP) — a bundled read-only MCP server, wake-mcp, lets Claude Code, Codex, Cursor or any MCP client search your whole history, list recent sessions per project and read transcripts page by page, so a new agent can pick up where another one left off; Settings → Connect has copy-paste setup snippets
• Command line — wake-cli gives the same four answers to anything that can run a shell command: wake-cli sessions --project "$PWD", wake-cli search "…", wake-cli show ; it prints the same text an MCP client sees; npx skills add iAmCorey/Wake installs a skill so agents reach for it on their own

Supported agents

Model = whether Wake shows which LLM a session used (the model the session last used). Via = whether Wake shows where the session was started from (CLI, IDE extension, desktop app) — Codex records this in its local data; Hermes and OpenClaw record the channel a session came in through (Telegram, Discord, …). A "—" means the agent's local data simply doesn't record that field, not a missing feature.

Codex writes its background threads — the guardian auto-review, /review, compaction, memory consolidation and spawned sub-agents — into the same sessions directory as your conversations. Wake recognises them from the metadata on their first line and skips them; a file it cannot identify stays visible rather than risk hiding a real conversation.

Cursor keeps two stores. A chat that has a full transcript under ~/.cursor/projects is read from there; local workspace metadata and filesystem matching restore its project path, including spaces. Project metadata is refreshed on each scan even if the transcript is unchanged. Chats that only live in Cursor's own database — older ones, or Cursor versions that leave nothing but a turn_ended marker in the transcript — are read from state.vscdb. Older IDE chats that Cursor stored without a workspace show up under Unknown project.

Token statistics depend on the usage recorded by each agent. Qoder CLI transcripts that contain only zero token counts leave token usage unknown in Wake, even when they include Credits or a context usage ratio. Those values measure different things and are not converted into tokens; the sessions remain visible in the Sessions and Prompts views of Insights.

Windsurf and Trae encrypt their local data; Amp, Factory (Droid), and Warp keep sessions in the cloud — none of those are supported. Reasonix stores sessions locally but hasn't been mapped yet.

Remote hosts

Wake can mirror the sessions on your other machines and show them next to the local ones. Add a host in Settings → Remote hosts (an alias from ~/.ssh/config, or user@host); Wake then syncs on launch, on refresh, and whenever you click Sync now. Remote sessions carry an @host badge, are searchable like everything else, and resume through Copy SSH command, a ready-to-paste ssh -t 'cd && codex resume '.

Before you add a host:

• SSH has to work without prompts: load your key into an agent (Wake runs without a terminal, so it can never answer a passphrase prompt) and connect once from a terminal so the host key is already trusted
• rsync is needed on both ends — macOS and most Linux distributions ship one; on Windows install it yourself

How it works, and what it doesn't do yet:

• Wake first asks the remote which of the known agent directories exist, then mirrors only those with rsync into remotes// under its own data directory. Only session data and sidecar files are copied, never credentials, and nothing on the remote is ever written
• Remote sessions are read-only in Wake: they can't be moved to the Trash, and the mirror simply follows whatever is on the remote
• The remote is assumed to use each agent's default paths under the login user's home (CODEX_HOME-style overrides on the remote aren't detected), and remote Windows machines aren't supported

Connect your agents (MCP)

Wake ships wake-mcp, a small read-only MCP server over stdio that sits next to the app binary (Wake.app/Contents/MacOS/wake-mcp on macOS, beside wake on Linux and Windows). Point an MCP client at it and the agent gets four tools:

Setup is a copy-paste from Settings → Connect, or run wake-mcp setup in a terminal. For example, Claude Code:

claude mcp add --scope user wake -- "/Applications/Wake.app/Contents/MacOS/wake-mcp"

Codex reads the same server from ~/.codex/config.toml:

[mcp_servers.wake]
command = "/Applications/Wake.app/Contents/MacOS/wake-mcp"

A few things worth knowing:

• Everything is read-only: the server opens Wake's index without write access and never scans or rebuilds it; there are no delete or star tools (the one thing it can write is Wake's own data directory, which resolving the default index path creates)
• Search and lists come from Wake's index, so keep Wake running for fresh results — every reply says how recent the index is. Reading a transcript parses the agent's files rather than the index, so it does not depend on the last scan (remote-host sessions are read from their local mirror)
• Agents see the same session files Wake indexes, on this machine only (remote-host mirrors included); nothing leaves the machine
• wake-mcp call wake_search '{"query":"useEffect("}' runs a single tool from the terminal, handy for checking what an agent would see

The full reference — every parameter, output formats, key and reference formats, error semantics, troubleshooting — is in docs/mcp.md.

From a shell

Not every agent speaks MCP, and sometimes you just want the answer in a terminal. wake-cli sits next to wake-mcp and covers the same ground:

wake-cli sessions --project "$PWD" --limit 5      # what happened in this repo
wake-cli search "rate limiter" --project "$PWD"   # where was this discussed
wake-cli show 'claude-code:1b2c3d4e-…'            # read that transcript
wake-cli setup                                    # path, PATH setup, and a block to paste into CLAUDE.md

It prints what the MCP tools return, asserted byte for byte in the test suite apart from a trailing newline the CLI adds, so an agent driving it through a shell sees what a connected one does. Full reference in docs/cli.md.

To make an agent reach for it without being told, install the bundled skill with npx skills add iAmCorey/Wake (or copy skills/wake/ into ~/.claude/skills/wake/).

Language

Wake's interface follows your system language on first launch and falls back to English. Simplified Chinese ships with the app; pick a fixed language under Settings → General → Language.

Adding a language is one flat JSON file mapping the English text to your translation — drop it in Wake's config folder to use it immediately, or send it as a pull request. Untranslated strings simply stay English, so a partial pack is welcome. See crates/wake/locales/README.md.

Privacy stance

• Agent data directories are opened read-only; Wake never writes to another tool's files or databases
• Credential files (auth.json and friends) are never read
• Remote hosts are mirrored read-only with rsync over your existing SSH setup: only session data and its sidecar files come across (never credentials), nothing on the remote machine is ever written, and the mirror lives inside Wake's own data directory (remotes//), so re