🔮 claurdvoyant

Your AI coding sessions are gold. Stop letting them rot in scattered folders.

One tool to find, read, search, port, and stream every agent session you've ever run — across every harness.

claude · codex · grok · opencode · gemini · hermes · openclaw · cursor · …

parse anything · search by meaning · resume anywhere · let your agents read each other's minds

_{the desktop app reading 2,245 real local sessions across 8 harnesses — heatmap, harness legend, and a live feed}

You spent three hours teaching an agent your codebase. That context — the dead ends, the decisions, the hard-won understanding — is some of the most valuable output you produce. And then:

• 🙈 You can't find it. It's one of hundreds of .jsonl files in a folder named after a path. (Yes, you keep the important session IDs in a notes app. Everyone does.)
• ⛓️ It's trapped. Most harnesses only resume a session from the exact directory it ran in. Move the project, lose the thread.
• 🏝️ It's stranded. Started in Claude Code but want to continue in Codex? Tough. Every tool speaks its own dialect and none of them talk.

Restarting from scratch is the most expensive thing you do all day. claurdvoyant makes sure you never have to.

# 🔎 find that session from last week by what it was ABOUT, not where it lived
cv search "the flux inference refactor"        # full-text, instant
cv-search semantic "formalizing proofs"        # by meaning — no keyword overlap needed

# 🚀 take a Claude session and continue it in Codex. for real.
cv convert da9174f4 --to codex
#   ✦ wrote ~/.codex/sessions/2026/…/rollout-….jsonl
#   ↳ codex resume 019e75e0-…

# 🧳 break a session out of its directory jail (brings CLAUDE.md / MEMORY.md along)
cv port da9174f4 --to-dir ~/new/home

# 👁️ watch every agent on your machine work, live, in one feed
cv scry

…and a couple that didn't exist before:

• 🧠 An MCP server so a running agent can read other agents' sessions — "what happened in this project before?", "what's my sibling agent doing right now?" — and even await_omen: block until another session prints something matching a regex.
• 📣 A coordination board (cv board + MCP): agents post status and hand off work to each other. With the daemon mirroring activity, it's a live feed across your whole cloud fleet.
• 🌐 A zero-install web viewer: drag a zip of any harness folder into your browser and explore it. Nothing uploaded, all WASM.

_{¹ The Claude app keeps transcripts server-side; the ChatGPT app keeps them locally but encrypted at rest. We detect the install and document exactly why neither is readable — see docs/FORMATS.md.}

Conversion is N-way among the 13 emit-capable harnesses: any → any, mediated by one unified IR. Every format reverse-engineered in docs/FORMATS.md. Bringing your own? → ADDING_HARNESS.md 💛

• 🧵 Splice & loom — compose a new session from spans of others (cv splice A:0-12 B:6-), or fork-and-graft a branch and generate its continuation with an LLM (cv loom … --generate). Works via OpenRouter / Anthropic / LM Studio (free, local, offline). Loom agent transcripts like a Janus loom, across any harness.

• 🧠 Distill — cv distill <id> turns a session into a durable MEMORY.md digest (decisions, gotchas, where things live). Your archive compounds instead of rotting.

• 🔮 Recall — semantic "have I solved this before?" — as a cv recall command and an MCP tool that hands a running agent the relevant past span.

• 🧬 Provenance — search answers what was said; the event catalog answers what was done. Every tool call across every session is classified and queryable: cv touched <file> lists every session that ever edited a file, and cv blame <file> ties a file's git history back to the agent conversation that wrote it — "why does this code exist?", answered by the actual reasoning that produced it (with a cv show --range jump to the moment of the edit).

• 🌳 Anatomy of a run — a deep agent session isn't a flat transcript, it's a forest. cv workflow <id> renders a Workflow-tool run as its real shape — the phase tree, the agents under each phase, their journaled outcomes/tokens/tool-calls, and the driving script. cv tools <id> is cross-agent tool analytics over the whole orchestrator+sub-agent forest (per-agent histograms, which agent used what, a wall-clock timeline). cv compaction <id> finds every context-compaction seam — trigger, pre-compaction size, and the summary that seeded the next window — and cv show --pre-compaction reads back the span the continued agent lost. (cv dataset --subagents pulls the whole forest into a training set.)

• ✂️ Prune — cv prune <id> is custom compaction: instead of abandoning a giant session to the summarizer (which rewrites your history into a lossy paragraph), it snips the bulky old tool payloads — large file reads, command logs, screenshots — into a sidecar and leaves a tiny [PRUNED id=…] marker, producing a new, resumable session (claude --resume <new-id>). Your prompts and the exact flow stay verbatim; the most recent turns stay sharp; originals are one cv prune … --retrieve away. (Algorithm adapted from the validated flatten-mcp.)

• 🔒 Redact — cv redact <id> scrubs secrets/PII so a transcript is safe to share.

• 🎁 Share — cv share <id> → one self-contained, redacted-by-default HTML artifact: dark crystal-ball theme, collapsible thinking/tool folds, opens offline in any browser, uploads nothing (CSP-pinned so it can't).

• 📦 Pack — cv pack "<task>" compiles a context bundle from your whole corpus: relevant past spans + what files those sessions actually touched (event catalog), as a CLAUDE.md digest, a system prompt, or a synthetic resumable session in any harness. Never explain your codebase to an agent twice.

• 📣 Coordination board — agents post status, hand off work, and grab tasks with a distributed lock (board_claim) so a fleet never duplicates effort. await_omen blocks until a session matches a regex.

• 🖥️ Desktop app + 🌐 web viewer — the Tauri app reads all your local sessions natively (zero setup) and lays the corpus out beautifully:

  • a Projects lens — every repo, every agent that touched it, over time;
  • a GitHub-style activity heatmap timeline (a constellation of your working days);
  • side-by-side Compare, a Stats dashboard, a visual loom composer (OpenRouter or free local LM Studio generation), and a live fleet dashboard;
  • sub-agent trees — a Claude Task session's children, nested and lazy-loaded inline, each labeled with its task prompt;
  • a Structure explorer (<cv-forest>) — Overview / Forest / Workflows / Tools / Compaction tabs that turn a run's anatomy into something you can drill through.

  The browser build is zero-install — drop a harness zip, nothing uploaded (all WASM).

• 🔌 Harness integrations — plug claurdvoyant into the agents' own hooks/MCP/plugins (integrations/): SessionEnd → archive + distill, SessionStart → recall, events → the board.

Full docs — every CLI command, the MCP tools, the daemon's HTTP API, the app, cross-harness conversion, and the harness table — live in the user manual (mdBook, also under manual/).

Prebuilt binaries for macOS / Linux / Windows (arm64 · x64 · x86) ship on every release — grab the latest from Releases (cv · cv-mcp · cvd · cv-tui · cv-search), or one-line it:

curl --proto '=https' --tlsv1.2 -LsSf https://github.com/emberian/claurdvoyant/releases/latest/download/cv-installer.sh | sh

Or from source:

cargo build --release          # → target/release/{cv, cv-mcp, cvd, cv-tui, cv-search}

claude mcp add claurdvoyant -- /path/to/target/release/cv-mcp

18 tools, incl: list_sessions · search_sessions · read_session · project_sessions · recall (semantic "where was this solved before") · await_omen (block until a session matches a regex) · board_post/read/await + board_claim/release/who (coordination + distributed locks).

cvd sync     # snapshot every session into ~/.claurdvoyant
cvd watch    # follow live + archive as sessions change → a fleet activity feed

After staring into seven different transcript formats, we wrote down the one they should have agreed on: OpenSession — a small, honest, harness-neutral interchange format (the key heresy: cwd is metadata, not identity). claurdvoyant's IR is its reference implementation. If you ship a harness, emit OpenSession and everyone's sessions become portable by construction. 🤝

One IR (Session → Message → Block{Text|Thinking|ToolUse|ToolResult|File|Image}), one Adapter per harness (discover + parse + emit), plus loom / redact / board / watch / ingest modules — and small crates on top: cv (CLI) · cv-mcp (MCP) · cvd (daemon + serve) · cv-search (tantivy + model2vec) · cv-llm (distill/generate) · cv-web (WASM) · app/ (Tauri desktop).

parse(any harness) → 🔮 unified IR → search · convert · port · loom · distill · archive · coordinate · view

Built in a wild few sessions, much of it by a swarm of agents working disjoint files. ✨ Honest about the edges:

• 20 harnesses parse; the 7 core ones also emit (N-way conversion). The rest — Cursor, Kimi, Qwen, LM Studio, Cline, Roo, Continue, Goose, Zed, and the ChatGPT/Claude.ai account data exports (chatgpt-export/claude-export — register their location with cv config --add-export <path>) — are parse-only for now.
• Robustness: 2000+ real sessions parse with 0 panics; parsers are fuzz-tested against hostile input.
• The full-text index trades disk for speed; Gemini's protobuf .pb is opaque; a few sidecar tool-call streams aren't merged yet.
• Historical format variants are an explicit goal — see ADDING_HARNESS.md, and please send your own harness logs (we can only test what we can see).

PRs and weird old transcripts deeply welcome. 💜