Documentation
Recall

How to search your Claude Code history across every machine

Claude Code keeps sessions on the machine that ran them. The built in picker, two local search tools, and how codecast searches every machine and every agent at once.

Claude Code keeps every conversation as a JSONL file under ~/.claude/projects/ on the machine where it ran. That makes search easy on one machine and awkward across several: a session from your laptop is not on your desktop, and a session from a cloud box or a teammate's machine is not on either. This guide covers the options for searching that history, starting with the ones that need nothing installed.

On one machine

claude --resume opens a picker of recent sessions for the current project, and the picker can filter the list. It is built in and fine for "the session I had yesterday", but it lists sessions from this machine only.

search-sessions is a small open source CLI (MIT) that searches the full text of every Claude Code and OpenClaw session in ~/.claude/projects/, with no index to build and no database. It also installs as a slash command inside Claude Code. It reads local disk only, by design.

LLMnesia is a free Chrome and Edge extension that indexes Claude Code sessions from the terminal, the VS Code extension and the desktop app, together with browser chats in ChatGPT, Claude, Gemini and others, into one local search. It also keeps everything on the device, with no account and no cloud.

If all your agent work happens on one computer, one of these is the least setup. Copying ~/.claude/projects/ between machines also works, since Claude Code reads session files wherever they are, but it is a manual step you have to remember each time.

Across every machine, with codecast

Codecast takes the other approach: instead of searching the files where they sit, a small daemon on each machine watches the history files your agents already write and syncs each conversation to your account as it happens. Every machine that runs the daemon under the same login feeds one history, so a search from any of them, or from the web, covers all of them:

curl -fsSL https://codecast.sh/install | sh
cast login

Search then runs from the terminal:

cast search "flaky deploy"               # every session you can see, keyword and semantic
cast search auth --mine -s 7d            # only your own sessions, last seven days
cast search "rate limit" -m samvit       # one teammate's sessions
cast search migration -u                 # only what a person typed, not the agent's replies
cast ask "how did we fix the flaky deploy?"   # a question answered across that history

Quoted phrases match exactly and unquoted words match anywhere. Each result names its session, which cast read <id> opens. The same history is searchable in the web app at codecast.sh/search.

Two things differ from the local tools. The search is not only yours: by default it covers every session your team can see for the current directory, and --mine narrows it to you. And it covers Codex, Cursor and Gemini sessions alongside Claude Code, because the daemon records those too. Your agents can run the same commands, which is what Agent memory describes in depth.

The limits are the other side of the design. It only covers machines where the daemon runs, it needs an account, and the history lives in codecast rather than only on your disk. Which directories are shared with a team, and which stay private to you, is set per directory; see See your whole team's Claude Code sessions in one place.

Choosing

Use claude --resume for a recent session on the machine in front of you. Use search-sessions or LLMnesia when you want full text search of your own history and want it to stay on one device. Use codecast when the history you need is spread across several machines or several people, or includes agents other than Claude Code, and you want one place to search it from.

More guides
How agent snippets work
cast install writes versioned instruction sections into your agents' own config files. This is the mechanism every other guide builds on.
Give Claude Code memory across sessions and teammates
Not notes files: every session can search, read, and watch every other session your team has run. The commands, the scopes, and how agents use them.
How to find which AI agent session wrote a line of code
git blame names whoever committed a line. cast blame names the agent session that wrote it and opens the exact message; Git AI and Agent Blame solve it with git notes instead.
Messaging between sessions
cast send turns sessions into teammates: any session can message any other, including a teammate's, and manage what the human sees in the inbox.
Ambient awareness
Stable mode injects a live feed of recent sessions into every new session at start. Combined with messaging, sessions know about each other without being told.
See your whole team's Claude Code sessions in one place
Claude Code already writes every session to disk. The codecast daemon syncs those files — plus Codex, Cursor, and Gemini — into one live team feed, inbox, and searchable record.
How to share a Claude Code session with your team
Three different asks hide behind that sentence: read a finished conversation, watch a running one, or make every session visible by default. What Anthropic ships, what Lore does, and where codecast fits.
Pinned thread state
cast state keeps one agent-written line saying where a thread stands, pinned above the composer and on the inbox card, with its staleness on show.
Decisions: asking without interrupting
cast decide puts a question, its options and the reasoning into a queue you clear when you choose to. The answer returns to the agent as a message.
Team chat that agents take part in
Channels, threads and direct messages where a mention can wake a role or a session, agent lines are capped, and a Slack workspace mirrors in.
Huddles and walkie
Every huddle is transcribed with exact speaker attribution and leaves a digest, so an agent can quote what was said on the call.
Forks and spawned sessions
cast spawn --subagent delegates a worker that nests under the session that launched it; plain cast spawn and cast fork start independent threads in the human's inbox.
Tasks and plans
The work tracking layer agents report into: tasks, plans, binding, comments, and the dashboard that watches it all.
Triggers
Follow-up work that runs after the session ends: delayed, recurring, or fired by a GitHub event.
Workflows
Execution graphs in DOT syntax: agent steps, shell commands, conditions, and human approval gates.
Orchestration
A conductor agent decomposes a plan, spawns implementers in isolated worktrees, and runs reviewers and critics over the result.
Pull requests and issues as codecast objects
cast pr and issue sync keep a copy of GitHub and Linear objects current from webhooks, send every action back, and wake the session that owns the work.
The org: roles, scopes and the line
Route work to a standing responsibility instead of a session: roles with scopes, wakes, proposals a person accepts, and a line that reviews before it ships.
Driving the human's own Chrome
cast browser works in a background tab of the Chrome that already holds your logins, and puts the evidence in the thread.
Driving a native macOS app
cast computer reads a window as an indexed tree, refuses stale indexes, and reports whether an action was verified.
One typecheck watcher for every session
cast check answers every session from one tsc --watch for each tree and project, so thirty agents do not build the same program thirty times.
The cast-* skills
23 packaged procedures, compiled into the CLI, each a fixed sequence of ordinary cast commands.
Sessions on machines you are not sitting at
How a session starts on, moves to, sleeps on and is watched from another machine, and what each lease does when the machine goes away.
Usage limits are a pause
Codecast parks a session that hits a limit, then continues it at the reset or on a saved account that still has room.
The visual canvas
Agents reply with sandboxed HTML that renders inline: charts, dashboards, diagrams, and small widgets instead of ASCII art.
Published pages
cast publish turns a file into a page at a stable URL, with version history, access gates, and viewer comments that flow back to the session.
How the client syncs
Every surface paints from a local store, an append only log for each scope delivers only what changed, and one window syncs while the others copy it.