# Wake: a Rust and GPUI desktop app that gathers every coding-agent session on your machine

> Wake reads the local session stores of Claude Code, Codex, OpenCode, Gemini CLI and a dozen other agents, indexes them with SQLite FTS5, and reopens any conversation in its original terminal. It is macOS first, with experimental Linux and Windows builds.

**iAmCorey/Wake** — All your AI agent sessions in one place — browse, search, resume. Rust + GPUI.

- Repository: https://github.com/iAmCorey/Wake
- Stars: 1,383 · Forks: 88
- Language: Rust
- License: MIT
- Published: 2026-09-10 · Updated: 2026-09-10 · Language: en
- Canonical page: https://hysenlabs.com/projects/iamcorey-wake

## The scattered session problem Wake was built for

A working developer in 2026 may have Claude Code transcripts under ~/.claude/projects, Codex logs under ~/.codex/sessions plus a state_5.sqlite file, OpenCode databases under ~/.local/share/opencode, and Gemini CLI chats under ~/.gemini/tmp. Each tool has its own directory layout, its own file formats (JSONL, SQLite, zstd-compressed JSONL), and its own resume syntax. Finding the session where you fixed a specific bug three weeks ago means grepping through four different trees by hand.

Wake's answer is a single native window over all of them. The README describes the app as reading those directories read-only and giving you one fast window into the history. The intended user is someone who already runs more than one agent and treats sessions as a durable record rather than scratch space. It is not a chat client: Wake does not send prompts to any model, and the README states that the app only contacts GitHub when you explicitly check for an update.

## How the read-only index and resume path actually work

The repository is a Cargo workspace with two members, crates/wake-core and crates/wake, versioned together at 0.6.5. The dependency list in Cargo.toml shows the shape of the mechanism: walkdir for directory traversal, notify for live file watching, rusqlite with the bundled feature for the index, zstd for decoding compressed logs, and gpui 0.2 with gpui-component 0.5 for the interface. The README credits Rust + GPUI for the native window.

On the data side, Wake walks each known agent directory, parses whatever format it finds, and writes a SQLite FTS5 trigram index. The trigram choice is the interesting part: the README claims it handles CJK text and code substrings like useEffect( equally well, and that a search jumps straight to the matched message in the transcript. A plain word-token index would fail on both of those cases, so this is a deliberate trade-off in index size for substring matching.

Resume is deliberately shallow. Wake does not embed a terminal; it reopens the session in your existing one (Terminal or iTerm on macOS, native terminal hosts on Linux and Windows) at the original project directory, running something like claude --resume or codex resume. The README also documents a bundled read-only MCP server called wake-mcp, which lets Claude Code, Codex, Cursor or any MCP client search the whole history and read transcripts page by page. That is the one path where another agent can consume Wake's index programmatically rather than through the GUI.

## Installing Wake and resuming your first session

The README points at the GitHub releases page as the distribution channel, and the platform badge lists macOS 14+ as the supported target, with Linux and Windows marked beta (experimental Linux since v0.2.5, experimental Windows since v0.2.7). There is no package-manager command documented in the README, so the release page is where a binary comes from.

Building from source is the other route, since the repository is a normal Cargo workspace. The workspace pins an unusual dev profile that matters on a GPUI dependency tree this large:

```toml
[profile.dev]
# gpui 依赖树巨大,dev 依赖开优化让 UI 不卡
opt-level = 1

[profile.dev.package."*"]
opt-level = 2
```

That comment in Cargo.toml says the GPUI dependency tree is huge and that enabling optimization for dev dependencies keeps the UI from stuttering. If you build without it, expect a sluggish window.

Once the app is running, the first useful action is the search shortcut, which the README gives as ⌘K on macOS and Ctrl+K elsewhere. Typing a code fragment such as useEffect( should land you on the matching message inside a transcript rather than on a session list, because the FTS5 trigram index matches substrings. From there, one-click resume hands the session back to your terminal at the original project directory. Nothing is written to the agent's own files during any of this; starring and pinning are stored in Wake's own database, and the README says the original files are untouched.

## Where Wake stops: encrypted stores, cloud sessions and remote overrides

The supported-agent table is the honest core of this project, because it also lists what cannot work. Cursor IDE chats, Windsurf and Trae encrypt their local data, and Amp, Factory (Droid) and Warp keep sessions in the cloud. None of those are supported, and no amount of configuration changes that. Reasonix stores sessions locally but has not been mapped yet, which is a different situation: possible later, not possible now.

Antigravity CLI is a partial case. Wake reads ~/.gemini/antigravity-cli/conversation_summaries.db, but the table notes that this is metadata only, because the transcripts themselves are encrypted. You get the index entry without the conversation.

Remote hosts carry their own constraints. Wake asks the remote which known agent directories exist, then mirrors only those with rsync into remotes/<host>/ under its own data directory. The README is explicit that only session data and sidecar files are copied, never credentials, and that nothing on the remote is ever written. But SSH has to work without prompts: Wake runs without a terminal, so it can never answer a passphrase prompt, and you must connect once from a terminal beforehand so the host key is already trusted. rsync is required on both ends. Remote sessions are read-only in Wake and cannot be moved to the Trash, the mirror simply follows the remote. The remote is assumed to use each agent's default paths under the login user's home, so CODEX_HOME-style overrides on the remote are not detected, and remote Windows machines are not supported at all.

## Wake against a plain grep over ~/.claude

The obvious alternative is the shell: grep -r over ~/.claude/projects, plus a manual claude --resume with a session ID you copy out of the filename. That costs nothing to install and works on any machine where the agent runs, including ones Wake does not support.

The difference in approach is the index. A grep walks the files every time and returns lines, so a hit inside a long JSONL transcript tells you the text exists but not which conversation turn or which project it belongs to. Wake builds a persistent SQLite FTS5 trigram index, groups sessions by agent and project, and jumps to the matched message in a rendered transcript with user and assistant bubbles, collapsible tool-call clusters and tree-sitter highlighting for 30+ languages. The README also describes Grok Build subagents nested under their parent and live file watching for incremental updates, which is the part a grep loop cannot match without writing your own watcher.

The trade-off runs the other way on coverage and on trust. grep reads whatever is on disk in whatever format; Wake only reads formats its parsers know, which is why the unsupported list exists. And an index is a second copy of your history in Wake's data directory, which is a real consideration if your transcripts contain anything sensitive.

## Maintenance, releases and the MIT licence

The last push to the repository was on 2026-09-09, the same day v0.5.2 was tagged, with v0.5.1 and v0.5.0 landing the day before. The workspace version in Cargo.toml is 0.6.5, ahead of the latest release tag listed in the README, which suggests development happens on main between tags. The repository is not archived. The release cadence visible in the release list is fast, and the supported-agent table is the kind of surface that needs constant updating as each agent changes its storage format; that is the ongoing maintenance cost a user inherits, not a one-time install.

Licensing is MIT, declared both in the README badge and in the workspace Cargo.toml under [workspace.package]. MIT is permissive: it allows use, modification and redistribution with the copyright notice and permission notice retained. This is not legal advice, and if you plan to redistribute Wake inside a commercial product you should read the LICENSE file in the repository rather than rely on a summary. The agents Wake reads are separate programs with their own licences and terms, and Wake's read-only posture toward their data does not change those terms.

## Conclusion

Wake fits developers who run several coding agents on macOS and keep losing track of which session holds the fix. It is not for anyone whose history lives in Cursor IDE, Windsurf or Trae, since those stores are encrypted and the README lists them as unsupported. Before adopting it, check the supported-agent table against the agents you actually use, and confirm your SSH keys are loaded into an agent if you plan to mirror remote hosts.

## FAQ

### Which AI agents does Wake support?

The README lists Claude Code, Codex CLI, Qoder CLI, Copilot CLI, Cursor CLI transcripts, OpenCode and OpenCode 2, Kiro, Gemini CLI, Pi, Oh My Pi, Grok Build, Kimi Code, Antigravity CLI (metadata only), DeepSeek Harness, Hermes Agent and OpenClaw. Cursor IDE chats, Windsurf, Trae, Amp, Factory (Droid) and Warp are explicitly not supported.

### Does Wake modify my original agent session files?

The README states that Wake reads the agent directories read-only and that starring and pinning are stored in Wake's own database, leaving the original files untouched. Deletion moves sessions to the system Trash and records a tombstone so deleted sessions stay deleted.

### How does Wake resume a session?

It reopens the session in your existing terminal (Terminal or iTerm on macOS, native terminal hosts on Linux and Windows) at the original project directory, using the agent's own resume command such as claude --resume or codex resume. Remote sessions resume through a copyable ssh -t command instead.

## Sources

- [iAmCorey/Wake on GitHub](https://github.com/iAmCorey/Wake)
- [Issues](https://github.com/iAmCorey/Wake/issues)
- [License: MIT](https://github.com/iAmCorey/Wake/blob/main/LICENSE)
- [README](https://github.com/iAmCorey/Wake/blob/main/README.md)
- [Releases](https://github.com/iAmCorey/Wake/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/iamcorey-wake