Claude Code Session Manager: Wake for Mac

A Claude code session manager sounds like a nice-to-have right up until the Tuesday you know you solved a bug three weeks ago, in some session, on some project, and claude --resume shows you a list of truncated first lines that all look identical. Wake, released on August 19, 2026, is a native macOS app that reads every agent's transcript directory on your machine and puts the lot behind one search box.

Key Takeaways:

• Wake indexes 13 coding agents, not just Claude Code, including Codex CLI, OpenCode, Gemini CLI, Kiro, Grok Build and Kimi Code.
• Search is SQLite FTS5 with a trigram index, so useEffect( and CJK text both match, and results jump to the exact message inside the transcript.
• Every agent directory is opened read-only, credential files are skipped, and the app makes no network requests at all.
• It's macOS 14 or newer and there's no signed installer yet; you build it from source with a Rust toolchain, or fight Gatekeeper over an ad-hoc-signed download.
• Three releases landed in the first two days, so treat version-specific details here as a snapshot of August 2026.

The problem a Claude code session manager solves

Your agent history isn't in one place, and it isn't in a format you'd choose. Claude Code writes JSONL under ~/.claude/projects. Codex keeps ~/.codex/sessions alongside a SQLite file. OpenCode has its own database, Gemini CLI drops chats in a temp directory, and by Wake's own count there are nine more layouts after those. Nobody designed this; it accumulated, one tool at a time, each one reasonably deciding that where it kept its own transcripts was its own business.

The consequence is specific and irritating: the knowledge is on your disk, in plain text, and you can't get at it. Grepping raw JSONL gets you a match with no idea which conversation it came from or how to pick that conversation back up.

What makes this worse than an ordinary search problem is that agent transcripts are where the reasoning lives. The commit message says what changed; the session says why the first two approaches didn't work, which library version broke, and what the error text actually was. Losing that isn't losing a chat log, it's losing the debugging. And it compounds, because the more agents you try, the more directories accumulate and the lower the odds that the one you want is in the one you happen to check.

Which is the argument for a Claude code session manager as a category rather than for any particular app. Something has to read all of them at once.

Corey Chiu created the repository on August 18, 2026 and tagged v0.1.0 the next morning, which makes Wake about the youngest Claude code session manager you could pick. By August 21 it had 347 stars, 20 forks and exactly 10 commits, which tells you both that the idea landed and that the code is three days old.

What Wake actually indexes

The support table is the most useful thing in the README, because it's honest about gaps rather than claiming universal coverage. Thirteen agents are read: Claude Code, Codex CLI, Copilot CLI, Cursor's CLI transcripts, OpenCode and its v2 beta, Kiro, Gemini CLI, Pi, Oh My Pi, Grok Build, Kimi Code, and Antigravity CLI at metadata level only because its transcripts are encrypted.

Two columns sit beside each agent. One says whether Wake can show which model a session used; the other says whether it can show where the session was launched from, and only Codex records that in local data. A dash means the agent's own files don't hold the field, which is a distinction most tools would quietly hide.

The unsupported list is equally direct. Cursor's IDE chats, Windsurf and Trae encrypt their local data. Amp, Factory's Droid, and Warp keep sessions in the cloud, so there's nothing local to read. Reasonix stores locally but hasn't been mapped yet.

Search runs on an FTS5 trigram index, which is why it handles useEffect( and Chinese text equally well rather than falling over on anything that isn't a word. That choice is worth dwelling on, because the default tokeniser in most full-text setups splits on word boundaries and would quietly refuse to match a substring with a bracket in it. For searching code, that default is useless, and a trigram index costs disk to avoid it.

On the author's machine, roughly 310 sessions and 800MB of JSONL index in about five seconds, subsequent launches use an mtime-based incremental scan, and queries return in under a millisecond. Those are one person's numbers on one machine, and they're the only performance figures published.

Hit a result and Wake opens the transcript at the matched message, with tool-call clusters collapsed, thinking summaries folded, and tree-sitter highlighting across 30-odd languages. Then one click reopens that session in Terminal or iTerm at the original project directory, shelling out to claude --resume or codex resume as appropriate.

Managing is deliberately thin. Star or pin a session and the flag goes in Wake's own database rather than in the agent's files; export writes Markdown; delete moves the original to the system Trash and leaves a tombstone so a later rescan doesn't bring it back. Nothing here tries to become a second system of record, which for a v0.2 release is the right amount of ambition. It also means Wake never has to keep anything running, and that division of labour is exactly why it sits comfortably next to MoClaw rather than against it: one indexes what already finished on your Mac, the other is a hosted machine doing the work that has to continue somewhere.

The privacy stance is the interesting engineering

Reading another tool's data directory is a trust problem before it's a technical one, and Wake's answer is unusually specific. Agent directories are opened read-only and the app never writes to another tool's files or databases. Credential files such as auth.json are not read at all. There are zero network requests, and the README makes a finer point than most: GPUI's dependency tree bundles an HTTP client, and Wake simply never constructs one.

Its own index lives at ~/Library/Application Support/wake/wake.db and can be thrown away and rebuilt at any time, with stars and pins kept in a separate table so they survive the rebuild. Deleting a session moves the original to the system Trash and writes a tombstone, so a rescan doesn't resurrect it.

For a three-day-old app asking to read every conversation you've had with every agent, that's the right set of promises. It also points at the structural limit: everything Wake knows, it knows about this Mac. A session started on your work laptop is invisible from your desktop, because the transcript never left the machine that made it. MoClaw takes the other side of that trade, running the agent on a hosted cloud AI computer so the session and its files live somewhere both machines can reach, which is a different answer to the same scattered-history problem rather than a competing local index.

Installing it is the rough edge

There's no notarised installer. You clone the repo, run scripts/make-app.sh with a Rust toolchain present, and get dist/Wake.app. If you'd rather download a prebuilt copy, it's ad-hoc signed, so macOS Gatekeeper blocks the first launch and you either right-click and choose Open or run xattr -d com.apple.quarantine Wake.app.

That's a real filter, and not only for people who don't have Rust installed. Telling a security-conscious colleague to strip the quarantine attribute from a three-day-old binary that reads every conversation on their machine is a hard sell, and building from source at least means the thing you run is the thing you read. Anyone in a managed-device environment should expect this to be the step that stops them.

macOS 14 or newer, and macOS only. There is no Linux or Windows build and the GPUI dependency means one isn't a weekend's work.

Set against that: three releases in two days, a CI workflow, and a v0.2.1 that fixed OpenCode resume specifically. The project is moving, and 10 commits of history is not a code base you should put in the middle of anything that matters yet. Treat it as a very good reader for data you already have, which is a low-risk role, rather than as infrastructure.

Where a local index stops being enough

Wake solves retrieval. It doesn't solve the reason retrieval got hard, which is that agent work now happens in more places than a person can hold in their head, and each of those places is a laptop that sleeps.

That's the honest boundary. A session manager can find the conversation where you fixed the migration; it cannot keep the migration running while you're on a train. Anything long enough to matter, an overnight refactor or a scheduled job that fires at 3am, needs a machine that stays awake, and MoClaw is that machine: hosted, always on, sitting alongside the local agents you already have rather than replacing them. Wake tells you what happened. A hosted machine is what keeps something happening while you're not watching.

There's a second reason the two fit together. Wake resumes a session by shelling out to a CLI on the same box, which means the working directory, the installed toolchain and the half-finished branch all have to still be there. If you've reformatted, switched laptops, or simply cleaned up a checkout, the transcript survives and the resume doesn't; you get to read what you did without being able to continue it. Move that same work onto a hosted machine and resuming stops being a lookup problem, because nothing was ever suspended and the environment never moved.

The third gap is the one that shows up when there's more than one of you. Transcripts on your Mac are transcripts nobody else can search, so the answer to "didn't you already solve this?" stays locked on one laptop. A hosted machine puts the session and the files somewhere a colleague can be pointed at, which is a different kind of retrieval from the one Wake is built for and not a criticism of it, since a read-only local indexer was never going to reach across machines. Our macOS agent harness comparison goes through what stays local and what doesn't, and the Claude skills roundup covers what to put in those sessions once you can find them again.

FAQ

Is Wake free and open source?

Yes, MIT licensed, with the full source on GitHub. There is no paid tier, no account, and no telemetry, as of August 2026.

Which coding agents does Wake support?

Thirteen: Claude Code, Codex CLI, Copilot CLI, Cursor CLI transcripts, OpenCode, OpenCode 2 in beta, Kiro, Gemini CLI, Pi, Oh My Pi, Grok Build, Kimi Code, and Antigravity CLI at metadata level only. Cursor's IDE chats, Windsurf and Trae are unsupported because their local data is encrypted, and Amp, Droid and Warp keep sessions server-side.

Is Wake Mac-only?

Yes, and it needs macOS 14 or later. It's built on GPUI, the same UI framework as Zed, which makes a cross-platform port a substantial piece of work rather than a build flag.

Does Wake modify my Claude Code or Codex files?

No. Every agent data directory is opened read-only, and the app keeps its own index in a separate database under Application Support. Stars, pins and tombstones live in Wake's database, not in the agents' files. Deleting a session sends the original to the system Trash rather than removing it outright.

Can it search sessions from another computer?

No. Wake reads the transcript directories on the machine it's running on, so anything created elsewhere is invisible to it. That's a consequence of the local-only design, not a missing feature, and it's the gap a hosted setup closes.