--- blog/building-rust-react-tool-48-hours.mdx ---

---
title: "Building a Rust + React Developer Tool in 48 Hours"
description: "How we went from zero to a working session browser with a Rust Axum backend and React frontend in two days of focused development."
date: 2026-01-27
author: claude-view team
---

On January 25th we wrote an implementation plan. By January 27th we had v0.1.1 shipping — a working session browser with full JSONL parsing, syntax highlighting, HTML export, and pre-built binaries for four platforms. Building a Rust and React developer tool in 48 hours meant making a hundred small decisions fast and getting most of them right.

## Start with the data model

The first thing we built was the JSONL parser. Claude Code stores conversations as newline-delimited JSON files — one line per message, with nested content blocks for text, tool calls, and thinking. Getting the parser right before touching any UI code was the single best decision of the sprint.

We spent roughly 6 hours on the parser alone. Every message has a `type` field (`user`, `assistant`, `system`, `summary`) and content blocks that can be `text`, `tool_use`, `tool_result`, `thinking`, or `image`. Some fields are optional. Timestamps are strings, not numbers. The `usage` object on assistant messages contains token counts across four categories.

Once the parser was solid, every downstream feature — search, export, analytics — was just a different view of the same data.

## Axum for the HTTP layer

We chose Axum because it's the thinnest Rust web framework that doesn't make you fight the type system. The entire HTTP layer is about 200 lines: serve the React SPA from embedded static files, expose `/api/sessions` for the list and `/api/sessions/:id` for detail, and a health check endpoint.

Memory-mapped file reading (`mmap`) let us parse JSONL files without copying them into heap memory. For a tool that scans hundreds of session files on startup, this matters — we measured 3x lower peak RSS compared to `std::fs::read_to_string`.

```rust
let mmap = unsafe { Mmap::map(&file)? };
let finder = memmem::Finder::new(b"\"type\"");
for line in mmap.split(|&b| b == b'\n') {
    if finder.find(line).is_some() {
        // only parse lines that look like messages
    }
}
```

The SIMD pre-filter (`memmem::Finder`) skips lines that can't possibly be message objects, which cuts parse time by roughly 40% on large session files.

## React with Virtuoso for long conversations

Some Claude Code sessions have 500+ messages. Rendering all of them at once is a non-starter. We used `react-virtuoso` to virtualize the message list — only DOM nodes visible in the viewport are rendered, with smooth scrolling for everything else.

Syntax highlighting uses `shiki` with lazy-loaded grammars. We highlight code blocks inside messages but skip the highlighting pass entirely for messages without triple-backtick fences. This shaved about 200ms off initial render for typical sessions.

## What we cut

The 48-hour constraint forced ruthless prioritization. We cut:

- **Full-text search** — shipped as a simple substring filter in v0.1, Tantivy integration came later
- **Analytics** — no charts, no cost tracking, just raw session browsing
- **Settings page** — hardcoded everything, including the port (47892)
- **Incremental parsing** — we re-parsed all files on every server restart; fine for ~100 sessions, painful for 1,000+

Every cut became a v0.2 or v0.3 feature. The key insight: none of these were needed for the core experience of "browse and read your Claude Code sessions."

## The binary distribution trick

We wanted `npx claude-view` to work on day one, which meant cross-compiling Rust for macOS ARM64, macOS Intel, Linux x86_64, and Linux ARM64. GitHub Actions builds all four targets on every tag push, uploads them as release assets, and the npm wrapper downloads the right one at runtime.

Total binary size: ~15MB. No runtime dependencies. No Docker. No Node.js runtime embedded.

## Takeaway

The 48-hour build taught us that developer tools benefit enormously from "parser first, UI second." If your data layer is solid, the frontend can iterate in minutes. If your data layer is wrong, every frontend change is debugging in disguise. We've carried that lesson through every subsequent version — get the data right, then make it look good.


--- blog/e2e-encrypted-sharing.mdx ---

---
title: "End-to-End Encrypted Sharing Without a Backend Database"
description: "How we built zero-knowledge conversation sharing using client-side encryption, Cloudflare R2, and a static SPA viewer."
date: 2026-02-25
author: claude-view team
---

You want to share a Claude Code conversation with a teammate. But the session contains API keys, internal architecture discussions, and code from a private repo. End-to-end encrypted sharing solves this: the server stores ciphertext it can never read, and the decryption key lives only in the URL you send.

Here's how we built zero-knowledge conversation sharing with client-side encryption and a static viewer SPA.

## The architecture

The sharing flow has four components:

1. **Rust server** (local) — serializes the session, generates a random key, encrypts with AES-256-GCM, uploads ciphertext
2. **Cloudflare Worker** (API at `api-share.claudeview.ai`) — receives encrypted blob, stores in R2, stores metadata in D1
3. **R2 bucket** — blob storage for encrypted session data
4. **Viewer SPA** (static site at `share.claudeview.ai`) — fetches the encrypted blob, decrypts in the browser, renders the conversation

The critical property: **the Worker never sees plaintext**. Encryption happens on the user's machine before the data leaves localhost. Decryption happens in the recipient's browser. The server is a dumb pipe for ciphertext.

## Why the URL fragment matters

When you share a session, the URL looks like:

```
https://share.claudeview.ai/s/abc123#key=base64encodedkey
```

The part after `#` is the **fragment identifier**. This is not a design accident — it's the security model. URL fragments are never sent to the server. When the viewer SPA loads at `share.claudeview.ai/s/abc123`, the web server receives a request for `/s/abc123` but never sees `#key=base64encodedkey`. The key exists only in the browser's address bar and JavaScript runtime.

Compare this to a query parameter (`?key=...`), which would be sent to the server in the HTTP request, logged in access logs, cached by CDNs, and visible to any network intermediary.

## The encryption details

Key generation uses the Web Crypto API (in Rust, via the `aes-gcm` crate on the server side):

- Generate a 256-bit random key
- Generate a 96-bit random nonce (IV)
- Encrypt the serialized session JSON with AES-256-GCM
- Prepend the 12-byte nonce to the ciphertext (the recipient needs it to decrypt)
- Base64url-encode the key for URL-safe embedding

AES-GCM provides both confidentiality and integrity — if anyone tampers with the ciphertext on R2, decryption fails with an authentication error rather than producing garbage output.

## No accounts needed

Viewers don't need an account, an API key, or even JavaScript beyond what the static SPA provides. Click the link, the SPA fetches the blob from the Worker API, extracts the nonce, decrypts with the key from the URL fragment, and renders. The entire viewer is a static site on Cloudflare Pages — no server-side processing, no session cookies, no tracking.

This was a deliberate constraint. Requiring accounts for viewers kills sharing adoption. The person you're sharing with might be a contractor, a friend helping you debug, or a Stack Overflow user. They shouldn't need to create an account to see a conversation.

## The trade-off: lose the link, lose the data

If the URL is lost — browser history cleared, Slack message deleted, no copy saved — the encrypted blob on R2 is permanently unrecoverable. There's no "forgot password" flow because there's no password. The key exists only in the URL fragment.

This is a feature, not a bug. The same property that prevents the server from reading your data also prevents anyone (including us) from recovering it. It's the same trade-off made by Firefox Send (RIP), Bitwarden Send, and PrivateBin. Users who need durability can bookmark the link or save it to a password manager.

## Expiration and cleanup

Shared sessions expire after a configurable TTL (default: 7 days). A scheduled Worker runs daily to delete expired blobs from R2 and metadata from D1. This bounds storage costs and limits the exposure window — even if a URL leaks, the ciphertext won't be there forever.

The D1 metadata table stores only: share ID, creation timestamp, expiration timestamp, and blob size. No session content, no user identifiers, no IP addresses.

## Takeaway

Zero-knowledge sharing is surprisingly straightforward to implement. The hard part isn't the cryptography — AES-GCM is well-understood and available in every platform's standard library. The hard part is resisting the urge to add features that break the security model. Account systems, server-side search, preview thumbnails — every "nice to have" either requires server-side decryption or leaks metadata. We chose to keep the server blind and let the URL fragment carry the trust.


--- blog/introducing-claude-view.mdx ---

---
title: Introducing claude-view
description: Monitor, orchestrate, and command your Claude Code sessions from a web dashboard or your phone.
date: 2026-02-28
author: claude-view team
---

Today we're launching **claude-view** — an open-source tool that brings Mission Control to your Claude Code workflows.

## What it is

claude-view monitors every Claude Code session on your machine in real time. It shows you what each agent is working on, how many tokens it's using, and how much it costs — all in one dashboard.

Run it with one command:

```bash
npx claude-view
```

No config. No signup. Your browser opens automatically at `http://localhost:47892`.

## Why we built it

As we started running multiple Claude Code agents simultaneously, we lost visibility. Which agent is working on what? Is that session still running or is it waiting for input? How much have I spent today?

Mission Control answers all of these questions — live.

## What you get

**Session browser** — every Claude Code session, past and present. Full-text search across all conversations. Filter by project, model, or date.

**Live dashboard** — real-time view of all running agents. Watch token counts tick up, see which tools are being called, monitor costs as they accumulate.

**Cost tracking** — per-session and aggregate costs with cache hit ratio. Know exactly where your tokens are going.

**AI Fluency Score** — a 0–100 metric that measures how effectively you collaborate with AI agents. Track your progress over time.

**Claude Code plugin** — ships as a native plugin (`claude plugin add @claude-view/plugin`) with 8 read-only tools, 3 skills (`/session-recap`, `/daily-cost`, `/standup`), and auto-start. Ask Claude "what did I work on last week?" and get a real answer.

## The mobile app (coming soon)

The next milestone is the mobile app — native iOS and Android. Monitor your agents from your phone, receive push notifications when agents need approval, and ship features from anywhere.

## Get started

```bash
npx claude-view
```

[Read the docs →](/docs/) · [GitHub →](https://github.com/tombelieber/claude-view)


--- blog/monitoring-multiple-ai-agents.mdx ---

---
title: "Monitoring Multiple AI Agents: The Problem Nobody Talks About"
description: "When you run 3-5 Claude Code agents simultaneously, you lose track of what each one is doing, how much it costs, and whether it needs your input."
date: 2026-02-14
author: claude-view team
---

You have three Claude Code agents running. One is refactoring your auth middleware. Another is writing integration tests. A third is fixing a CSS regression in a git worktree. You switch between terminal tabs trying to remember which is which. Monitoring multiple AI agents is the operational problem that emerges the moment you go from one agent to two.

## The three questions

Every developer running parallel agents asks the same three questions, constantly:

1. **What is each agent working on right now?** Not what you told it to do 20 minutes ago — what is it actually doing at this moment?
2. **How much have I spent?** Token costs accumulate silently. A long-running agent with low cache hit rates can burn through $5-10 before you notice.
3. **Does any agent need me?** Claude Code sometimes needs user approval for tool calls, or gets stuck and asks a clarifying question. If you don't see the prompt, the agent just waits indefinitely.

Existing tools don't solve this. Your terminal shows one session at a time. `tmux` panes give you parallel visibility but no aggregation — you're scanning raw output across four panes trying to mentally parse which agent is autonomous and which is blocked.

## State classification

The core abstraction we landed on is **session state classification**. Every running agent is in one of a few states:

- **Needs You** — the agent asked a question or is waiting for tool approval
- **Autonomous** — actively working, no human input needed
- **Idle** — process is alive but no recent activity
- **Done** — session ended, process exited

Classifying state sounds simple until you try to implement it. Claude Code doesn't expose a structured "I'm waiting for input" signal. We infer it from a combination of process liveness checks, JSONL tail watching, and message type analysis. If the last message is from the assistant and contains a question mark with no subsequent user message, it's likely in a "needs you" state.

Process liveness itself is tricky on macOS. We use `kill(pid, 0)` as the primary check (returns 0 if the process exists, regardless of signal delivery). But `sysinfo` on macOS doesn't reliably report process working directories or command lines, so we fall back to `lsof -a -p <pid> -d cwd -Fn` to get the actual cwd for project association.

## Cost tracking with cache awareness

Token costs aren't as simple as `input_tokens * price + output_tokens * price`. Claude's prompt caching creates three pricing tiers:

- **Cache creation** — tokens written to cache, billed at 1.25x the base input price
- **Cache read** — tokens read from an existing cache, billed at 0.1x the base price
- **No cache** — standard input pricing

A session with a 90% cache hit rate costs roughly 10x less per input token than one with 0% hits. Reporting raw token counts without cache breakdown is misleading — you'd think two sessions with the same token count cost the same, when one might be 8x cheaper.

We compute cost per session using the model's pricing table and the four usage fields that Claude Code logs on every assistant message: `input_tokens`, `output_tokens`, `cache_read_input_tokens`, and `cache_creation_input_tokens`.

## The Kanban layout

A flat list of sessions doesn't match how you think about parallel work. We added a Kanban view that groups sessions into swimlane columns — by project or by branch. This is the same spatial metaphor that Kubernetes dashboards use for pod distribution across nodes, or that Grafana uses for service health across clusters. The difference is that each card is an AI agent on your laptop, not a container in a data center.

The Kanban view makes the "what is each agent working on" question answerable at a glance. Your API project column has two agents — one is green (autonomous), one is yellow (needs you). Your frontend column has one agent, and it's done.

## Why this matters now

The trend toward multi-agent workflows is accelerating. Today it's 3-5 agents. Next year it might be 10-20, working across repos, branches, and even machines. The monitoring problem doesn't scale linearly — it scales combinatorially. Every new agent multiplies the state you need to track.

We built claude-view's Mission Control specifically for this problem. But regardless of the tooling you use, the pattern is clear: once you run more than one AI agent, you need the same observability infrastructure that DevOps teams built for distributed systems. Dashboards, state classification, cost aggregation, and alerting. The only difference is that your "cluster" is a set of AI processes on your dev machine.


--- blog/session-browser-to-mission-control.mdx ---

---
title: "From Session Browser to Mission Control: Evolving a Developer Tool"
description: "How claude-view evolved from a simple JSONL viewer into a real-time multi-agent monitoring dashboard in 25 days."
date: 2026-02-19
author: claude-view team
---

claude-view started as a weekend project to browse Claude Code sessions. Twenty-five days later it was a real-time multi-agent monitoring dashboard. The evolution from session browser to Mission Control wasn't planned — each phase was driven by a pain point that made the previous version insufficient.

## Phase 1: Session browser (days 1-2)

The original problem was simple: Claude Code stores conversations as JSONL files in `~/.claude/projects/`, but there's no way to browse them. You can `cat` the files, but they're raw JSON with nested content blocks and base64-encoded images. We built a session list, a message viewer with syntax highlighting, and HTML export. That was v0.1.

The architecture was minimal — Rust reads JSONL files on startup, serves a React SPA from embedded static assets, exposes two API endpoints. No database, no indexing, no background processes.

## Phase 2: Search and analytics (days 3-8)

Once you have 200+ sessions, you need search. Substring matching on in-memory data worked for a week, then we hit sessions with 1,000+ messages and search took 800ms. We integrated Tantivy, a Rust full-text search engine (think Lucene but without the JVM), and got query times under 5ms.

Analytics came from the same data. Every assistant message includes token usage — `input_tokens`, `output_tokens`, `cache_read_input_tokens`, `cache_creation_input_tokens`. Aggregate those across sessions and you have cost tracking. Plot them over time and you have trend charts. The data was always there; we just started computing over it.

The architecture gained SQLite for persistent metadata and Tantivy for the search index. Both rebuild from JSONL source files on startup if the schema version changes.

## Phase 3: Git integration (days 9-14)

A natural question after browsing sessions: "What did this session actually produce?" We added git log scanning to link sessions with commits by timestamp correlation. If a commit happened during or shortly after a session in the same project directory, it's associated with that session.

This phase also added contribution analysis — what percentage of your git output involved AI assistance, broken down by project and time period. The data model expanded from "conversations" to "conversations + their real-world outputs."

## Phase 4: Live monitoring (days 15-22)

This was the inflection point. Everything before this was historical — browsing past sessions, analyzing completed work. Live monitoring meant watching active sessions in real time.

The technical jump was significant. We added:

- **Process discovery** — scanning the process table for running Claude Code instances, associating them with project directories via `lsof`
- **JSONL tail watching** — using `notify` (inotify/kqueue) to detect new messages as they're written
- **Server-Sent Events** — pushing session state updates to the browser in real time
- **Session state classification** — inferring whether each agent is autonomous, waiting for input, or done

The architecture went from request-response to event-driven. SSE streams replaced polling. A background task continuously monitors process liveness and file changes, broadcasting state transitions to connected clients.

## Phase 5: Plugin and relay (days 23-25)

Two extensions emerged from the monitoring work. The Claude Code plugin (`@claude-view/plugin`) exposes session data as MCP tools — so Claude itself can answer "what did I work on today?" by querying its own session history. The WebSocket relay enables the mobile app to receive live updates from the local server without port forwarding.

## The key inflection

When live monitoring became the primary use case, we moved Mission Control to the home page. Session history became a secondary view, accessible from the sidebar. This was a product decision driven by usage: we opened claude-view 10x more often to check on running agents than to browse past conversations.

## What the evolution taught us

Every architecture decision from Phase 1 became either a foundation or a liability in Phase 4. mmap-based JSONL parsing (foundation) — same code reads historical and live files. Embedded static assets (foundation) — one binary, no build step for users. No database (liability) — had to add SQLite when in-memory data didn't scale. No real-time layer (liability) — had to add SSE and background workers.

The lesson: if your tool reads data that changes over time, build the real-time path early. Retrofitting event-driven architecture onto a request-response system is possible but expensive. We did it in 7 days; starting with SSE from day 1 would have saved 3 of those days.


--- blog/v0-10-0-kanban-and-polish.mdx ---

---
title: "Managing Multiple AI Agents: Why We Built the Kanban View"
description: When you're running 3-5 Claude Code agents at once, a flat list doesn't cut it. v0.10.0 adds Kanban swimlanes, cost popovers, worktree drift detection, and more.
date: 2026-03-08
author: claude-view team
---

You're running five Claude Code agents. One is refactoring auth in your API server. Another is writing tests for the frontend. A third is debugging a migration in a git worktree. You glance at your session list and see... five rows. No grouping, no spatial context. Which agent belongs to which project?

A flat list doesn't match how you think about parallel work. **v0.10.0 fixes that.**

## Kanban swimlanes

The live dashboard now supports a Kanban view that groups running sessions into swimlane columns by project or branch. Instead of scanning a list and mentally sorting "this one is my API repo, that one is frontend," you see it at a glance — each column is a project, and the sessions within it are the agents working in that context.

A **group-by dropdown** lets you switch perspectives instantly. Group by project to see workload distribution across repos. Group by branch to track feature work across worktrees. The view you need depends on the question you're asking, so we let you switch without losing state.

This matters most when you're running agents across 3+ projects simultaneously. The spatial layout gives you the same kind of overview a physical Kanban board gives a team — except each card is an AI agent doing real work.

## Cost and token breakdown popover

Hover any session card — in the Kanban view or the list view — and a popover shows the full cost breakdown: input tokens, output tokens, cache read vs. cache creation, and the dollar cost per category. No more navigating into a session detail page just to check if an agent is burning through your budget.

This is especially useful in the Kanban layout. You can scan across projects and quickly spot which project's agents are the most expensive.

## Worktree branch drift detection

If you use git worktrees to run agents on separate branches simultaneously, you've probably hit this: an agent starts on `feat/auth`, but somewhere during its work the worktree's HEAD drifts to a different branch. Maybe a rebase went wrong, maybe another tool switched it.

claude-view now detects when a worktree's current branch doesn't match the branch it was on when the session started. You'll see a visual indicator on the session card so you can intervene before the agent commits to the wrong branch.

## Hook event tracking

Claude Code hooks — pre/post-tool scripts that run alongside your agent — now get full visibility in the dashboard. You can see which hooks fired, when they ran, and whether they succeeded or failed. When an agent's behavior looks off, check the hook log before digging into the conversation.

## Bulk select and archive

Session history grows fast when you're running multiple agents daily. You can now select multiple sessions and archive them in bulk. Shift-click for ranges, checkbox for individual picks. Keeps your history manageable without deleting anything — archived sessions are still searchable.

## Crash recovery

The sidecar process that bridges Claude Code sessions to the dashboard now auto-recovers from crashes. If the sidecar dies — OOM, signal, panic — it restarts and reconnects to all active sessions without losing data. You shouldn't have to babysit the tool that's supposed to help you babysit your agents.

## Zero-config local mode

This has always been a goal, but worth restating: `npx claude-view` works with zero environment files, zero signup, zero configuration. The server starts, your browser opens, and you see your sessions. Every cloud feature (sharing, auth, sync) is additive — the core experience is fully local and fully free.

## Update now

```bash
npx claude-view@latest
```

If you're already running claude-view, that's all you need. The Kanban view is available immediately in the live dashboard.

[Full changelog on GitHub](https://github.com/tombelieber/claude-view/releases) · [Read the docs](/docs/)


--- blog/v0-11-2-plans-prompts-teams.mdx ---

---
title: "Plan Tabs, Prompt History, and Team Dashboards"
description: "v0.11.2 brings Claude Code plans, full-text prompt search, and dedicated team intelligence views."
date: 2026-03-08
author: claude-view team
---

Three features that complete the visibility picture: plans you wrote, prompts you sent, and teams you're part of. Together, they answer questions you've never been able to answer before.

## Plan browser

Every session starts with a prompt to Claude Code. That prompt often references a plan — a design doc, an architecture decision, a spec you wrote to guide the conversation.

Before v0.11.2, finding that plan meant digging through `~/.claude/plans/` manually. Now, plans are indexed, linked to sessions by slug, and browsable directly in the session detail panel.

Click the new **Plans** tab in any session, and you see:

- All plans referenced by that session
- Plan file contents with syntax highlighting
- Links to jump between related sessions and plans
- Full-text search across all your plans

This is especially useful for Mission Control sessions, where you may reference multiple phases of the same long-running plan. See the whole context without leaving claude-view.

## Prompt history

You've sent thousands of prompts to Claude Code. Each one is stored in `~/.claude/prompts/`. But without a way to search them, they're effectively invisible.

v0.11.2 adds a **Prompt History** view with:

- **Full-text search** on the display content you saw
- **Intent classification** — automatically labels prompts as "feature", "debug", "refactor", "review", etc.
- **Template clustering** — uses Drain clustering to group similar prompts and detect patterns
- **Statistics** — leaderboards of your top prompt templates, intents, and usage over time
- **Copy to new session** — find a prompt that worked well and reuse it

The intent classification and template detection happen automatically as prompts are indexed. No configuration needed. The search index is built in Tantivy (the same engine behind Quickwit), so even with 10k+ prompts, searches are instant.

This is powerful for learning: you can see patterns in how you prompt Claude Code. You can identify which prompt structures lead to better outcomes. You can spot when you're repeating yourself and find better ways to phrase things.

## Team dashboards

If you're a team lead in Claude Code, you've seen the magic: spawn a sub-agent, give it a task, and watch it work. But visibility into what your team members are doing — which agents they spawned, what tasks they're running, which files are changing — has been scattered.

v0.11.2 adds a **Teams** page that shows:

- **Team members** — all agents in your teams config
- **Inbox** — messages from agents, team leads, and system notifications
- **Tasks** — tasks spawned across all team members, with status and duration
- **File changes** — which files are being read, edited, created across team sessions

It reads from `~/.claude/teams/` configs and the inbox files automatically. No manual setup. Click any team member to drill into their sessions, or click any task to see the full context.

## Under the hood

The Plan Tab feature required:

- A new plan_files module in Rust to parse `~/.claude/plans/` directory structure
- A slug field on every session (extracted from JSONL, stored in database)
- API endpoints to fetch plans and link them to sessions
- React components with lazy loading so opening a session with 50 plans doesn't tank performance

The Prompt History feature added:

- A complete JSONL parser for the prompt history format
- Tantivy indexing on prompts with configurable filters (display, paste, clipboard)
- Drain clustering algorithm for template detection
- Intent classification via regex patterns + SIMD pre-filter

The Teams Dashboard feature wired:

- A new teams parser that reads config files + inbox JSONL
- API endpoints for team list, detail, and inbox
- React hooks for team queries and real-time updates
- Full TypeScript type generation via ts-rs

All three features share the same architectural philosophy: **index once, query many times**. Plans, prompts, and teams are indexed on startup, then served via fast APIs. Changes are detected and reindexed in the background.

## What's next

- **Mobile team integration** — Expo app will show teams and tasks alongside live sessions
- **Custom session layouts** — drag-and-drop column resizing for the live monitor
- **Codex verification protocols** — statistical verification of parsed data across historical and live sessions

## Update now

```bash
npx claude-view@latest
```

Open the Plans tab on an old session. Search your prompt history. Check the Teams page to see what your agents are up to.



--- blog/v0-12-0-plugin-manager.mdx ---

---
title: "Visual Plugin Management for Claude Code"
description: "v0.12.0 brings a full Plugin Manager to claude-view — browse, install, enable, disable, and uninstall Claude Code plugins without touching the terminal."
date: 2026-03-09
author: claude-view team
---

Claude Code's plugin system is powerful. But managing plugins has meant memorizing CLI commands, remembering scope flags, and parsing terminal output. v0.12.0 changes that with a dedicated Plugin Manager page in the browser.

## The problem with CLI-only plugin management

If you wanted to see what plugins you had installed, you ran `claude plugin list`. To install one, `claude plugin install <name> --scope user`. To disable it for a single project, `claude plugin disable <name> --scope project`. Every action was a terminal round-trip, and forgetting the `--scope` flag meant operating on the wrong level.

Worse, there was no overview. No way to see at a glance which plugins were active, which were disabled, or which scope each one was installed at. You had to hold that state in your head.

## Plugin Manager page

Open claude-view and navigate to the new **Plugins** page. You see:

- **Health banner** at the top showing overall plugin system status
- **Card grid** of every installed plugin, each displaying name, description, version, scope (user or project), and enabled state
- **Search bar** with debounced filtering to find plugins instantly across large collections
- **Action menu** on each card for enable, disable, and uninstall operations

The card layout gives you the same information density as `claude plugin list` but in a format you can scan in seconds rather than parse line by line.

## Marketplace and installation

Click **Browse Marketplace** to open the marketplace dialog. It lists available plugins you haven't installed yet. Each entry shows the plugin name and description.

When you click install, a **scope picker** appears. Choose user-level (applies everywhere) or project-level (applies only to the current project). The choice is explicit and visible, no more guessing which flag to pass.

After installation, the plugin card appears in your grid immediately. No page refresh needed.

## Scoped actions that actually work

This was a subtle but critical fix. In earlier builds, scope forwarding only worked for the install action. Enabling, disabling, and uninstalling a project-scoped plugin silently operated at the user level, creating confusing states where a plugin appeared disabled but kept running in a project.

v0.12.0 forwards the scope parameter for every action. Disable a project-scoped plugin and it disables at the project scope. Uninstall it and it uninstalls from the project. The behavior matches what you see on the card.

## Under the hood

The Plugin Manager is built on the same architectural pattern as the rest of claude-view: the Rust backend does the heavy lifting, the React frontend renders it.

**Server-side caching.** The backend calls `claude plugin list` and caches the parsed output with a 5-minute TTL using the CachedUpstream pattern. Opening the Plugins page doesn't shell out to the CLI every time. The cache invalidates automatically on any mutation (install, enable, disable, uninstall).

**ANSI stripping.** The `claude` CLI outputs colored text with ANSI escape codes. The server sets `NO_COLOR=1` on the subprocess environment and strips any remaining escape sequences as a safety net. Browser toast messages and error dialogs render clean text, not garbled control characters.

**Type safety.** Plugin response types are defined as Rust structs with `#[derive(TS)]`, generating TypeScript types automatically. The frontend imports from `types/generated/` and never hand-writes API response shapes. When the backend adds a field, the frontend type updates on the next build.

**Scope forwarding.** Every plugin mutation endpoint accepts a `scope` parameter. The backend passes it directly to the `claude plugin <action> --scope <value>` subprocess call. No action silently defaults to user scope.

## Also in this release

- **Mobile:** Expo SDK 55 compatibility with updated react-native-screens and expo-router. Push notifications are platform-gated so they compile cleanly on web. EAS build artifacts are properly gitignored.
- **Registry:** New `invocables_for_plugin` method for querying which tools a specific plugin provides.

## What's next

- **Plugin usage analytics** — track which plugins fire most often and in which sessions
- **Mobile plugin management** — view and toggle plugins from the Expo native app
- **Plugin dependency graph** — visualize which plugins depend on each other

## Update now

```bash
npx claude-view@latest
```

Open the Plugins page from the sidebar. See every plugin you have installed. Try disabling one, then re-enabling it. Browse the marketplace and install something new.


--- blog/v0-12-1-project-scoped-plugin-fix.mdx ---

---
title: "Fixing Project-Scoped Plugin Actions"
description: "v0.12.1 fixes a silent failure where project-scoped plugin operations (uninstall, enable, disable) didn't pass the correct working directory to the CLI subprocess."
date: 2026-03-09
author: claude-view team
---

v0.12.0 shipped a full Plugin Manager. But if you had plugins installed at the project scope, some actions failed silently. v0.12.1 fixes this by wiring `projectPath` through the entire stack.

## The bug

Claude Code's CLI enforces a rule for project-scoped plugins: the subprocess must run from the directory where the plugin was originally installed. If you installed a plugin with `--scope project` in `/Users/me/my-project`, uninstalling it requires CWD to be that same path. Without it, the CLI returns an error.

The Plugin Manager's backend had the project path in the `installed_plugins.json` data, but it never passed it forward. The path stopped at the Rust struct and never made it to the API response, the TypeScript types, the React components, or back to the CLI subprocess. The UI showed a toast error, but the root cause was invisible.

## The fix

Full-stack wiring of `projectPath`, traced end-to-end:

1. **Rust struct** — Added `project_path: Option<String>` to `CliInstalledPlugin` and `PluginInfo`
2. **API response** — `project_path` serializes as `projectPath` in JSON (matching the `#[derive(TS)]` convention)
3. **Generated types** — `PluginInfo.projectPath: string | null` auto-generated from the Rust struct
4. **React components** — `PluginActionMenu` and `PluginCard` pass `plugin.projectPath` through the `onAction` callback
5. **Mutation hook** — `usePluginMutations` sends `projectPath` in the POST body to `/api/plugins/action`
6. **Backend handler** — Sets `Command::current_dir()` on the subprocess when `projectPath` is present

The "Update All" button also needed fixing — it was missing `projectPath` in its mutation call, so bulk updates would fail for project-scoped plugins.

## Scope flag behavior

While debugging, we discovered that the `--scope` flag only applies to two CLI actions:

- **install** — tells the CLI where to install (user or project)
- **uninstall** — tells the CLI which scope to remove from

For **enable** and **disable**, the CLI auto-detects scope. Passing `--scope` to these actions is harmless but unnecessary. v0.12.1 now only adds `--scope` for install and uninstall, matching the CLI's actual contract.

## E2E test guard

This class of bug — full-stack wiring gaps where a field exists at one layer but not the next — is hard to catch with unit tests. Each layer passes its own tests because missing an optional field doesn't cause an error. The failure only surfaces when a real user clicks a button.

To guard against regressions, v0.12.1 adds 26 Playwright E2E tests for the Plugins page:

- **API contract** — Response shape, field presence, query param filtering, error responses
- **Search & filters** — Debounced search, scope dropdown, kind tabs, active styling
- **Card interactions** — Expand/collapse, marketplace display, disabled state
- **Action menu** — Opens correctly, uninstall confirmation dialog, click doesn't propagate to card
- **Health banner** — Visibility matches API data (duplicate count, unused count, CLI errors)
- **Accessibility** — Keyboard navigation with Enter/Space, focus management

Tests are resilient to different plugin configurations — they skip gracefully when no plugins are installed, so they pass on CI machines without a local Claude CLI.

## Update now

```bash
npx claude-view@latest
```

If you have project-scoped plugins, open the Plugins page and try disabling or uninstalling one. It should work correctly now regardless of scope.


--- blog/v0-13-0-workflows-and-live-chat.mdx ---

---
title: "Workflows: Build Multi-Stage AI Pipelines from a Chat"
description: "v0.13.0 introduces a workflow system where you describe a pipeline in natural language and watch it render as a live Mermaid diagram, plus unified live chat and recently closed sessions."
date: 2026-03-11
author: claude-view team
---

What if you could describe a multi-stage process in plain English and have it turn into an executable pipeline — while you watch? That's the idea behind Workflows, the headline feature in v0.13.0.

## Designing pipelines through conversation

The Workflows page is a new section in the sidebar. Open it and you see a library grid of your saved workflows. Create a new one, and you land in a detail view with a familiar VS Code-style layout: resizable panels, a tab strip, and a chat rail on the right.

The chat rail is where it gets interesting. Describe what you want — "polish this implementation plan by checking each step against the codebase, then rewrite unclear steps" — and the LLM streams back a YAML workflow definition in real time. As it writes, the Mermaid diagram in the preview tab updates live. You see your pipeline take shape as a directed graph while the AI is still generating it.

Two chat modes let you shape the workflow iteratively. **Control mode** modifies the workflow definition directly. **Review mode** critiques the current definition and suggests improvements without changing it. Switch between them as you refine the pipeline.

## Running workflows

The runner tab shows your workflow as stage columns, similar to a kanban board turned sideways. Each stage has attempt cards that track execution state: pending, running, succeeded, failed. A progress bar across the top shows overall completion.

Under the hood, the Node.js sidecar process handles execution. Each stage runs in sequence with gate polling — the runner checks whether the previous stage's output satisfies the next stage's preconditions before proceeding. If a stage crashes, the runner recovers automatically: it detects the failure, logs the crash context, and can retry the stage without losing progress on earlier stages.

Two built-in workflows ship with v0.13.0: **Plan Polisher** (reviews and tightens implementation plans) and **Plan Executor** (runs plan steps sequentially with verification). Both are stored as YAML files and can be forked or edited.

## Unified live chat

Before v0.13.0, watching a live session meant seeing only real-time messages as they arrived. If you opened the live monitor after a session had been running for a while, you missed everything that happened before.

Now the live session view loads the full message history first, then appends real-time messages seamlessly below. One continuous scroll view, no tab switching, no "load earlier messages" button. History and live events merge into a single conversation stream.

## Recently closed sessions

Sessions used to disappear from the Live Monitor the moment they ended. If you stepped away for five minutes and came back, you'd have no idea which sessions had just finished or what they accomplished.

The Live Monitor now has a "Recently Closed" section. When a session's process exits, the session moves from the active list to the recently closed list with a timestamp. You can dismiss individual sessions or clear the entire section. The closed state persists in SQLite, so recently closed sessions survive server restarts.

## Everything else

- **Dynamic model list** — The model selector fetches available models from the backend, with full model IDs in tooltips
- **Queued message indicators** — Pending user messages show as faded bubbles with a "Queued" badge
- **Production hardening** — Six security and correctness fixes across the workflow endpoints

## Update now

```bash
npx claude-view@latest
```

Open the Workflows page to create your first pipeline. Try describing a process you run manually today and watch it become a diagram.


--- blog/v0-14-0-open-in-ide-and-mentions.mdx ---

---
title: "Open Files in Your Editor, See What Claude Referenced"
description: "v0.14.0 adds one-click Open in IDE from session views, @file mention chips on session cards, and a richer live chat experience with thinking blocks and a context gauge."
date: 2026-03-11
author: claude-view team
---

The gap between reading a Claude Code session and acting on it just got smaller. v0.14.0 introduces two features that connect what you see in claude-view to the work you do in your editor.

## Open in IDE

Claude Code sessions reference files constantly — edits, reads, searches, diffs. Until now, seeing a file referenced in a session meant manually navigating to it in your editor.

v0.14.0 adds an **Open in IDE button** wherever files appear: the Changes tab, individual file headers in the diff view, and the project headers in the Kanban live monitor. Click it and the file opens in your editor at the right path.

claude-view auto-detects which editors you have installed — VS Code, Cursor, Zed, and others. If you have more than one, it asks once and remembers. The detection runs locally against your installed applications; nothing is sent to a server.

The button is intentionally small and secondary — it doesn't get in the way of reading the session, but it's there when you want to act on something you see.

## @File mention chips

When Claude references a file using `@filename` notation, that mention is now extracted and displayed as a chip on the session card. You can see at a glance which files a session touched before you open it — useful for finding sessions that worked on a specific file, or for understanding what a long-running agent was doing.

Chips show abbreviated names to keep cards compact. Hover a chip to see the full path. The extraction runs at parse time, so mentions appear on both live sessions and historical ones without any extra work.

## Richer live chat

The live chat rail — which shows the streaming conversation between you and Claude during an active session — now renders the full structure of assistant responses:

- **Thinking blocks** are shown in a collapsible aside, so you can see Claude's reasoning without it dominating the view
- **Tool calls** show the function name and arguments with syntax highlighting
- **Tool results** are formatted and collapsible for long outputs

A **mode selector** at the top of the rail lets you switch between Control mode (direct commands) and Review mode (critique and suggestions). A **context gauge** shows what percentage of the current model's context window is in use — useful for knowing when you're approaching limits on a long session.

## Teams panel improvements

The teams panel now separates human team members from Claude sub-agents. Previously they were mixed together, which made it hard to see who was coordinating the session versus which agents were doing work. The new layout puts people and agents in distinct sections with clear labels.

## Update now

```bash
npx claude-view@latest
```

Open a session that references files and try the Open in IDE button. Check the session cards for @mention chips on your recent sessions.


--- blog/v0-15-0-unified-search-and-sidecar.mdx ---

---
title: "Search That Always Works, Teams That Survive Restarts"
description: "v0.15.0 ships a unified search engine with automatic fallback, a ground-up sidecar rewrite for Agent SDK v0.2.72, SSE-driven live data, and persistent team browsing via JSONL reconstruction."
date: 2026-03-12
author: claude-view team
---

Two problems that show up differently but have the same root cause: data that should be there isn't. v0.15.0 fixes both — for search and for teams.

## Search that finds what you're looking for

The previous search architecture had a gap. Tantivy's full-text index is fast and precise for keyword queries, but it only knows about sessions it has indexed. If you searched for something before indexing completed, or used a query that Tantivy couldn't tokenize well, you got nothing.

v0.15.0 introduces a unified search engine that never gives up empty-handed. The flow:

1. **SQLite pre-filter** — structured filters (project, date range, model) run first against the database to narrow the candidate session IDs
2. **Tantivy full-text** — runs against the pre-filtered set, returns ranked results with snippets
3. **ripgrep fallback** — if Tantivy returns 0 results, grep scans the JSONL files directly for substring matches

The fallback is automatic and transparent. Results from grep are labeled "Substring matches" so you know which engine answered — useful for understanding whether your query hit the full-text index or a literal match.

The frontend sends a single request to `/api/search`. It doesn't know or care which engine responded. This follows the project's one-endpoint principle: backend decides the strategy, frontend renders the result.

## The sidecar rewrite

The Node.js sidecar — which brokers communication between the Rust server and Claude Agent SDK sessions — has been rewritten from scratch for Agent SDK v0.2.72.

The old sidecar accumulated debt: a growing list of edge cases, a protocol that had evolved organically, and two bugs that caused real failures in production (a broken resume URL and a pipe deadlock that could freeze a session).

The new sidecar is built around four distinct modules:

- **Session registry** — a typed map of active sessions with sequenced event emission, so events always arrive in order
- **Permission handler** — routes `canUseTool` decisions with full context forwarded to the frontend, enabling per-tool approval UI
- **Event mapper** — a pure function that translates all 22 SDK message types to the new typed protocol (27 server events, 8 client messages), with no side effects
- **SDK session** — manages create/resume lifecycle with a long-lived stream loop and clean shutdown

The resume URL bug (wrong path) and pipe deadlock (read loop not draining stderr) are both fixed. Crash recovery now works reliably.

## SSE-driven live data

The live monitor previously fetched session state on a polling interval. Between polls, you could be looking at stale data — a session that had already ended, or a new session that hadn't appeared yet.

Live data now comes through server-sent events. The Rust server pushes updates as they happen. The browser receives them immediately. The polling loop is gone.

## Persistent team browsing

When you opened claude-view after a restart, team data was often missing. The live session store is in-memory, so anything that happened before the restart wasn't there. Teams showed as empty or incomplete until sessions were re-indexed.

v0.15.0 adds a JSONL fallback layer for teams. When the in-memory store is cold — either because the server just started or a session was closed — claude-view reconstructs team composition and message inbox directly from the JSONL files. The reconstruction is a single-pass scan per session, not a full re-index.

Teams now persist across server restarts. If you were in the middle of a multi-agent session last night, you can open claude-view this morning and still see the full team composition and message history.

## Update now

```bash
npx claude-view@latest
```

Run a search to see the unified engine in action. Start a multi-agent session, restart the server, and check whether the team is still there.


--- blog/v0-16-0-zero-config-cloud.mdx ---

---
title: "npx claude-view Just Works"
description: "v0.16.0 bakes prod URLs into the distributed binary so sharing and auth work out of the box — while self-hosted builds stay clean with no embedded config."
date: 2026-03-12
author: claude-view team
---

There's a tension in distributing a tool that has both local and cloud features. If you embed cloud URLs in the binary, self-hosters pick up config they didn't ask for. If you don't, `npx` users have to set env vars before anything cloud-related works.

v0.16.0 resolves this cleanly.

## Two binaries, one codebase

The distributed binary — the one you get via `npx claude-view@latest` or the install script — now has Supabase and relay URLs baked in at CI build time. Sharing works. Auth works. No configuration required.

The source build — `cargo build` from the repo — produces a binary with none of those URLs embedded. It's a clean slate. Cloud features activate only when you explicitly set the env vars:

```bash
export SUPABASE_URL=...
export SHARE_WORKER_URL=...
export SHARE_VIEWER_URL=...
cargo run --release
```

Same source. Different build contexts. The right defaults for each audience.

## How it works

The CI workflow injects the prod URLs as environment variables during the release build. Rust's `env!()` macro embeds them at compile time — they're baked into the binary, not loaded at runtime. No `.env` files, no dynamic resolution, no failure modes.

```rust
// In the binary: resolved at compile time
const SHARE_WORKER_URL: &str = env!("SHARE_WORKER_URL");
```

When the same code is built locally without those vars set, the `env!()` macro falls back to an empty string, and the server disables the feature. The `GET /api/config` endpoint tells the frontend which features are available, so the UI adapts automatically.

## Self-hosting is a first-class path

This change came from a real gap: the README didn't explain the distribution model clearly. Someone building from source would see sharing UI but get errors because the backend URLs weren't set — and have no idea why.

The README now has an explicit self-hosting section. It explains which env vars activate which features, what works with zero config (everything local), and what requires cloud setup (sharing, auth).

If you're running claude-view on your own machine with your own data, `cargo build && ./target/release/claude-view` gives you the full local experience — history browser, search, live monitor, analytics — with no cloud dependencies at all.

## Update now

```bash
npx claude-view@latest
```

If you're an npx user, sharing and auth now work without any setup. If you're self-hosting, the README has the full picture.


--- blog/v0-17-0-system-monitor.mdx ---

---
title: "See Your Machine While Your Agents Run"
description: "v0.17.0 adds a System Monitor page with live CPU, memory, and disk gauges — streamed via SSE with smooth animations, right alongside your Claude sessions."
date: 2026-03-12
author: claude-view team
---

When you're running several Claude agents in parallel, your machine is working hard. But until now, you had to switch to Activity Monitor or `htop` to see what was actually happening — breaking your flow every time you wanted to check if you were close to memory pressure or a CPU spike.

v0.17.0 adds a System Monitor page directly in the claude-view sidebar.

## What you see

Open the System Monitor from the sidebar and you get live gauges for:

- **CPU usage** — overall utilization, updated in real time
- **Memory** — used vs. available, so you can see when agents are pushing limits
- **Disk** — current read/write activity

Below the gauges is a **top processes list** — the most CPU-hungry processes on your machine, grouped by name and sorted live. You can see at a glance whether it's your Claude sessions, your IDE, or something else driving load.

## Smooth, not jumpy

Raw system metrics change every second and the numbers can jump around. A gauge that snaps from 23% to 67% in one frame is hard to track visually.

The monitor uses a rAF-based tween hook that interpolates values between readings. The gauge needle moves smoothly toward each new reading rather than teleporting. This is the same technique Activity Monitor uses — your eye can track a moving needle; it can't track a number that jumps.

Cards also animate in with a staggered reveal on first load — each one fades in slightly after the previous. It's a small detail, but it makes the page feel responsive rather than just appearing fully-formed.

## SSE, not polling

The system data streams from the Rust backend via server-sent events — the same mechanism as the live session monitor. The server pushes updates as they happen; the browser receives them without polling. No stale reads, no interval timers, no unnecessary requests.

`★ Insight ─────────────────────────────────────`
This is a natural extension of the SSE infrastructure already used for live sessions — once the server can push session events, pushing system metrics costs almost nothing architecturally.
`─────────────────────────────────────────────────`

Under the hood, the observer runs in a `spawn_blocking` task so the `std::thread::sleep` between readings never blocks the async runtime. This matters on macOS where the Tokio runtime is used for everything from HTTP to file I/O — a blocking sleep in the wrong place can stall unrelated requests.

## What's next

- Linux and Windows builds are next on the platform roadmap
- More monitor metrics: network I/O, per-session resource attribution
- Cost tracking improvements across multi-agent sessions

## Update now

```bash
npx claude-view@latest
```

Open the System Monitor from the sidebar while running a few agents. Watch what your machine does.


--- blog/v0-19-0-unified-model-catalog.mdx ---

---
title: "One Catalog for Every Model"
description: "v0.19.0 introduces a unified model catalog — a single source of truth for pricing, context windows, and capabilities across all Claude models."
date: 2026-03-14
author: claude-view team
---

Model metadata was scattered. Pricing lived in one file, context windows in another, display names in a third. When Anthropic shipped a new model, you had to update multiple places — and if you missed one, cost calculations silently drifted.

v0.19.0 consolidates everything into a **unified model catalog**.

## What changed

Every model now has a single entry that declares its pricing tiers, context window, capabilities, and display metadata. The catalog is the sole authority — cost calculations, model selectors, and insights all read from the same source.

This means:
- **Accurate cost tracking** for all Claude models, including cache pricing tiers
- **One place to update** when new models ship
- **Consistent metadata** across the dashboard, activity page, and session detail views

## Sidebar deduplication fix

A subtle bug: if you ran Claude Code sessions after starting the claude-view server, the sidebar could show the same project twice — once with 2 sessions, once with 1,296. The root cause was interesting.

The indexer resolves `git_root` (the repository root path) for each session so that worktree sessions group under their parent repo. But the resolution only used path pattern matching (`/.worktrees/` markers). Sessions at the actual repo root — the common case — got `None`. A startup backfill caught historical gaps via `git rev-parse`, but sessions indexed *after* the backfill ran accumulated with a missing `git_root`. The grouping query fell through to a sanitized project ID, creating a separate entry with the same display name.

The fix: call `git rev-parse --git-common-dir` inline during indexing when path-based inference returns nothing. One subprocess call per project, ~5ms. The startup backfill continues to handle historical data.

## Update now

```bash
npx claude-view@latest
```


--- blog/v0-2-0-security-and-ui-redesign.mdx ---

---
title: "Security First: Hardening claude-view Before Launch"
description: "v0.2.0 adds security hardening across CI, CORS, and error handling, plus a semantic card UI redesign for conversation browsing."
date: 2026-01-30
author: claude-view team
---

Most tools ship features first and patch security later. We did the opposite. Before adding a single analytics feature, v0.2.0 locks down the foundation.

## Why security before features

claude-view runs a local web server on your machine. It reads your Claude Code session files — full conversation histories, tool calls, code snippets. If the server leaks data through verbose error messages, accepts requests from any origin, or runs CI without dependency auditing, none of the features on top matter. You wouldn't trust a monitoring tool that's itself a liability.

## What we hardened

**CORS lockdown** — the Axum server now rejects cross-origin requests by default. Only `localhost` origins on the expected port are allowed. This prevents a malicious page in another tab from querying your session data through the local server.

**Error response sanitization** — before this release, server errors could leak internal paths, stack traces, and file system structure. Every error response now returns a generic message to the client while logging the full details server-side. Debugging stays easy; information disclosure stops.

**CI security pipeline** — every PR now runs `cargo deny` for dependency auditing and `cargo audit` for known vulnerabilities. Supply chain attacks against Rust crates are rare but not zero, and we'd rather catch them in CI than in production.

**Input validation** — query parameters and path segments are validated before they hit any handler. Malformed session IDs, path traversal attempts, and oversized payloads are rejected at the edge.

## Semantic card UI

The other half of v0.2.0 is a full UI redesign for conversation browsing. The old layout dumped raw messages into a scrolling list — functional but hard to scan.

The new design uses **semantic cards** that group messages by context. Each card shows the session's project, duration, model, and a preview of the first user message. You can scan 50 sessions and find the one you want in seconds instead of scrolling through raw transcript dumps.

Cards are interactive — click to expand into the full conversation view, hover for metadata. The visual hierarchy makes it obvious which sessions are long multi-turn conversations and which are quick one-shot questions.

## The philosophy

Ship safe defaults. A user who runs `npx claude-view` for the first time shouldn't need to think about CORS policies or error leakage. Those decisions are made for them, correctly, from day one. The 1% who need to customize can override — but the defaults protect everyone.

## Update now

```bash
npx claude-view@latest
```

Security isn't a feature you market. It's a foundation you build on.


--- blog/v0-21-0-single-stream-chat.mdx ---

---
title: "One Stream to Rule Them All"
description: "v0.21.0 replaces the dual-source chat merge with a single-stream architecture and adds native Linux keychain support."
date: 2026-03-16
author: claude-view team
---

Live chat in claude-view had an architectural debt: two data sources (replay from disk, live from WebSocket) merged in the frontend. When a session switched, stale state from the old session could bleed into the new one. Bugs were subtle — a message appearing twice, a conversation that wouldn't update, a connection that silently went dead.

v0.21.0 fixes this at the root.

## Single-stream architecture

The old model worked like this: the frontend fetched historical messages from the REST API and live messages from a WebSocket, then merged them by timestamp. This merge was fragile — race conditions between the two sources caused duplicate messages, ordering glitches, and stale conversations after session switches.

The new model is simpler. The WebSocket is the single source of truth. When you open a session, the sidecar replays the full conversation history through the WebSocket first, followed by live messages as they arrive. The frontend receives one ordered stream and renders it. No merge logic. No deduplication. No race conditions.

User messages now echo back through the WebSocket as `user_message_echo` events. Previously, user messages were injected client-side and could desync from the server's view. Now both sides agree on exactly what was said and when.

A `replayComplete` flag signals when historical replay ends and live streaming begins. The frontend uses this to suppress loading indicators at the right moment. And if you open the same session in a second tab, the first connection is closed with WebSocket code 4001 (`connection_replaced`) — no more phantom duplicate connections draining resources.

## Graceful buffer exhaustion

The sidecar maintains a replay buffer of recent messages. When the buffer is exhausted (the session history is larger than what's kept in memory), the old behavior was to fatally disconnect the WebSocket. The user saw a blank chat with no explanation.

Now the sidecar sends a `fatal=false` signal and keeps the connection open. The frontend knows it has a partial replay and can indicate this to the user rather than showing an error state.

## Linux credentials

claude-view reads your Claude authentication token to show subscription tier and enable authenticated features. On macOS, this reads from the system Keychain. Linux had no equivalent — the credential path simply returned `None`.

v0.21.0 adds a `secret-tool` backend that reads from GNOME Keyring via the Secret Service D-Bus API. If you're running GNOME, KDE, or any desktop environment with a Secret Service provider, your credentials are now picked up automatically. The lookup has a 3-second timeout to handle headless environments (no D-Bus session) without blocking startup.

The NPX path scanner was also made platform-universal — macOS-specific paths like `/opt/homebrew` are no longer tried on Linux, and universal paths are checked first on all platforms.

## Update now

```bash
npx claude-view@latest
```

Open a chat session and watch the single-stream replay. If you're on Linux, check that your subscription tier appears in the header — that means keychain integration is working.


--- blog/v0-23-0-context-gauge-and-shell-install.mdx ---

---
title: "Your Context Gauge Was Lying to You"
description: "v0.23.0 fixes inflated context usage percentages in live sessions and adds a zero-dependency shell installer."
date: 2026-03-19
author: claude-view team
---

If you've been watching a live Claude Code session in Claude View and noticed the context gauge climbing suspiciously fast — 84% when you'd barely started — it wasn't your imagination. It was a bug. v0.23.0 fixes it.

## The wrong number

The context gauge shows how full Claude's context window is. It's the single most important signal for long-running sessions: hit 100% and the model starts compacting your conversation, losing earlier context.

The bug: for live sessions, we were reading `modelUsage` from the SDK's `turn_complete` event and summing token counts across all models. This number looked right but measured the wrong thing. It was session-cumulative (total tokens used across all turns) rather than current fill (tokens in the context window right now).

The result was dramatic. A session 10 turns in might show 84% full, when the actual context window was only 12% utilized. Users seeing this would preemptively start new sessions or worry about context loss — both unnecessary.

## The fix: trust the source

Claude Code already knows exactly how full its context window is. Every few seconds, it writes a statusline JSON with the precise context window size, current usage, and pre-computed percentage. This data is authoritative — Claude Code computes it from the same state that drives its own compaction decisions.

The fix replaces the WS-derived calculation with a 4-tier priority chain:

1. **statuslineUsedPct** — Claude Code's own pre-computed percentage (most accurate)
2. **Live Monitor fill** — context window tokens from the statusline + authoritative denominator
3. **History fill** — JSONL accumulator data (correct semantics, used for non-live sessions)
4. **Nothing** — if we don't have authoritative data, we show a dash instead of a guess

The principle: never show a wrong number. A missing number is honest. A wrong number erodes trust.

## Shell install

Not everyone has Node.js installed. Not everyone wants to run `npx`. v0.23.0 adds a shell installer:

```bash
curl -fsSL https://get.claudeview.ai | sh
```

It detects your platform (macOS ARM or Intel), downloads the pre-built binary from the latest GitHub release, and places it in a sensible location on your PATH. No runtime dependencies. No package manager. One command, working binary.

The `npx claude-view@latest` path still works and remains the easiest way to stay up-to-date. The shell installer is for environments where Node.js isn't available or where you want a standalone binary.

## 49 new tests

This release also adds comprehensive test coverage for the chat lifecycle — the code path that handles live sessions, watching mode, SDK hooks, and message reconciliation. Seven features that shipped with zero tests now have unit tests, hook tests, component tests, and regression tests. The regression tests specifically guard the three bugs we've fixed in recent releases, ensuring they never come back.


--- blog/v0-24-0-multi-session-chat.mdx ---

---
title: "Multi-Session Chat and the Block Pipeline"
description: "v0.24.0 adds VSCode-style tabbed sessions, a Rust-native conversation block pipeline, and a finite state machine that makes chat panels deterministic."
date: 2026-03-24
author: claude-view team
---

If you run more than one Claude Code session at a time, v0.24.0 changes how you work with them. Instead of switching between the monitor sidebar and individual session views, you can now open sessions as tabs — drag them, split them, arrange them however makes sense for what you're doing.

## Tabbed sessions with dockview

The new chat page uses [dockview](https://dockview.dev) — the same layout engine that powers VS Code's editor panels. Each session opens in its own tab. You can:

- **Split horizontally or vertically** by dragging a tab to the edge of another panel
- **Rearrange tabs** by dragging between groups
- **Close sessions** from the tab context menu (Ctrl+W) or end the underlying Claude process
- **Persist layout** across page reloads — dockview's native `fromJSON`/`toJSON` handles this without React effects

The layout state includes which sessions are open, how panels are arranged, and which tab is active in each group. When you reload, everything comes back exactly as you left it.

## The block pipeline

Every Claude Code session is a JSONL file — one JSON object per line. Previous versions parsed this in TypeScript on the frontend, which meant duplicated parsing logic, inconsistent handling of edge cases, and no structural validation.

v0.24.0 introduces a **Rust-native BlockAccumulator** that transforms raw JSONL into typed `ConversationBlock` values:

- **UserBlock** — the human's message, with text content and optional parentUuid for threading
- **AssistantBlock** — thinking, text segments, and tool uses with correlated results
- **ProgressBlock** — bash output, MCP calls, agent spawns, hook events
- **TurnBoundaryBlock** — turn duration, token usage, model, cost, and stop reason
- **NoticeBlock** — rate limits, context compaction, API errors
- **SystemBlock** — session init, worktree state, file snapshots, queue operations

The accumulator is stateful — it correlates multi-line constructs. An assistant's `tool_use` on line 47 gets matched with the `tool_result` on line 52. Incremental entries with the same `message.id` merge into a single block. Turn boundaries assemble from `turn_duration` + `stop_hook_summary` + usage data across multiple lines.

This pipeline serves two paths:
1. **REST** — `GET /api/sessions/:id/messages?format=block` returns paginated `ConversationBlock[]`
2. **WebSocket** — terminal WS in `mode=block` streams blocks in real-time via the same accumulator

Both paths use the same Rust code, so parsing behavior is identical whether you're viewing a historical session or watching a live one.

## Finite state machine for chat panels

Each chat panel is driven by an FSM with three phases:

- **nobody** — no session loaded. Waiting for the user to select or create one.
- **acquiring** — connecting to the session, loading history, establishing WebSocket. Multiple sub-states handle the ordering: connect first, then fetch history, then switch to live streaming.
- **active** — session is loaded and interactive. Sub-states track turn status (idle, pending, streaming) and connection health.

Every transition is a pure function: `(currentState, event) → (nextState, commands)`. Commands are side effects (open WebSocket, fetch history, send message) that execute after the state update. This eliminates the class of bugs where a side effect reads stale state — the state is always updated before commands run.

The FSM solved 13 bugs in its first week, including: doubled assistant text during streaming, focus stolen from chat input by polling, frozen pages when history loaded before WebSocket connected, and missing thinking indicators during the gap between "connected" and "first assistant response."

## Developer mode

Every session now has a Chat/Developer toggle. Developer mode shows the same conversation as structured event cards:

- **ToolCard** — tool name, input, output, duration, and status in a collapsible card
- **EventCard** — session init, hook events, task progress, file snapshots, worktree state
- **CategoryFilterBar** — filter blocks by category (builtin, agent, MCP, hook)
- **ThinkingIndicator** — animated spinner verbs ("Thinking...", "Analyzing...", "Writing...") with lifecycle trail

This replaces the previous raw terminal view with something that's both more readable and more information-dense.

## Session source detection

Claude Code sessions can be launched from a terminal, an IDE (VS Code, Cursor, Windsurf), or the Agent SDK. v0.24.0 detects the source by inspecting the parent process tree at discovery time and displays a SourceBadge on every session card, sidebar entry, and detail panel.

This matters for the sidebar's urgency grouping — an IDE session waiting for permission approval is more urgent than a terminal session that's just idle.

## What else shipped

- Direct TCP sidecar connection on port 3001 (relay removed)
- Message threading with parentUuid indentation
- Share viewer migrated to ConversationThread
- Evidence audit handles new Claude CLI JSONL types (worktree-state, ai-title, forkedFrom)
- ~5,800 lines of deprecated code removed
- PII-check pre-commit hook

## Update

```bash
npx claude-view@latest
```


--- blog/v0-25-0-block-pipeline-polish.mdx ---

---
title: "Block Pipeline Polish and the Integrity Audit"
description: "v0.25.0 overhauls Developer Rich mode rendering, adds dedicated block renderers for sidechains and hooks, and introduces a full-stack integrity audit that catches type drift before it ships."
date: 2026-03-25
author: claude-view team
---

Developer mode was functional but noisy. Every block type — tool calls, agent spawns, hook events, retries — rendered through the same generic card. You could read the data, but scanning a 200-block trace required too much visual parsing. v0.25.0 gives each block type its own renderer and locks the whole pipeline down with an automated integrity audit.

## Purpose-built block renderers

The block pipeline now has dedicated renderers for block types that were previously handled by fallback cards:

- **Sidechain blocks** — agent-spawned sub-sessions now render with a nested card layout showing the parent-child relationship, sidechain status, and a collapsible execution trace
- **Image blocks** — inline image rendering with lazy loading, aspect ratio preservation, and a lightbox for full-size viewing
- **Hook metadata** — pre/post tool-use hooks display their timing, decision (allow/deny/modify), and the modified input when applicable
- **Retry events** — failed tool executions show the retry chain: original attempt, error, retry count, and final outcome in a single card

Each renderer is a single-file component following the one-component-per-file rule, with a corresponding Storybook story that exercises its variants.

## Developer Rich mode overhaul

The visual hierarchy in Developer Rich mode was flat — every card competed for attention equally. The overhaul introduces:

- **Semantic color coding** — tool results use the tool category's color (blue for builtin, purple for MCP, amber for agent), making it possible to scan by color rather than reading labels
- **Consistent spacing system** — all block cards now use the same padding, gap, and border-radius tokens from the design system, eliminating the visual noise from inconsistent spacing
- **Typography refinement** — monospace content (tool inputs, code blocks, raw JSON) uses a slightly smaller font size with increased line-height, giving more content per screen without sacrificing readability
- **Dark mode contrast** — 29 color classes that were hardcoded without `dark:` variants have been fixed, and the shared package's Tailwind `@source` directive now ensures cross-package components get scanned properly

## The integrity audit

The block pipeline spans four layers: Rust parser → generated TypeScript types → React components → Storybook stories. A new block type added in Rust but missing a React renderer is invisible to users. A type change in Rust that doesn't regenerate TS types causes a silent runtime mismatch.

`block-pipeline-audit.sh` validates the full stack:

1. **Type coverage** — every `ConversationBlock` variant in the Rust enum has a corresponding generated TS type
2. **Renderer coverage** — every TS block type has a React component that handles it (not a generic fallback)
3. **Story coverage** — every renderer has at least one Storybook story with realistic fixture data
4. **Dark mode coverage** — every color class in block renderer files has a `dark:` pair

The audit runs as a `/block-integrity` command and is wired into the pre-release pipeline. It catches the class of bug where parallel development — someone adds a Rust block type while someone else works on React components — creates a gap that only shows up when a user encounters that block type in production.

## Chat mode visual identity

Chat mode and Developer mode now have distinct visual identities. Previously, the only difference was content filtering — same colors, same typography, same layout. Now:

- Chat mode uses warmer tones with larger text and more generous spacing, optimized for reading conversations
- Developer mode uses cooler tones with denser layout, optimized for scanning execution traces

The distinction is subtle but makes mode-switching feel like moving between two purpose-built interfaces rather than toggling a filter.

## Update

```bash
npx claude-view@latest
```


--- blog/v0-26-0-session-monitoring-and-statusline.mdx ---

---
title: "Reliable Session Monitoring and Live Statusline Context"
description: "v0.26.0 hardens session lifecycle tracking with PID-based identity, streams Claude Code's statusline to the Live Monitor via SSE, and adds opt-in telemetry."
date: 2026-03-25
author: claude-view team
---

Session monitoring in claude-view relied on heuristics — matching processes to sessions by working directory and timing. It worked most of the time. But "most of the time" breaks down when you run three Claude Code instances in the same repo, or when a session restarts faster than the polling interval. v0.26.0 replaces heuristics with process IDs and closes five lifecycle gaps that caused phantom sessions, missed state transitions, and stale status badges.

## PID-based session identity

Previously, the Live Monitor matched sessions to processes by correlating the session's `cwd` with running `claude` processes. This breaks in common scenarios: monorepo developers running multiple agents in the same directory, sessions that restart between scan intervals, or worktree-based workflows where the same project appears at multiple paths.

Now, each session is identified by its process ID at creation time. The monitor reads the PID from the session's lock file and tracks it through the process lifecycle. When the process exits, the session transitions to its terminal state immediately — no polling delay, no heuristic matching, no ambiguity.

The five gaps this closes:

1. **Phantom sessions** — a crashed process left a stale lock file, so the monitor showed a "running" session with no process behind it. Now, PID existence is checked directly.
2. **Split identity** — a restarted session got assigned a new monitor entry instead of updating the existing one. PID continuity prevents this.
3. **Delayed transitions** — the gap between "process exited" and "monitor notices" was up to one scan interval (2s). Now it's event-driven.
4. **Cross-contamination** — two sessions in the same directory could swap identities when one exited and another started. PIDs are unique per session.
5. **Orphaned watchers** — file watchers for exited sessions weren't cleaned up, slowly leaking resources. PID-based lifecycle ties cleanup to process exit.

## Batch process scanning

The monitor used to call `ps` once per tracked session — if you had 20 sessions, that was 20 subprocess spawns every scan interval. On macOS, `ps` is fast, but 20 invocations every 2 seconds adds up, especially on laptops where CPU cycles directly translate to battery drain.

v0.26.0 collects all tracked PIDs and checks them in a single batch `ps` call. The process tree classifier — which determines whether a PID is a Claude Code session, a subprocess, or unrelated — now operates on the full process table in one pass. This reduces scan overhead from O(n) subprocess spawns to O(1).

## Live statusline via SSE

Claude Code has a statusline — the text at the bottom of the terminal that shows what the agent is currently doing: reading a file, running a command, thinking, waiting for permission. This information was only visible in the terminal where the session was running.

v0.26.0 broadcasts statusline updates to the Live Monitor via Server-Sent Events. The existing SSE connection that carries session state transitions now also carries statusline payloads. The chat panel receives this context too, so when you're chatting with an agent, you can see "Reading src/lib/auth.ts" or "Running tests" without switching to the terminal.

This is particularly useful for long-running agent sessions where you've backgrounded the terminal. Instead of switching back to check if the agent is stuck or making progress, the Live Monitor shows the current activity in real-time.

## Opt-in telemetry

v0.26.0 adds PostHog telemetry with a consent flow. On first launch, you're asked whether to opt in. The choice is persisted and can be changed in settings. If you opt in, claude-view reports anonymous usage events — which features are used, session counts, error rates — that help prioritize development.

The PostHog API key is baked into release builds at compile time, so telemetry works without any environment variables or configuration. If you opt out, no events are sent — the integration is fully gated on the consent flag, not just filtered server-side.

## Update

```bash
npx claude-view@latest
```


--- blog/v0-27-0-geist-fonts-and-agent-costs.mdx ---

---
title: "See What Your Agents Actually Cost"
description: "v0.27.0 adds per-agent cost breakdowns, collapsible agent groups, Geist fonts, and Apple HIG typography across the entire app."
date: 2026-03-26
author: claude-view team
---

When you run a Claude Code session with multiple subagents, the total cost is a single number. But which agent used the most tokens? Did the research agent burn through cache reads while the code agent racked up output tokens? Until now, you couldn't tell.

## Per-agent cost breakdown

The cost tooltip in the session header now expands into a full breakdown. Each subagent gets its own row showing the model it used, input tokens, output tokens, cache reads, and cache creation. If your session spawned eight agents across two models, you see all eight lines with their individual costs.

For sessions with many agents, the tooltip scrolls rather than overflowing off-screen. The model name sits next to each agent so you can immediately see whether a subagent ran on Opus or Sonnet.

This data comes from the Rust parser, which now tracks per-agent model and token usage on `SubAgentInfo` structs. The TypeScript types are auto-generated from Rust via ts-rs, so the frontend always stays in sync with the parser's capabilities.

## Collapsible agent groups

Conversations with nested agents can get long. A session that spawns an exploration agent, which spawns three sub-explorers, which each produce tool results — that's a lot of vertical space.

Agent groups are now collapsible. Click the group header to fold the entire subtree. The header shows a summary — agent name, model, and a content preview with JSON syntax coloring — so you can scan collapsed groups without expanding them. This makes it practical to review sessions with deep agent hierarchies without losing your scroll position.

## Geist fonts and Apple HIG type scale

We replaced Fira Sans and Fira Code with Geist Sans and Geist Mono. Geist was designed by Vercel specifically for developer tools — it's optimized for UI text at small sizes, with a monospace variant that has the same x-height as the proportional face.

Alongside the font swap, every font size in the app was normalized to the Apple Human Interface Guidelines type scale. This means consistent sizing from sidebar labels (13px) through body text (15px) to section headings (20px). The result is a calmer, more uniform visual hierarchy that reduces the feeling of information overload when scanning long sessions.

## Getting started

```bash
npx claude-view@latest
```


--- blog/v0-28-0-on-device-ai-for-session-intelligence.mdx ---

---
title: "On-Device AI for Session Intelligence"
description: "v0.28.0 brings local LLM phase classification, a component dashboard, and a polished settings experience to claude-view."
date: 2026-04-02
author: claude-view team
---

claude-view now runs an on-device LLM to classify what phase your coding sessions are in — no cloud calls, no latency, no cost. v0.28.0 also ships a component dashboard, a redesigned Harness view, and a settings page that finally feels finished.

## The problem with cloud-only classification

Phase classification tells you whether a session is exploring, building, debugging, or shipping. Previously, every classification call hit a remote model. That meant latency, cost, and GPU waste — especially for sessions that had settled into a stable phase and didn't need reclassification every few seconds.

For teams running dozens of concurrent sessions, the overhead added up fast.

## Local LLM with smart scheduling

v0.28.0 introduces on-device classification via oMLX. claude-view detects and manages the oMLX process automatically:

- **Auto-lifecycle**: detects the binary on your PATH, spawns it when you enable local AI, restarts on crash, and shuts down cleanly with SIGTERM on exit
- **Model switching**: a curated registry with RAM guard ensures you don't accidentally load a model that exceeds your available memory
- **Download UX**: HuggingFace multi-file downloads with resume support, cancel button, speed display, and ETA countdown
- **Smart drain loop**: exponential backoff with EMA stabilization reduces GPU usage by 93% — sessions that haven't changed don't waste compute

The classifier uses three modes: off, smart (only classifies when new activity arrives), and always. Smart mode is the default, and it's what most people should use.

## Component dashboard

The System Monitor now shows a component-level view instead of a single self-process row. Each component (sidecar, oMLX) gets its own metrics:

- **VRAM bar** with purple styling, distinct from CPU and RAM
- **Session count badge** showing how many sessions each sidecar is handling
- **Per-component CPU and RAM** via IOKit GPU memory FFI and sysinfo process introspection

## Harness v3

The Live Monitor's Harness view got a full redesign. The needs-you sidebar groups sessions by project and branch with collapsible headers, so you can focus on what matters. The main view uses Design/Delivery swimlanes to separate sessions by lifecycle stage.

## Settings that feel finished

The Settings page was functional but felt like a checklist. v0.28.0 adds feature scope labels (so you know what each setting affects), unified card headers, a GitHub star CTA, release notes link, build date in the About section, and improved UX for Mobile Pairing, Privacy, and Clear Cache.

## Under the hood

The biggest architectural change is the SessionCoordinator — a 4-phase mutation pipeline (lifecycle, statusline, reconcile, control) that replaces the monolithic manager. The 4337-line `manager.rs` was decomposed into 8 focused modules, each handling one concern.

The hook system expanded from 14 to 25 Claude Code events with explicit match arms for every event type. And the entire API surface is now exposed as 85 MCP tools via OpenAPI codegen, making it possible to build Claude Code plugins that talk to claude-view.

## What's next

- FSM unification: one state machine for all session views (chat, live, history)
- Scheduled task classification: classify sessions on a timer, not just on activity
- Mobile companion app for monitoring sessions on the go

## Update now

```bash
npx claude-view@latest
```

Enable on-device AI in Settings to try local phase classification. The smart drain loop means you won't even notice the GPU usage.


--- blog/v0-29-0-one-fsm-to-rule-them-all.mdx ---

---
title: "One FSM to Rule Them All"
description: "v0.29.0 unifies all session views on a single state machine, adds entrypoint badges, and introduces a local CI pipeline that catches bugs before they ship."
date: 2026-04-02
author: claude-view team
---

claude-view v0.29.0 ships the biggest architectural change since the block pipeline: every session view now runs on a single finite state machine. Plus, session cards tell you how each session started, and releases are now gated by a local CI pipeline that would have caught every bug from the last three versions.

## The problem with two architectures

Since v0.24.0, claude-view had two parallel paths for loading and displaying session data: a TanStack Query hook chain for history views, and a finite state machine for live sessions. Both fetched blocks, both managed pagination, both handled scroll anchoring — but they did it differently.

The result was predictable: bugs fixed in one path didn't get fixed in the other. Pagination worked in live view but broke in history. Scroll anchoring worked in history but drifted in live. Every fix was a game of whack-a-mole across two codebases that were supposed to do the same thing.

## One state machine, everywhere

v0.29.0 deletes the TanStack hook chain entirely (-5,841 lines) and runs every session view — history, live, watching — through the same FSM. One set of pagination logic. One scroll anchoring implementation. One place to fix bugs.

The migration surfaced a subtle issue that had been hiding for a month: Virtuoso's `onStartReached` callback was being passed as an inline anonymous function wrapped in a conditional ternary. This created a new function reference on every render, which silently broke Virtuoso's `firstItemIndex` scroll anchoring. The fix was straightforward — a stable `useCallback` passed unconditionally — but it could only be found by diffing the working consumer against the broken one.

## Entrypoint badges

Session history cards now show a badge indicating how each session was started: CLI, VS Code, SDK, or other entrypoints. When you're running a dozen sessions across different tools, knowing which ones came from your IDE vs. your terminal vs. an automated SDK script makes triage faster.

The entrypoint is parsed from the first line of each session's JSONL, where Claude Code writes the launch context. No additional configuration needed — it just appears on session cards.

## Local CI that actually catches things

Every release now passes through an 8-gate local CI pipeline before the version is bumped:

1. TypeScript lint, typecheck, and tests
2. Rust clippy (warnings as errors) and full workspace tests
3. Evidence audit (JSONL schema guard)
4. Storybook build (component compilation)
5. Integrity gates (parser/indexer replay with golden fixtures)

Previously, releases only ran an evidence audit and a Storybook build. The first run of the full pipeline on the existing codebase caught a missing struct field in the parser, a test assertion that assumed a specific OS error message, and 20 pre-existing test failures in components that had drifted from their implementations. GitHub Actions only handles cross-platform binary builds and npm publishing — quality gates run locally, where they're fast and you can fix things immediately.

## Under the hood

The agent name parser now handles `agent-name` JSONL entries, improving sub-agent identification in conversation views. A new baseline-to-parser sync guard catches evidence drift before it ships — if the parser's output no longer matches the golden baseline, the release is blocked.

The mobile app's biome configuration was also fixed to exclude generated files (CocoaPods specs, Tamagui config) that were causing false lint failures.

## What's next

- Fix the 20 pre-existing TypeScript test failures surfaced by the full CI pipeline
- Landing page refresh with the new changelog and blog content
- Session filtering by entrypoint type

## Update now

```bash
npx claude-view@latest
```

The FSM unification means fewer bugs in session views going forward. If you've been hitting pagination issues in history view, this release fixes them structurally.


--- blog/v0-3-0-git-integration.mdx ---

---
title: "Git Integration: Connecting AI Sessions to Your Codebase"
description: "v0.3.0 adds git integration and AI contribution tracking — see which commits your Claude Code agent helped produce."
date: 2026-02-09
author: claude-view team
---

You finish a Claude Code session. The agent wrote code, you reviewed it, ran tests, iterated. Then you `git commit`. A week later, looking at `git log`, there's no trace that an AI agent was involved. The commit looks like any other. The session that produced it is buried in `~/.claude/projects/`.

v0.3.0 bridges that gap.

## Session discovery follows your projects

claude-view now understands your project structure. Instead of dumping every session into a flat list, sessions are grouped by the project directory they were started in. Open a repo in Claude Code, and claude-view knows which sessions belong to that repo.

This is powered by parsing the JSONL session files, which encode the working directory. No configuration required — claude-view reads what Claude Code already writes.

## AI contribution tracking

The headline feature: claude-view now links Claude Code sessions to the git commits they produced.

When a session ends and commits exist in the repo's history that fall within the session's time window, claude-view attributes them. You can see, per-session, which commits were produced with AI assistance and what percentage of your recent work involved an agent.

**We chose to undercount rather than overcount.** A commit is only attributed to a session if the timing and working directory match. If you were coding manually in the same repo during a session, those commits won't be falsely attributed. Conservative attribution means the numbers you see are trustworthy — when claude-view says a commit was AI-assisted, it was.

This matters for teams thinking about AI adoption metrics. Inflated numbers breed skepticism. Provable-only attribution builds trust.

## How it works

```bash
npx claude-view
```

Navigate to any session and you'll see a "Commits" section showing linked git commits with their hashes, messages, and timestamps. The contribution tracking runs automatically — no git hooks to install, no config files to write.

Under the hood, claude-view shells out to `git log` with time-range filters scoped to the session's start and end timestamps. It cross-references the repo path from the session metadata with the actual git repository. If the paths don't match or no commits fall in the window, nothing is shown. No phantom data.

## Why this matters

AI-assisted development is becoming normal, but the tooling hasn't caught up. Your git history doesn't know about AI. Your project management tool doesn't know about AI. claude-view is the connective tissue — it links the AI work to the artifacts it produced.

## Update now

```bash
npx claude-view@latest
```

Your git history now has context. Every commit, every session, connected.


--- blog/v0-30-0-on-device-ai-and-hook-visibility.mdx ---

---
title: "On-Device AI, Hook Visibility, and Sub-Agent Pagination"
description: "v0.30.0 brings provider-agnostic local LLM settings, hook events rendered inline in conversations, and paginated sub-agent views."
date: 2026-04-05
author: claude-view team
---

This release focuses on three areas: giving you control over local AI providers, making hooks visible in your conversation timeline, and handling large sub-agent sessions gracefully.

## On-Device AI settings

If you're running a local LLM — whether through Ollama, LM Studio, or any OpenAI-compatible server — the settings experience just got a lot better.

The previous implementation was tightly coupled to oMLX, Apple's on-device framework. That worked for Apple Silicon users running specific models, but left everyone else out. v0.30.0 replaces this with a **provider-agnostic architecture**:

- **Model selector dropdown** — pick from detected models instead of typing slugs
- **Any OpenAI-compatible endpoint** — point it at `localhost:11434`, `localhost:1234`, or wherever your local inference runs
- **Redesigned settings card** — cleaner layout that makes connection status and model selection obvious at a glance

The underlying integration no longer manages processes for you. It connects to whatever you're already running and gets out of the way.

## Hook events in your conversation

Claude Code hooks — the `PreToolUse`, `PostToolUse`, and `Stop` handlers you configure in `settings.json` — have always run invisibly. You knew they fired because you saw their side effects (a linter ran, a file was formatted), but the hooks themselves didn't appear in your session timeline.

v0.30.0 renders hook events as **conversation blocks** alongside assistant messages, tool calls, and user input. Three delivery paths ensure you see them regardless of how you're viewing the session:

- **Live sessions** stream hook blocks over WebSocket in real time
- **Historical sessions** merge hook events from the database into the block timeline
- **JSONL replay** picks them up from the raw session file

This means when you scroll through a conversation, you can see exactly when your formatting hook ran, what it did, and how long it took — without checking terminal output separately.

## Sub-agent pagination

Sessions with sub-agents can generate hundreds of blocks. Previously, opening a sub-agent panel loaded every block at once — slow for long-running agents and unusable for agents that ran thousands of tool calls.

Sub-agent block views now paginate. Blocks load incrementally as you scroll, with the same stable scroll anchoring used in the main conversation view. This also fixed a bug where sub-agent WebSocket connections failed for historical sessions (99% of sessions), because the handler only checked live sessions instead of falling back through the full session lifecycle.

## Under the hood

- The sidecar had a memory problem: `listSessions()` spawned a full Claude CLI process on every call, consuming 900MB+ of RSS. Removed entirely — the sidecar now scans the filesystem directly.
- The Activity page moved from client-side aggregation to a dedicated `rich_activity()` database function. Faster queries, less data transferred, more accurate results.
- CLI plugin commands that produced more than 64KB of stdout were silently truncated due to a Node.js pipe buffering limit. Fixed by routing output through a temp file.
- Session mutations and the multiplexed WebSocket hook were centralized into shared modules, and pagination was extracted to the coordinator level so every session phase gets it automatically.

## What's next

- Phase classification confidence tuning — the ML classifier is approaching the precision threshold for production display
- Linux and Windows binary builds in the release pipeline
- Search across all sessions with the Tantivy full-text index

## Update now

```bash
npx claude-view@latest
```

Open your settings to try the new On-Device AI card, or check any session with hooks to see them rendered inline.


--- blog/v0-31-0-historical-conversation-blocks.mdx ---

---
title: "Complete Conversation Timelines for Every Session"
description: "v0.31.0 synthesizes Plan and Question blocks from historical JSONL data, giving you a complete visual timeline for any session — not just recent ones."
date: 2026-04-06
author: claude-view team
---

When you open an old Claude Code session in claude-view, you should see the same rich conversation timeline you get for live sessions. Until now, you didn't.

## The gap

claude-view renders conversations as a sequence of **InteractionBlocks** — visual units that represent Plans, Questions, tool calls, and responses. These blocks make it easy to scan a session at a glance: "here's where the agent planned, here's what it asked me, here's where it ran the tests."

The problem: Plan and Question blocks were only synthesized for sessions currently in memory. For any session that had ended — even from yesterday — those blocks were missing. You'd see a flat stream of tool calls and text, without the higher-level structure that makes sessions actually readable.

This wasn't a small gap. Plans and Questions are the *most* informative blocks in a session. They're where Claude explains what it's about to do and why. Losing them from historical sessions meant losing the narrative thread.

## What changed

v0.31.0 synthesizes InteractionBlocks from historical JSONL data during the indexing pass. When you open any session — from today or from three months ago — claude-view reconstructs the block structure from the raw event log.

The result: your full conversation timeline is complete, regardless of when the session happened. Plans appear where they were triggered. Questions appear where they were asked. The session reads like it did when it was live.

## Accurate cost estimates

A separate fix in this release plugs a caching issue that was silently skewing token cost estimates. A one-hour cache window was causing cost display to drift from actual usage — you might see costs from an hour ago presented as current. This is now resolved, and system message rendering gaps are also fixed.

## Dev reliability improvements

Four fixes landed for the development environment:

- **Crash-aware sidecar supervisor** — `node --watch` doesn't handle crashes gracefully. The new supervisor detects crashes and restarts cleanly.
- **Orchestrator script** — the 400-character inline `concurrently` command in the dev start script is replaced with a proper orchestrator. Easier to read, easier to debug.
- **Cleanup script** — `dev-cleanup.sh` now kills orphan processes, not just the ports they were using.
- **Sidecar ownership gate** — `CLAUDE_VIEW_SIDECAR_EXTERNAL` prevents the Rust server from spawning a second sidecar in dev mode. Previously, every `cargo watch` rebuild would kill the `tsx watch` process and replace it with a stale build, causing WebSocket failures that looked like FSM bugs.

These are internal improvements — they don't affect the installed `npx claude-view` experience, only the development workflow.

## What's next

- Deeper historical reconstruction — filling more block types from JSONL
- Improved cost breakdown by session phase
- Timeline scrubbing for long sessions

## Update now

```bash
npx claude-view@latest
```

Open any old session and check the timeline. Plans and Questions should now appear throughout.


--- blog/v0-32-0-complete-block-pipeline.mdx ---

---
title: "Every Session Event Is Now Visible"
description: "v0.32.0 closes the last gaps in claude-view's developer timeline: attachment changes, permission shifts, and scheduled task triggers are now rendered as first-class blocks."
date: 2026-04-06
author: claude-view team
---

When you're debugging a Claude Code session, the developer timeline in claude-view should show you *everything*. Until now, three categories of events were silently dropped: context attachment changes, permission mode shifts, and scheduled task triggers.

v0.32.0 closes all three gaps.

## What was missing

Claude Code emits structured events for a lot of things: tool calls, hook executions, agent spawns, session boundaries. But three event types were passing through the block pipeline and rendering as nothing:

**Attachment events** happen when files are added to or removed from Claude's context mid-session. If you're using `/add` to pull in a file, or if the agent's context window is being managed automatically, you'd see the downstream effects in the tool calls but not the context change itself.

**Permission mode changes** happen when a session transitions between permission levels — from the default mode that asks before running tools, to the more autonomous modes that don't. These transitions are meaningful for understanding *why* the agent behaved differently in different parts of a session.

**Scheduled task fires** happen when a scheduled Claude agent wakes up and starts work. The agent session would appear in the session list, but the trigger event — the moment something said "start now" — wasn't visible.

All three were parsed and typed in the pipeline but fell into the `default:` branch of the renderer with no output.

## The fix

Each event type now has a dedicated renderer:

- **Attachment blocks** show the file names added and removed, with additions in the default text color and removals in red — the same visual shorthand as a git diff.
- **Permission mode change blocks** show the new mode with an amber badge — a warm color that signals "something about how this session operates changed here."
- **Scheduled task fire blocks** show an orange "Scheduled" badge — distinct from permission changes but in the same warm range, since both represent configuration-level events rather than content events.

The compiler now enforces this completeness. The renderer switch statement ends with an exhaustiveness check: if a new `SystemVariant` is added to the type definition without a matching case, the code won't compile. The three missing events were caught by exactly this check — they were added to the type and the compiler flagged the missing renderer.

## Cleaner hook blocks

A separate fix in this release de-duplicates information in hook progress blocks. Previously, the event name and hook name appeared in both the block header (via the EventCard label) and the block body. They were being rendered twice.

The body now shows only what's unique to it: the status message and the command being executed. The header carries the full event→name context. For sessions with heavy hook activity — pre-tool validators, live monitors, post-tool loggers — this makes the timeline noticeably less noisy.

Long outputs are also no longer silently truncated. Hard `.slice()` caps on hook command output and stdout have been removed.

## What's next

- Timeline filtering by block type — filter to show only tool calls, only agent events, or only hook activity
- Cost breakdown by session phase — see where the expensive parts of a session happened
- Improved session replay for scheduled task sessions

## Update now

```bash
npx claude-view@latest
```

Open any session with hook activity or context management and check the developer timeline. The events that were invisible before should now be there.


--- blog/v0-33-0-teams-and-claude-integration.mdx ---

---
title: "Team Debates, Cost Tracking, and Your ~/.claude Directory"
description: "v0.33.0 brings team debate transcripts, per-member cost breakdowns, sub-agent sidechains, and full ~/.claude directory integration to claude-view."
date: 2026-04-07
author: claude-view team
---

If you're running multi-agent teams in Claude Code, you've probably wondered: "What are they actually saying to each other?" And more practically: "Which agent is burning through my tokens?" v0.33.0 answers both questions.

## Team debate transcripts

When Claude Code spawns a team of agents to debate a problem, the raw output is a wall of XML blocks scattered across JSONL lines. Reading it means scrolling through `<teammate-message>` tags, cross-referencing session IDs, and mentally reconstructing who said what.

v0.33.0 parses these debates into **clean conversation transcripts**. Each agent gets their own card. Moderator prompts are visually distinct from agent responses. Verdicts and round boundaries are marked clearly. It reads like a group chat, not a log file.

The design follows progressive disclosure. By default, you see the conversation flow — who argued what, what the moderator asked, what verdict was reached. Technical details (model names, token counts, tool calls) are behind an expandable section. A product manager can follow the debate. An engineer can drill into the execution details. Same page, different depths.

## Per-member cost breakdown

The Teams tab now shows **per-member cost and token usage**. Each team member card displays their total spend, and a crown icon marks the highest spender. This surfaces immediately when one agent is doing most of the heavy lifting while others are nearly idle — a common pattern when team configurations aren't balanced.

Cost breakdown is visible across all surfaces: the sidebar overview, the detail panel, and the team overview page. You don't have to navigate anywhere special to see where tokens are going.

## Sidechains

Teams spawn sub-agents — claude-view calls these **sidechains**. v0.33.0 adds a dedicated section for them: model info, timestamps, duration, and token usage per sidechain. Click any sidechain to drill into its full block view.

Sidechain data refreshes reactively via inbox versioning. When a team member spawns a new sub-agent, the UI updates immediately without polling. This is the same event-driven architecture we use across the live monitor — no `setInterval`, no stale data.

## ~/.claude integration

Your `~/.claude` directory contains your AI memory files, Claude Code settings, MCP server configs, active session metadata, and todo items. Until now, browsing these required terminal commands or a file manager.

v0.33.0 adds a **Memory page** with a 2-column layout: type-grouped memory files on the left, content preview on the right. Badges show counts per type (user, feedback, project, reference). The panel is resizable.

A separate **Settings page** surfaces your Claude Code configuration, MCP servers, active sessions, and todos. Everything is read-only — claude-view shows you what's there without modifying it.

## Sessions directory watcher

The live monitor now watches `~/.claude/projects/` for new session directories. When a new session appears on disk, it's picked up immediately — no restart, no manual refresh. The watcher also runs a startup scan to catch sessions created while claude-view wasn't running, and detects crash artifacts from sessions that didn't shut down cleanly.

## Update now

```bash
npx claude-view@latest
```

Open the Teams tab to see debate transcripts and cost breakdowns. Check the Memory page to browse your `~/.claude` directory from the dashboard.


--- blog/v0-34-0-cross-platform-terminals-webhooks.mdx ---

---
title: "Linux Support, Live Terminals, and Webhook Notifications"
description: "v0.34.0 brings native Linux builds, interactive xterm terminals for CLI sessions, webhook notifications with Slack/Lark support, and a complete session ownership model."
date: 2026-04-12
author: claude-view team
---

Three things that don't seem related until you think about what they have in common: watching your AI agents work from anywhere, on any machine, and getting notified when something interesting happens.

## Linux, finally

claude-view started as a macOS tool because that's where most Claude Code users live. But "most" isn't "all," and the workaround — setting `CLAUDE_VIEW_ALLOW_LINUX=1` and hoping for the best — wasn't a real answer.

v0.34.0 ships a native **linux-x64 binary** in every release. The CI pipeline now builds and tests on Linux alongside both Mac architectures. Under the hood, we replaced `node-pty` (which needed platform-specific native addons and caused ABI mismatch headaches) with Rust-native `portable-pty`. One fewer native dependency, one fewer class of install failures.

If you're running Claude Code on a Linux dev server or in WSL, `npx claude-view@latest` now just works.

## Interactive CLI terminals

When Claude Code spawns tmux sessions — for long-running builds, server processes, or interactive debugging — you previously had to switch to a terminal to see what was happening. Now those sessions render as **real xterm terminals** directly inside the Chat and Monitor pages.

Each terminal tab shows live output from the tmux session. A close button lets you manage tabs without switching contexts. The rendering is params-driven rather than creation-time config, which means terminal behavior updates dynamically as sessions change state.

This is particularly useful when an agent is running a dev server in one session while editing code in another. You see both streams side by side without leaving claude-view.

## Webhook notifications

You're running agents overnight. Maybe a batch of code reviews, maybe a long migration. You want to know when something finishes — or fails — without keeping a browser tab open.

v0.34.0 adds a **webhook notification API**:

- **CRUD management** — create, update, list, and delete webhook endpoints through the API
- **Slack and Lark formatters** — structured messages that render natively in your team's chat tool
- **HMAC-SHA256 signing** — every delivery is signed so you can verify it came from your claude-view instance
- **Automatic retry** — failed deliveries retry with exponential backoff
- **Test-send endpoint** — validate your webhook config before relying on it

The canonical payload format means you can also write custom formatters for any destination that accepts HTTP webhooks — Discord, Teams, PagerDuty, or a custom endpoint.

## Session ownership

The internal model for "who owns this session" got a complete rewrite. The old `LiveStatus` enum was a flat list of states that didn't capture the nuances of session lifecycle — is it running? Is it mine? Can I take it over?

The new `OwnershipTier` model answers these questions structurally:

- **pid.json** is now the single source of truth for live session detection
- Ownership resolution can find sessions by Claude session ID, not just local paths
- All UI components — session lists, sidebars, source badges, kanban boards — derive their state from ownership tier instead of maintaining parallel status tracking

This also enabled the **unified interaction UI**: plan approvals, permission prompts, and user questions now surface through a single card system. If an agent needs your input, you see it in one consistent place regardless of the interaction type.

## What's next

- **Windows support** — win32-x64 builds are defined in CI but not yet enabled
- **Mobile companion** — React Native app for monitoring agents on the go
- **Notification rules** — filter which events trigger webhooks based on project, severity, or event type

## Update now

```bash
npx claude-view@latest
```

Try opening a session that spawns a tmux process — you'll see the terminal tab appear automatically in the Chat page.


--- blog/v0-35-0-ownership-and-performance.mdx ---

---
title: "Session Ownership and a Leaner Binary"
description: "v0.35.0 adds computed session ownership, runtime configuration, and cuts the binary size in half."
date: 2026-04-12
author: claude-view team
---

If you run multiple Claude Code sessions — some spawned by the SDK, some inside tmux, some standalone — you've probably wondered which session belongs to what. v0.35.0 answers that question automatically.

## Session ownership, computed at the boundary

Every session now carries ownership metadata: is it SDK-spawned (a subagent of another session), tmux-managed (part of a terminal multiplexer group), or a standalone CLI session? Previously, this information was either unavailable or required you to trace process trees manually.

In v0.35.0, ownership is computed the moment a session enters the system — at both the REST API and SSE streaming boundaries. By the time a session appears in your dashboard, its ownership is already resolved. CLI sessions get eager resolution with automatic stale refresh, so tmux relationships appear the instant a session is discovered.

The ownership model itself was rewritten from a discriminated-union enum to an independent-facts struct. Instead of forcing every session into a single category, the system now records independent facts (has a tmux session ID, was spawned by SDK, has a parent session) and lets the UI compose them. This is more truthful — a session can be both SDK-spawned and tmux-managed.

## Half the binary, half the heap

Two changes cut resource usage significantly:

**The release binary dropped from 35MB to 17MB.** A two-profile build split separates development conveniences (like the embedded Swagger UI) from the production binary. The Swagger UI alone added 18MB of compressed assets — useful for API development, unnecessary for `npx claude-view`. Feature-gating it behind a compile flag keeps both workflows working without bloating the distributed binary.

**Search indexing releases 50MB of heap after bulk operations.** The Tantivy full-text search engine holds a large write buffer during indexing. Previously, this buffer persisted for the lifetime of the process. A two-phase writer pattern now opens the writer, performs the bulk index, commits, and releases it. The writer only re-opens when new sessions arrive. For a typical installation with thousands of sessions, this means the steady-state memory footprint drops by about 50MB after the initial indexing burst.

The sidecar Node.js process also became lazy — it no longer spawns at server startup, only on first interactive use. If you're just browsing historical sessions, the sidecar never loads.

## Runtime configuration

A new `config.toml` file lets you toggle features without recompiling. This is the foundation for future A/B testing and gradual rollouts, but immediately useful for disabling features that don't apply to your workflow.

## Reliability fixes

Per-block error isolation means a single malformed block in a conversation no longer takes down the entire chat view. Each block renders inside its own error boundary — if one block fails to parse, the rest of the conversation remains readable. This particularly helps with historical sessions that may contain older JSONL formats.

The plugin system's npm source and npx MCP pattern were also fixed, unblocking `claude plugin install` from the registry for remote installations.

## Update now

```bash
npx claude-view@latest
```

Open the Live Monitor and check the ownership badges on your running sessions — SDK-spawned agents, tmux groups, and standalone sessions are now labeled automatically.


--- blog/v0-36-0-pid-lifecycle-and-terminal-panes.mdx ---

---
title: "PID Files, One Store, and Terminal Panes That Stay Put"
description: "v0.36.0 replaces process tree scanning with PID-based session detection, unifies the session store, and adds Zed-style terminal panes."
date: 2026-04-13
author: claude-view team
---

If you've ever restarted the claude-view server and found ghost sessions lingering in your dashboard, or watched a session flicker between "active" and "unknown" because the process scanner missed a heartbeat — v0.36.0 fixes the root cause.

## PID files as the single source of truth

Previous versions detected Claude Code sessions by scanning the process tree — looking for specific process signatures, checking parent-child relationships, cross-referencing tmux session names. It worked, but it was fragile. Process tree scanning races with process startup and teardown, and different OS versions report process metadata inconsistently.

v0.36.0 flips the model. Claude Code writes a PID file when it starts and removes it when it exits. The oracle now reads these files instead of scanning `/proc` or `ps`. This is the same pattern used by PostgreSQL, nginx, and most Unix daemons — because it works.

The oracle runs on a two-tier refresh cycle: PID file checks every 2 seconds (cheap — just `stat` calls), full system reconciliation every 10 seconds (for cleanup and edge cases). The result is faster detection with lower CPU usage.

## One store to rule them all

The server previously maintained two separate session stores: `CliSessionStore` for CLI-discovered sessions and the main `LiveSessionStore` for everything else. This dual-store architecture meant ownership data, tmux bindings, and lifecycle events had to be synchronized between two maps — a constant source of subtle state bugs.

v0.36.0 collapses both into a single unified store. Every session — whether discovered via CLI, spawned by the SDK, or posted by tmux — lives in one map with one lifecycle. The `SessionEvent` enum was simplified from multiple variants to just `SessionUpsert` and `SessionRemove`, making the event flow easier to reason about.

A side effect: server restarts now properly reconcile tmux ownership. The startup path queries tmux for active sessions and reconciles against PID files, so ghost sessions from the previous server lifetime are cleaned up immediately rather than lingering until the next full scan.

## Terminal panes, redesigned

The Live Monitor's terminal panes got a Zed-inspired overhaul. Chrome has been stripped down to the minimum — no redundant borders, no wasted header space. Each session gets exactly one terminal panel (the duplicate CLI panel bug is gone), with keyboard shortcuts for zoom and layout management.

Sessions also show their lifecycle state visually. A new "Spawning" status with a pulsing blue indicator appears the moment a session is detected via PID file, before the first JSONL output arrives. You see the session boot in real time instead of it appearing fully formed after a delay.

## Under the hood

The closed session ring switched from an unbounded `HashMap` to a bounded `VecDeque(100)`. Previously, every session that exited stayed in memory indefinitely for "recently closed" lookups. Now only the last 100 are kept, with constant-time insertion and bounded memory.

The dockview layout persistence was also hardened — saves now flush on `unload`, `visibilitychange` (hidden), and React unmount, covering all the ways a browser tab can close without the layout being saved.

## Update now

```bash
npx claude-view@latest
```

Open the Live Monitor and watch a new Claude Code session boot — you'll see it appear as "Spawning" with a blue dot before any output arrives.


--- blog/v0-37-0-archived-projects-and-born-waiter.mdx ---

---
title: "Smart Project Archiving and Instant Session Resolution"
description: "v0.37.0 auto-detects archived projects, resolves CLI sessions without polling, and eliminates dual-path data flow bugs."
date: 2026-04-14
author: claude-view team
---

If you've used Claude Code across dozens of repositories, your Scope panel probably has ghosts — project entries for directories you deleted months ago. And if you've ever noticed a brief delay when launching a new CLI session from the dashboard, that was polling. Both problems are solved in v0.37.0.

## Archived project detection

claude-view now probes each project directory on startup. If the directory no longer exists on disk, the project is marked as archived and moves to a collapsed section at the bottom of the Scope panel. Your active projects stay front and center.

This works through a new `project_dir_status` table that tracks directory existence. The startup backfill runs asynchronously — it doesn't block the server from serving requests. Projects are also rechecked when new sessions arrive, so if you delete a directory mid-session, the next scan catches it.

For users with worktree-heavy workflows, we also fixed git root inference. Previously, sessions inside a worktree could fail to resolve back to the parent repository. The path resolution now walks up the directory tree to find the real `.git` root.

## Zero-poll session resolution

When you click "New Session" in the dashboard, claude-view creates a tmux session, waits for Claude to boot, then returns the session identity. Previously, this "wait" was a poll loop: check for a pid.json file every 50ms, up to 100 times.

The new "born waiter" pattern replaces polling with event-driven resolution. An FSEvents watcher registers before the tmux session is created, then races against the fallback poll. In production on macOS, the watcher fires within a millisecond of Claude writing its pid.json. The poll path still exists for environments without filesystem events (CI, containers), but it almost never wins the race.

We instrumented the entire create-session path with lifecycle debug logging to verify the timing. The waterfall shows: API handler starts at T+0ms, tmux spawns at T+2ms, pane PID resolves at T+3ms, and the born event fires at T+63ms (Claude's boot time). Zero wasted poll cycles.

## Single-writer architecture

A recurring bug pattern in real-time dashboards: a button triggers a fetch that creates an entity, while simultaneously an SSE stream delivers the same entity from the server. Two paths, same data, guaranteed desync.

v0.37.0 enforces a single-writer rule: buttons own the fetch, parent components react to the callback, and SSE streams only sync existing state — they never create new entities. This eliminated a class of phantom duplicate entries that appeared briefly before reconciliation cleaned them up.

## Update now

```bash
npx claude-view@latest
```

Try launching a new CLI session from the dashboard — the resolution is noticeably faster. And if you have deleted project directories, check your Scope panel for the new Archived section.


--- blog/v0-38-0-production-observability.mdx ---

---
title: "End-to-End Request Tracing for Claude Code Sessions"
description: "v0.38.0 adds structured logging, crash reports, and request ID propagation so you can trace any operation from browser to CLI session."
date: 2026-04-15
author: claude-view team
---

When something goes wrong in a system that orchestrates CLI sessions, WebSocket connections, and a block pipeline processing thousands of JSONL events, the first question is always: "What happened?" Until now, the answer required grepping through unstructured stderr output and hoping the timestamps lined up.

v0.38.0 ships a unified observability stack that makes every operation traceable.

## The problem

claude-view sits between your browser and Claude Code CLI sessions running in tmux. A single user action — opening a session, sending a message, watching blocks stream in — touches HTTP handlers, WebSocket connections, a block pipeline orchestrator, and the sidecar proxy. When something hung or crashed, you had no structured way to correlate events across these layers.

Logs were `eprintln!` calls. Crashes left no trace. If a request timed out, you couldn't tell whether the bottleneck was in the pipeline, the sidecar, or the CLI itself.

## What shipped

**Structured JSON logs** roll daily under `~/.claude-view/logs/`. Every log line includes a timestamp, span context, and structured fields — no more parsing free-text messages. In dev mode, you still get human-readable stderr output.

**Request ID propagation** is the core change. Every HTTP request entering the server gets a ULID `x-request-id`. That ID propagates through:

- HTTP response headers (for browser DevTools correlation)
- WebSocket init frames (so the sidecar knows which request spawned the connection)
- Block pipeline orchestrator spans (so you can trace which pipeline phase processed which block)
- tmux environment variables (`CLAUDE_VIEW_TRACE_ID`, `CLAUDE_VIEW_CLI_SESSION_ID`)

If a session hangs, you can grep the log directory for the request ID and see the full lifecycle: HTTP request received, WebSocket upgraded, pipeline phase entered, blocks processed, response sent.

**Crash logs** catch the cases where structured logging can't help — panics. A custom panic hook writes `crash-*.log` files with the full backtrace, the span context at the point of panic, and service metadata (version, host hash, deployment mode). These persist even when the process exits abnormally.

**Opt-in Sentry** integration sends crash reports and error events to Sentry when you opt in via a consent file at `~/.claude-view/telemetry-consent` or the `SENTRY_DSN` environment variable. No data leaves your machine unless you explicitly enable it.

## Under the hood

The observability crate is built on `tracing` and `tracing-subscriber` with a layered architecture:

- A **JSON file layer** with `tracing-appender` rolling daily files
- A **dev stderr layer** with `tracing-subscriber::fmt` for human-readable output, active only in dev mode
- An optional **OTLP layer** behind the `otel` feature flag, for sending traces to Jaeger, Grafana Tempo, or any OpenTelemetry-compatible backend
- An optional **Sentry layer** that maps `tracing` events to Sentry breadcrumbs and errors

All layers share a single `EnvFilter` configured via `RUST_LOG`. The subscriber is installed once at startup, and every `#[instrument]` annotation across the workspace automatically participates.

We also added criterion benchmarks to ensure the observability layer doesn't add measurable latency to the block pipeline hot path.

## ARM64 and pipeline hardening

This release also extends the build matrix to **linux-arm64**, so ARM servers and Raspberry Pi devices get native binaries. The release pipeline now runs artifact verification contracts (tarball structure, binary version check, ELF architecture validation) and build provenance attestations before publishing.

## Update now

```bash
npx claude-view@latest
```

Check `~/.claude-view/logs/` after running a few sessions to see structured traces in action.


--- blog/v0-39-0-stability-and-tokens-at-the-top.mdx ---

---
title: "Stability Fixes, Faster Search, and Tokens at the Top"
description: "v0.39.0 ships memory-bounded sidecar streaming, blue-green search index migration, and token and cost hero cards on the analytics page."
date: 2026-04-28
author: claude-view team
---

You opened claude-view, scrolled through 100+ closed sessions in the Live Monitor, and watched it freeze. Or you waited through a long startup while the search index rebuilt. Or you wondered why your Mac's fan spun up after claude-view ran for an afternoon.

v0.39.0 is the stability release. Three foundational fixes that you'll feel every day, plus an analytics tweak that surfaces the numbers you actually look at.

## The problem with 100 closed sessions

The Live Monitor reconciler — the loop that synchronizes session state between the sidecar and the database — used to bail out when too many sessions piled up. It hit a cooldown, scheduled a retry, and in the meantime the UI stopped responding to clicks. Open enough closed sessions and you'd see the panel just freeze.

We replaced the cooldown with **lazy sidecar recovery**. Sessions are reconciled on-demand when you actually look at them, not eagerly across the entire history. The 100-session ceiling is gone. We tested with thousands.

The companion fix is **bounded sidecar memory**. Each session's stream buffer used to grow without a cap as messages accumulated. Heavy users — running Claude Code 8 hours a day with multiple parallel agents — would notice claude-view's RSS climbing through the day. The cap is now enforced per-session, with heap telemetry exposed so we can catch regressions before users see them.

## Blue-green search index migration

The search index uses Tantivy, which has a versioned schema. When the schema changes (we add a field, change an analyzer, etc.), the old index isn't readable by the new code. Older versions handled this by rebuilding from scratch on startup — which meant a multi-second freeze the first time you launched the new version.

v0.39.0 ships **blue-green index migration**: when claude-view detects a schema bump, it keeps serving queries from the previous-version index while building the new version at `v{N}/` in the background. When the new index is ready, it swaps in atomically. No startup pause, no broken search.

This was foundational work for shipping schema changes safely going forward — we can iterate on search relevance without paying a perceived-startup-time tax.

## Tokens and cost at the top

The analytics page used to lead with a heatmap, then a project breakdown, then activity, then somewhere down the page: total tokens, total cost. Those are the numbers you actually look at — "how much did I spend last week?" — and they were buried.

v0.39.0 moves **tokens processed** and **total cost** to the top of the page, above the heatmap. The hero cards adapt to time-range filters. If you select "last 7 days" they show the 7-day numbers. If you select "all time" you see the lifetime totals.

There's also a date-range caption that says exactly what window the numbers represent, so you don't have to guess what "last 7 days" means against a weekend or a partial week.

## Under the hood: a six-month database rebuild

The biggest internal change in v0.39.0 doesn't have a UI — it's a multi-phase CQRS-style rewrite of the database write path. The old `sessions` table did everything: metadata, action history, derived stats, all in one row. Concurrent writers fought for the same row. Schema migrations were painful.

The rebuild splits this into:

- `session_stats` — the canonical writer-owned row, derived from JSONL parsing
- `session_flags` — user actions (archive, classify, dismiss) that flip independently
- `session_action_log` — append-only event log for audit and replay
- `stage_c_outbox` — reliable cross-table fanout for derived rollups
- 15 rollup tables — pre-aggregated stats so dashboard reads don't scan everything

The legacy `sessions` table is gone, retired through dual-write phases, shadow parity monitors, and a drift detector that runs continuously. We landed it as 7 phases over six months because *retiring a hot table without breaking anything* is the kind of work that has to be done patiently.

You won't see this directly. You'll feel it as: dashboard pages load faster, the writer doesn't stall, and adding new aggregations is a `derive(RollupTable)` away.

## What's next

- **Mobile pairing client.** v0.39.0 ships the server-side and Settings UI for pairing a phone via QR code. The receiving mobile app is the next milestone.
- **Plan workflows.** Pairing the existing plan blocks with editable plan TODOs so you can drive a session from a written plan.
- **Faster cold starts.** With the database rebuild done, the next bottleneck is the indexer — and we have ideas.

## Update now

```bash
npx claude-view@latest
```

If you've been holding off because of the 100-session freeze, this is the release to come back for. Open the analytics page first — the new hero cards are the smallest visible change but the one we use most.


--- blog/v0-4-0-dashboard-analytics.mdx ---

---
title: "Dashboard Analytics: Measuring Your AI Fluency"
description: "v0.4.0 transforms claude-view from a session browser into an analytics platform with time filters, heatmaps, and model usage breakdowns."
date: 2026-02-10
author: claude-view team
---

Until now, claude-view answered "what happened in this session?" With v0.4.0, it answers a bigger question: "how am I using AI over time?"

## From browser to analytics platform

The session list was useful for reviewing individual conversations. But if you've been using Claude Code daily for weeks, you need patterns, not transcripts. How many sessions did you run last week? Which model are you using most? Are you getting more efficient or just running more sessions?

v0.4.0 adds a full analytics dashboard that surfaces these patterns automatically.

## Time range filters with URL state

Every chart and metric on the dashboard respects a time range selector — last 7 days, 30 days, 90 days, or a custom range. The selected range is persisted in URL parameters, so you can bookmark a specific view or share a link with a colleague and they see the same data window.

Internally, this uses a copy-then-modify pattern for URL params. The filter state is the single source of truth, and every component reads from it rather than maintaining its own date range. One filter, applied everywhere.

## Contribution heatmap

A GitHub-style heatmap shows your daily Claude Code activity over the past year. Each cell is a day, colored by session count. Hover any cell to see the exact count and date.

This sounds simple, but the implementation required careful timestamp handling. Session timestamps in Claude Code JSONL files are strings, not numbers. Every timestamp conversion guards against `ts <= 0` to prevent `new Date(0)` from rendering as January 1, 1970.

## Model usage breakdown

A breakdown chart shows which models you've used and how tokens distribute across them. If you're running a mix of Sonnet and Opus sessions, you'll see the cost implications immediately — Opus sessions use more tokens per turn but often finish tasks in fewer turns.

## Performance gains

v0.4.0 also consolidates database queries. The previous version made separate queries for sessions, contributions, and metadata. Now a single query returns everything the dashboard needs, reducing database round-trips by roughly 65%. On a machine with 500+ sessions, the dashboard loads noticeably faster.

The test suite grew to 922 tests across the Rust backend and React frontend, covering edge cases like zero-duration sessions, sessions with no commits, and time ranges that span timezone boundaries.

## Update now

```bash
npx claude-view@latest
```

Open the dashboard tab and see your AI usage patterns for the first time. The data was always there — now it's visible.


--- blog/v0-40-0-trustworthy-usage-pill.mdx ---

---
title: "Building a Usage Pill You Can Actually Trust"
description: "v0.40.0 reworks the OAuth usage pill to handle six new Anthropic rate-limit windows, hide decommissioned buckets, and render multi-currency extras — trust over accuracy."
date: 2026-04-29
author: claude-view team
---

Open the dashboard and look at the top-right corner. That little pill that says "Weekly Sonnet 0%, no reset"? Until v0.40.0, that was a lie.

Anthropic quietly retired the Sonnet weekly bucket weeks ago. The API still returns it for backward compatibility — utilization at 0, `resets_at` set to null — but the bucket itself is gone. Older claude-view versions saw the data and dutifully rendered it as "Weekly Sonnet, 0% used." If you took that pill at face value, you'd think you had unlimited Sonnet headroom for the week. You didn't. Sonnet just doesn't have a weekly window anymore.

This is the kind of bug that's worse than not shipping the feature at all. **Wrong information destroys trust permanently** — once you see one wrong number from a tool, you stop believing any of them.

## What v0.40.0 does

The OAuth usage pill now follows a hard rule: if we aren't confident, we don't show it. Specifically:

- **Trust gate.** Any tier where utilization is unknown, OR where utilization is exactly 0 _and_ `resets_at` is null, is hidden. The decommissioned Sonnet bucket disappears entirely. So do new buckets we don't have a label for yet but can't read confidently.
- **Six new windows recognised.** Anthropic shipped buckets we hadn't seen before — `seven_day_opus`, `seven_day_omelette`, `seven_day_oauth_apps`, `seven_day_cowork`, plus a couple more codenames. Older versions failed to parse the response when one of these appeared, dropping the entire pill. v0.40.0 reads them all, with curated labels for the known ones and a humanised fallback ("seven_day_omelette" → "Weekly · omelette") for the rest.
- **Multi-currency extras.** `extra_usage` now respects the `currency` field. EUR gets "EUR", JPY gets "JPY". No fabricated dollar signs on European invoices.
- **Grouped tooltip.** When the pill expands, tiers are organised by kind: Session, Weekly windows, Additional tiers, Extra usage. If there's only one group, the layout collapses to its old single-tier form so nothing feels heavier than it needs to.

## The principle

claude-view treats every inferred or derived display through a **confidence-gated** lens. Better to show nothing than to show something wrong. Better to admit "we don't have a label for this codename yet" than to make up a friendly name. Better to lose a row than to confuse you about what's running on your account.

We have a phrase in the codebase: _寧願唔顯示，都唔顯示錯嘅嘢_ — better to display nothing than to display the wrong thing. It's borrowed from how Apple handles uncertainty in surfaces like Siri and the Lock Screen: precision over recall, every time.

## Under the hood

The fix is structural, not a band-aid. The OAuth handler used to be a single 574-line `oauth.rs` that parsed the raw API response straight into typed structs. One unknown field would break the whole response.

We split it into five focused files (`mod.rs`, `anthropic.rs`, `tiers.rs`, `identity.rs`, `handlers.rs`) and changed the parser shape:

- `utilization` is now `Option<f64>` instead of `f64`. A null in any window no longer poisons the whole response.
- `#[serde(flatten)] extra_windows: HashMap<String, _>` catches every codename Anthropic ships, known or not, without a code change.
- A `TierKind` enum (`session | window | other | extra`) lets the frontend group rows correctly when new tiers appear.
- `humanize_id` provides a fallback label for codenames we haven't curated yet.

The frontend pill component went through the same treatment — 364 lines became 6 small files, none over 154. Backward compatibility is preserved: pre-2026-04 backends without `kind`/`currency` fields render exactly as before.

## A small thing that wasn't really small

While we were in there, we also renamed the `/usage` plugin command to `/cv-usage`. Claude Code shipped a built-in `/usage` that shadowed ours, making the plugin command silently unreachable. The `cv-` prefix matches the npm package name and lets both coexist. Update your aliases.

## What's next

- **Subagent attribution surfacing.** Claude Code 2.1.123 added metadata tagging which subagent / skill / plugin dispatched each sidechain message. v0.40.0 baselines these new fields so the integrity check passes; the next release wires them into the session view so you can see at a glance _who_ was driving each turn.
- **Mobile pairing client.** The phone app to pair with claude-view (server-side scaffolding shipped in v0.39.0) is in active development.
- **Plan-driven sessions.** Editable plan TODOs paired with plan blocks so you can drive a session from a written plan.

## Update now

```bash
npx claude-view@latest
```

If you've been ignoring the pill in the corner, re-open the dashboard and click it. The tooltip is the difference.


--- blog/v0-41-0-truthful-telemetry.mdx ---

---
title: "Default-on telemetry that doesn't lie to you"
description: "v0.41.0 adds anonymous usage analytics — content-free, opt-out anytime, App Store privacy nutrition labels included. Plus: the install_source detection bug we accidentally shipped for months, and how we caught it."
date: 2026-05-18
author: claude-view team
---

If you ship a developer tool, you have a problem: most of your users never tell you what they actually use. You can guess from GitHub stars, npm downloads, the occasional issue. None of those are honest signals. They're vanity metrics with no causal link to whether the feature you spent two weeks on is helping anyone.

So this release adds something we resisted for a long time: **anonymous usage analytics, on by default**. We want to be straight about what we're doing and why.

## What we collect (and what we don't)

We count which screens you open, which features you click, app version, OS, install source, and a random per-install UUID. That's it.

We never collect: your code. Your prompts. Your file paths. Your conversation content. Your project names. Your Claude session IDs. There is no event in the schema that carries any of that. This isn't policy — it's enforced by a closed event taxonomy in the source. The compiler rejects new events that try to carry content fields.

Turn it off permanently with one command:

```bash
export CLAUDE_VIEW_TELEMETRY=0
```

A one-time notice prints on first run telling you exactly this. Builds from source send nothing — the API key is baked in at build time only for the official npm package and install script.

## App Store privacy nutrition labels

The full [privacy policy](https://claudeview.ai/privacy/) is now live with Apple App Store privacy nutrition labels (we're working toward an iOS app). Third-party processors are listed by name. Retention is stated explicitly. Your rights are spelled out — including: ask us to delete everything we have on you, at any time.

If your company needs to clear a vendor review before installing claude-view, the privacy page is structured so legal can do it in fifteen minutes. We wrote it as plain English first and lawyer English second.

## The bug we accidentally shipped for months

This release also fixes something embarrassing. The old code that figured out *how* you installed claude-view (shell script, npx, or Claude Code plugin) checked whether the binary's path contained `.cache/claude-view`. Earlier in the year we moved all app data from `~/.cache/claude-view/` to `~/.claude-view/` — and that detection silently broke. Every install via the shell script for the last few months was being labelled `npx` in our (then-internal) analytics.

The fix is structural: install.sh now writes an explicit marker file at `~/.claude-view/install-source`, and the server resolves it relative to the running binary. It survives `CLAUDE_VIEW_INSTALL_DIR` overrides. It's testable without a real install (pure path arithmetic + injected exe path). And it can't drift from the install script again because the install script writes the marker the server reads, in the same commit.

We caught this only because we instrumented the data pipeline end-to-end before shipping the analytics — and found the breakdown of install sources looked impossible. If we'd shipped the metric without that verification, the install-source numbers would have been useless for the first month, and we wouldn't have known.

There's a lesson here that's bigger than telemetry. Path contracts spanning multiple components (a shell script writes a file, a binary reads it) drift silently if you only fix one side. The new structure puts both sides under the same MANDATORY rule in the project's path-contract drift sweep: find one site, grep the cluster, fix all of them, prove zero.

## Plan-mode badge — confidence-gated by design

A session card now shows a small `Plan` badge when the session is in Claude Code plan mode. The implementation is uninteresting; the design constraint is.

We could have shown the *current* permission mode for every session, all the time. We didn't. Instead the badge appears **only when the most recent hook explicitly reported `plan`**. Every other mode — and the absence of any reported mode — renders nothing. No "Unknown" pill. No "Default" badge. Just silence, until we have a strong signal.

This follows a principle the project tries to apply everywhere: **better to show nothing than show something wrong**. Wrong information destroys trust permanently. Once you've seen a tool tell you the wrong thing, you'll never fully believe its next claim. Silence costs less.

The sub-agent reordering on cards (#62) follows the same idea from a different angle: don't sort agents arbitrarily and let the user wonder; sort them by what's most useful (running + newest first) and let the "+N more" overflow hide the oldest, not the working ones.

## What's next

Now that this release ships, we can finally measure whether the features people *think* are useful are the ones they actually use. The next few weeks will be guided by that data — not vibes, not loud GitHub issues, not what we feel like building.

If you don't want to be part of that, the opt-out is one command. If you do, you don't have to do anything — just upgrade.

```bash
npx claude-view@latest
# or
curl -fsSL https://get.claudeview.ai/install.sh | sh
```


--- blog/v0-5-0-mission-control.mdx ---

---
title: "Mission Control: Watching Your AI Agents Work in Real Time"
description: "v0.5.0 is the biggest release yet — live dashboards for every running Claude Code agent with sub-agent visualization, cost tracking, and full-text search."
date: 2026-02-19
author: claude-view team
---

You have three Claude Code agents running. One is refactoring your API layer. Another is writing integration tests. A third is debugging a deployment script. You alt-tab between terminal windows trying to remember which is which, whether any are waiting for approval, and how much you've spent in the last hour.

v0.5.0 ends the alt-tabbing. This is Mission Control.

## Real-time session state machine

Every running Claude Code session is now tracked with a state machine: **Needs You** (waiting for human input), **Autonomous** (actively working), and **Done** (completed). The live dashboard shows all sessions at a glance, color-coded by state. You know instantly which agents need attention and which are working autonomously.

State transitions are detected by monitoring the JSONL output in real time. When an agent emits a user-facing question or hits a permission boundary, it flips to "Needs You." When it starts executing tool calls again, it's back to "Autonomous."

## Sub-agent swim lanes

Claude Code can spawn sub-agents — child processes that handle specific subtasks. Before v0.5.0, these were invisible. Now the dashboard shows sub-agent hierarchies as nested swim lanes. You can see the parent agent coordinating work and each sub-agent executing its piece.

This is critical for complex tasks where a top-level agent delegates to 2-3 sub-agents simultaneously. Without visualization, you're flying blind.

## Verbose mode

Click any session card and toggle verbose mode to see every tool call as it happens. File reads, writes, shell commands, search queries — the full stream. This is the equivalent of watching over the agent's shoulder, except you can monitor multiple agents at once.

## Full-text search with Tantivy

Session history is now indexed by a Tantivy search engine — the same engine that powers parts of GitHub's search. Type a query and get results across all your sessions instantly. Fuzzy matching handles typos. Results highlight the matching text in context.

This replaced a naive substring search that slowed down linearly with session count. Tantivy builds an inverted index at startup, and queries return in single-digit milliseconds regardless of how many sessions you have.

## AI Fluency Score

A new composite metric — the AI Fluency Score — rates your collaboration with AI agents on a 0-100 scale. It factors in session efficiency (tokens per useful output), tool usage patterns, and iteration count. The score trends over time so you can see whether you're getting better at directing AI agents.

## Navigation restructure

Mission Control is now the landing page when you open claude-view. Session history, analytics, and search are still one click away, but the live dashboard is front and center. If you're running agents, that's what you need to see first.

## Update now

```bash
npx claude-view@latest
```

Start a few Claude Code sessions, then open claude-view. You'll never go back to alt-tabbing.


--- blog/v0-6-0-rebrand.mdx ---

---
title: "From vibe-recall to claude-view: Why We Renamed"
description: "v0.6.0 officially rebrands the project to claude-view — a name that tells you exactly what it does."
date: 2026-02-20
author: claude-view team
---

The project used to be called **vibe-recall**. It was a fun name — catchy, a nod to the "vibe coding" movement. But every time someone saw the name for the first time, they asked: "What does it do?"

That's a naming failure. A tool's name should answer that question, not raise it.

## Why names matter for developer tools

Developer tools live or die by discoverability. You search "Claude Code dashboard" or "monitor Claude sessions" and you need to find the tool. "vibe-recall" doesn't match any of those queries. It's a brand name, not a descriptor.

**claude-view** tells you exactly what it is: you view your Claude sessions. It's searchable, memorable, and self-explanatory. When someone mentions it in a Slack channel, the person reading doesn't need to click a link to understand what the tool does.

## The scope of the rename

Renaming a project isn't a one-line change. Every reference had to be updated:

- npm package name: `vibe-recall` to `claude-view`
- Rust crate names: `vibe-recall-server`, `vibe-recall-core`, etc. to `claude-view-server`, `claude-view-core`
- Binary name: the CLI command itself
- All import paths in TypeScript and Rust
- CI/CD pipeline references
- Documentation, README, and config files
- The default port stayed at `47892` — some things don't need to change

We scripted most of it with find-and-replace, then manually verified every file. The test suite caught several places we missed on the first pass.

## What else shipped in v0.6.0

The rename was the headline, but v0.6.0 also includes:

**Hook event logging** — Claude Code hooks (pre/post-tool scripts) now emit structured events that claude-view captures. You can see when hooks fire, how long they take, and whether they succeed. This is essential for debugging custom hook workflows where a failing hook silently changes agent behavior.

**Context gauge improvements** — the context window usage indicator is now more accurate. It accounts for cache read tokens separately from fresh input tokens, giving you a clearer picture of how close a session is to the context limit. When a session is approaching the limit, you'll know before the agent starts degrading.

## Going forward

The `npx` command is now:

```bash
npx claude-view
```

If you previously installed `vibe-recall`, uninstall it and switch to the new package name. The old name will stop receiving updates.

## Update now

```bash
npx claude-view@latest
```

Same tool, better name. Everything else works exactly as before.


--- blog/v0-7-0-crash-recovery.mdx ---

---
title: "Crash Recovery: Building a Tool You Don't Have to Babysit"
description: "v0.7.0 adds server crash recovery with persistent snapshots, work reports with cost analysis, and the cleanup CLI command."
date: 2026-02-20
author: claude-view team
---

Here's a scenario that actually happened: you're running four Claude Code agents overnight. claude-view is monitoring all of them. At 3am, the server crashes — maybe an OOM kill, maybe a panic on a malformed session file. You wake up and check the dashboard. All four sessions show as "unknown." The live state is gone. The agents finished hours ago but you have no record of their final status, token usage, or costs.

v0.7.0 makes sure that never happens again.

## Persistent session snapshots

The live monitor now writes session state to disk using a v2 snapshot format. Every state transition — Autonomous to Needs You, token count update, sub-agent spawn — is persisted. If the server crashes and restarts, it reads the snapshot file and reconstructs the exact state of every session that was running.

This isn't a full replay of the JSONL files (that would be slow). The snapshot is a compact binary format that captures the derived state: current status, accumulated tokens, cost, active sub-agents, and the last known message. Recovery takes milliseconds, not minutes.

The format is versioned so future changes to the state model don't break older snapshots. v1 snapshots (from before this release) are detected and discarded gracefully — you lose the old state but the server doesn't crash on startup.

## Work Reports

A new Work Reports page shows completed sessions with a focus on output: what files were modified, how many commits were produced, and the total cost. Think of it as a daily standup for your AI agents — here's what they did, here's what it cost.

Each report includes a **token breakdown** by category: input tokens, output tokens, cache reads, and cache creation. Cache reads are significantly cheaper than fresh input, so knowing your cache hit ratio tells you whether your sessions are cost-efficient or re-processing context unnecessarily.

**Cost analysis** converts raw token counts into dollar amounts using per-model pricing. You see the actual cost per session, per project, and per day. No more mental math with token counts and pricing pages.

## The cleanup command

Session files accumulate. After months of daily use, `~/.claude/projects/` can grow to gigabytes. The new CLI command handles this:

```bash
claude-view cleanup --older-than 90d
```

It removes session files older than the specified duration. It's non-destructive by default — run without `--confirm` to see what would be deleted. The search index is updated automatically after cleanup.

## Philosophy

A monitoring tool should be the most reliable piece of software you run. If it needs babysitting, it's adding overhead instead of removing it. Crash recovery, persistent state, and self-maintenance are not features — they're table stakes. v0.7.0 brings claude-view to that standard.

## Update now

```bash
npx claude-view@latest
```

Start it, forget about it. It'll be there when you need it.


--- blog/v0-8-0-plugin-and-search.mdx ---

---
title: "The Claude Code Plugin: Ask Your Agent About Your Work"
description: "v0.8.0 ships the claude-view plugin with 8 MCP tools, 3 skills, and a Tantivy-powered unified search engine."
date: 2026-02-22
author: claude-view team
---

Sometimes you don't want to leave your terminal. You're in the middle of a Claude Code session and you think, "What did I work on yesterday?" or "How much have I spent this week?" Opening a browser tab breaks your flow. You want the answer right here, inside the agent conversation.

v0.8.0 ships the **claude-view plugin** — a native Claude Code plugin that brings your session data into the agent itself.

## Install and go

```bash
claude plugin add @claude-view/plugin
```

That's it. The plugin auto-starts the claude-view server if it isn't already running. No separate process management needed.

## 8 MCP tools

The plugin exposes 8 read-only MCP tools that Claude Code can call during conversations:

- **list-sessions** — recent sessions with metadata
- **get-session** — full detail for a specific session
- **search-sessions** — full-text search across all sessions
- **get-costs** — token usage and cost breakdown
- **get-activity** — session counts by day/week
- **get-contributions** — git commits linked to AI sessions
- **get-projects** — all tracked projects
- **get-status** — server health and indexing status

These are read-only by design. The plugin never modifies your session data, never writes files, never changes state. It observes.

## 3 skills

Skills are pre-built prompts you can invoke with a `/` command:

**`/session-recap`** — summarizes your most recent session: what was accomplished, which files were changed, how many tokens were used. Useful when you pick up work the next morning and need context.

**`/daily-cost`** — shows today's total spend across all sessions, broken down by model. Run this at end of day to know your burn rate.

**`/standup`** — generates a standup-style summary of your last 24 hours of AI-assisted work. Sessions, commits, projects touched, total cost. Copy-paste it into your team's standup channel.

## Unified Tantivy search

The search engine got a major upgrade in v0.8.0. Previous versions indexed session metadata (title, project, date). Now the full conversation content is indexed — every user message, every assistant response, every tool call result.

The Tantivy engine supports fuzzy matching, so `refactr` finds results for "refactor." Queries return ranked results with highlighted snippets showing the matching text in context. On a machine with 1,000+ sessions, queries return in under 10ms.

## Rich message rendering

Conversation history now renders with **paired tool cards**. When Claude calls a tool and gets a result, both the call and the result are displayed as a single visual unit. File reads show the file content inline. Shell commands show the command and its output together. This makes it dramatically easier to follow what an agent actually did versus reading raw JSON blocks.

**Hook events** are also visible in conversation history. If a pre-tool hook modified the agent's behavior, you'll see it in the timeline where it happened, not buried in a separate log.

## Update now

```bash
npx claude-view@latest
```

Then install the plugin:

```bash
claude plugin add @claude-view/plugin
```

Ask your agent "what did I work on this week?" and get a real answer backed by real data.


--- blog/v0-9-0-activity-and-sharing.mdx ---

---
title: "Activity Dashboard and End-to-End Encrypted Sharing"
description: "v0.9.0 adds a calendar heatmap activity page and zero-knowledge encrypted conversation sharing via share.claudeview.ai."
date: 2026-02-25
author: claude-view team
---

Two features that sound unrelated but share a common thread: making your AI work visible. The activity dashboard makes it visible to you. Encrypted sharing makes it visible to others — on your terms.

## Activity dashboard

The new Activity page shows a **calendar heatmap** of your Claude Code usage over the past year. Each cell is a day, shaded by session count. It answers a question that's surprisingly hard to answer otherwise: "Am I using AI more or less than I was three months ago?"

Below the heatmap, a **daily timeline** expands when you click a specific day. You see every session from that day, ordered chronologically, with project names, durations, and token counts. It's a granular view of how your day was structured — when you started your first session, how long the gaps were, whether you ran agents in parallel or sequentially.

A **project breakdown** panel shows the distribution of work across repositories. If 80% of your sessions last week were in one project, you'll see it immediately. This is useful for weekly retrospectives or when deciding where to allocate more agent time.

## End-to-end encrypted sharing

You found a Claude Code session that perfectly demonstrates a technique — a clean refactoring approach, a debugging workflow, a prompt pattern that worked well. You want to share it with a colleague. But the session contains your file paths, your code, your project structure. Pasting raw JSONL into Slack isn't an option.

v0.9.0 adds encrypted sharing. Click the share button on any session, and claude-view:

1. **Encrypts the session client-side** using AES-256-GCM with a randomly generated key
2. **Uploads the encrypted blob** to our infrastructure (Cloudflare R2)
3. **Gives you a URL** like `share.claudeview.ai/s/abc123#key=xyz`

The encryption key is in the URL fragment (after `#`), which browsers never send to the server. The server stores ciphertext it cannot decrypt. This is zero-knowledge architecture — even if our infrastructure were compromised, your session data remains encrypted.

Recipients open the link in their browser. The share viewer SPA downloads the encrypted blob, extracts the key from the URL fragment, decrypts in-browser, and renders the conversation. **No account required.** No install. Just a link.

Shared sessions expire after 30 days by default, or you can delete them immediately from the sharing panel.

## Unified indexing pipeline

Under the hood, v0.9.0 consolidates three separate indexing paths (session metadata, full-text content, git contributions) into a **single three-phase pipeline**: discover, parse, and index. This eliminates race conditions where the search index and the database disagreed about which sessions existed. It also makes startup faster — one pass through the session directory instead of three.

## CLAUDE_VIEW_DATA_DIR

For sandboxed environments (containers, CI runners, managed workstations), you can now point claude-view at a custom data directory:

```bash
CLAUDE_VIEW_DATA_DIR=/path/to/sessions npx claude-view
```

This overrides the default `~/.claude` path. Useful if your Claude Code sessions live on a mounted volume or a shared filesystem.

## Update now

```bash
npx claude-view@latest
```

Check the Activity page to see your usage patterns. Share a session to see zero-knowledge encryption in action.


--- blog/why-rust-over-nodejs.mdx ---

---
title: "Why We Chose Rust Over Node.js for a Local-First CLI Tool"
description: "Rust gives us a 15MB binary with sub-second startup, mmap file parsing, and zero runtime dependencies. Here's why that matters for developer tools."
date: 2026-01-30
author: claude-view team
---

The first prototype of claude-view was a Node.js script. It worked. We shipped it. Five days later we rewrote the entire backend in Rust. Here's why we chose Rust over Node.js for a local-first CLI tool, and what the numbers actually look like.

## The numbers

| Metric | Node.js prototype | Rust (current) |
|--------|-------------------|----------------|
| Binary/bundle size | ~80MB (bundled runtime) | 15MB |
| Cold startup to listening | 2.3s | 0.4s |
| Parse 500 JSONL sessions | 4.1s | 0.9s |
| Peak RSS (500 sessions) | 340MB | 85MB |
| Runtime dependencies | node_modules tree | Zero |

These aren't synthetic benchmarks. They're measurements from the same MacBook Air M2 with real session data — about 500 JSONL files totaling 180MB.

## Memory-mapped parsing

The biggest win came from `mmap`. In Node, reading a JSONL file means `fs.readFileSync` or streaming — either way the file contents land in V8's heap. With mmap, the OS maps the file directly into the process address space. We scan the bytes in place without copying.

Combined with `memchr`'s SIMD-accelerated byte search, we can pre-filter lines before parsing JSON. Most lines in a JSONL file are message content — only a fraction are the metadata lines we need for session listings. Skipping non-matching lines without JSON parsing saves roughly 40% of parse time.

```rust
// SIMD pre-filter: only parse lines containing "type"
let finder = memmem::Finder::new(b"\"type\"");
for line in mmap_bytes.split(|&b| b == b'\n') {
    if finder.find(line).is_none() {
        continue; // skip without parsing
    }
    if let Ok(msg) = serde_json::from_slice::<Message>(line) {
        // process message
    }
}
```

Node.js can't do this. V8 doesn't expose mmap, and even with `Buffer` tricks you're still copying data across the native boundary.

## Zero runtime dependencies

When a user runs `npx claude-view`, the npm wrapper downloads a single static binary from GitHub Releases. No `node_modules`. No Python. No Rust toolchain. The binary has everything baked in — the HTTP server (Axum), the SQLite engine (rusqlite with bundled SQLite), the search index (Tantivy), and the React frontend (embedded as static assets via `rust-embed`).

This matters more than it sounds. `node_modules` introduces supply chain attack surface, version conflicts, and platform-specific native module compilation. A static Rust binary eliminates all three. We verify downloads with SHA256 checksums and publish with npm provenance attestation via Sigstore.

## SQLite without an ORM

Local state lives in SQLite via `rusqlite` — session metadata, search indexes, user preferences. In Node, you'd typically use `better-sqlite3` (which compiles a C extension on install) or Prisma (which downloads a query engine binary). In Rust, `rusqlite` with the `bundled` feature compiles SQLite from source as part of the build — no native module surprises, no download steps.

We batch all writes in transactions. A typical session index update touches 50-200 rows; wrapping them in a single transaction takes it from 200ms to 8ms.

## The trade-offs

Rust is not free. Development velocity is genuinely slower. A refactor that would take 30 minutes in TypeScript takes 2 hours in Rust, mostly fighting the borrow checker on lifetime issues in async code. Compile times on a clean build are about 45 seconds.

We mitigate this with `cargo-watch` for hot reloading (rebuilds only changed crates, usually 3-5s) and by keeping the frontend in React with Vite HMR. The Rust code changes less frequently than the UI — it's the stable core that parses, indexes, and serves data.

## When Node.js is the right call

For web servers, API gateways, or anything where developer velocity matters more than binary size — Node.js is excellent. We still use it for the npx CLI wrapper, the Cloudflare Workers, and our build tooling.

The calculus changes for local-first developer tools. Users install your tool alongside their own projects. A tool that adds 80MB and takes 3 seconds to start competes poorly with one that adds 15MB and starts instantly. Developer tools are judged by the experience of running them, and Rust lets us deliver an experience that feels native because it is native.


--- blog/zero-config-npx-distribution.mdx ---

---
title: "Zero-Config Developer Tools: The UX of npx Distribution"
description: "How we distribute a Rust binary through npm so users get a native tool with one command and zero configuration."
date: 2026-02-03
author: claude-view team
---

The best developer tools are the ones you don't have to think about installing. Zero-config distribution through npx means a single command — no build tools, no runtime dependencies, no configuration files. Here's how we built that experience for a Rust binary and what we learned about the UX of distribution.

## The distribution problem

claude-view is a Rust binary. Users shouldn't need Rust installed. They shouldn't need Docker. They definitely shouldn't need to clone a repo and compile from source. The installation experience should be:

```bash
npx claude-view
```

That's it. Browser opens. You're looking at your sessions.

## How the npx wrapper works

The `claude-view` npm package is a thin Node.js wrapper — about 150 lines of code. When you run `npx claude-view`, it:

1. **Detects your platform** — `process.platform` + `process.arch` gives us `darwin-arm64`, `darwin-x64`, `linux-x64`, or `linux-arm64`
2. **Checks for a cached binary** — stored in `~/.claude-view/bin/` so repeat runs skip the download
3. **Downloads from GitHub Releases** — fetches the platform-specific tarball for the matching version
4. **Verifies the SHA256 checksum** — every release publishes a `checksums.txt` signed by the CI pipeline
5. **Extracts and executes** — unpacks the tarball, sets the executable bit, and spawns the server process

The entire wrapper is 12KB. The downloaded binary is ~15MB. Total time from `npx` to browser open is about 3 seconds on a first run, sub-second after that.

## Why not the alternatives

**`cargo install`** requires a working Rust toolchain. About 5% of developers have Rust installed. We'd be asking 95% of our users to install a 500MB toolchain to build a 15MB binary.

**Homebrew** is macOS-only (Linuxbrew exists but has low adoption). It also requires us to maintain a tap formula, handle bottle builds, and deal with Homebrew's own update cadence. We added it as a secondary option, but it can't be the primary path.

**Docker** is a non-starter for local-first tools. claude-view reads JSONL files from `~/.claude/projects/` — bind-mounting your home directory into a container raises permission issues, breaks symlinks, and adds latency to file watchers. Plus, Docker Desktop on macOS uses a Linux VM, so file access goes through VirtioFS.

**curl | bash** works but users rightly distrust it. npm's provenance chain (Sigstore attestation, npm audit signatures) gives a stronger trust signal than a raw curl script.

## npm provenance and supply chain security

Every published version of `claude-view` on npm includes a Sigstore provenance attestation. This cryptographically links the published package to a specific GitHub Actions workflow run, commit SHA, and source repo. You can verify it:

```bash
npm audit signatures
```

The binary checksums are generated in CI and published alongside the GitHub Release. The npx wrapper verifies the checksum before execution — if someone tampers with the binary on the CDN, the hash won't match and the tool refuses to run.

## The port and auto-open dance

Default port is 47892 — chosen to be unlikely to conflict with anything. If it's taken (maybe you're already running a session), the server tries ephemeral port allocation and prints the actual URL. The npx wrapper captures the server's stdout, parses the port, and opens your default browser with `open` (macOS) or `xdg-open` (Linux).

One subtle detail: the server binds the port and prints the URL *before* starting any background work like indexing. This means the browser opens immediately even if the server is still scanning your session files. The UI shows a loading state until data arrives. Users perceive this as fast because the window appears instantly.

## Lessons from zero-config distribution

The biggest lesson: **every prompt is friction**. We removed the config file. We removed the port selection. We removed the "which sessions directory" question (we auto-detect `~/.claude/projects/`). The default behavior should be correct for 99% of users. The 1% who need custom paths can set `CLAUDE_VIEW_SESSIONS_DIR`.

Developer tools live or die by their first-run experience. If `npx your-tool` doesn't produce a useful result in under 5 seconds, most developers won't try again. Treat distribution as a product feature, not an afterthought.


--- changelog/v0.1.1.md ---

---
title: "v0.1.1 — First Public Release"
date: 2026-01-27
version: v0.1.1
---

## New features

- Session browser with instant search and project grouping
- Rich conversation previews with syntax-highlighted code, rendered markdown, and HTML export
- Ships binaries for macOS (ARM & Intel), Linux x64, Windows x64
- Zero-config: `npx claude-view` opens at localhost:47892

## Improvements

- First public release — foundational architecture established

## Getting started

```bash
npx claude-view
```


--- changelog/v0.11.2.md ---

---
title: v0.11.2 — Plans, Prompts & Teams
date: 2026-03-08
version: v0.11.2
---

## New features

**Plan Tab** — View Claude Code plans (`.claude/plans/`) directly in the session detail panel. Plans are parsed, indexed, and linked to sessions via slug. No more hunting through files.

**Prompt History** — Full-text search across all prompts you've sent to Claude Code. Browse by intent (feature, debug, refactor), see template usage patterns, and get statistics on prompt types. Includes Drain clustering for automatic template detection.

**Teams Dashboard** — Dedicated teams view showing team leads, inbox messages, team tasks, and file changes across team members. End-to-end team intelligence powered by `~/.claude/teams/` config files.

**Unified Project & Branch Design Tokens** — Consistent color and typography tokens for project names and branch labels across all views (live monitor, history, dashboard).

## Improvements

- **Agent tool support** — `Agent` tool now extracts `subagent_type` like the legacy `Task` tool. Full parity with prompt history pipeline.
- **Builtin tools registry sync** — 5 missing tools (verify-before-completion, receiving-code-review, requesting-code-review, executing-plans, dispatching-parallel-agents) now in BUILTIN_TOOLS registry.
- **File history paths** — Resolve paths from hashes + improved diff UI for new/deleted files.
- **OAuth cache timing** — Server-driven cache control for usage pill updates.
- **Phantom filter wiring** — All prompt history filters now fully wired (display, paste, clipboard).

## Getting started

```bash
npx claude-view
```

## What's next

- Mobile app enhancements (Expo SDK 56 upgrade)
- Custom session layouts (drag-and-drop column resizing)
- Codex historical + live verification protocols


--- changelog/v0.12.0.md ---

---
title: v0.12.0 — Plugin Manager
date: 2026-03-09
version: v0.12.0
---

## New features

**Plugin Manager** — A full GUI for browsing, installing, enabling, disabling, and uninstalling Claude Code plugins directly from the claude-view web UI. No terminal needed.

**Plugin Card Grid** — Each installed plugin renders as a card showing name, status, scope (user or project), and version. A health banner at the top shows plugin system status at a glance.

**Marketplace Dialog** — Browse available plugins and install them with a scope picker (user-level or project-level). Debounced search filtering across all plugin cards for instant discovery.

**Plugin Actions** — Right-click or use the action menu on any plugin card to enable, disable, or uninstall with a confirmation dialog. All actions correctly forward the scope parameter to the underlying CLI.

## Improvements

- **Full TUI data parity** — Plugin cards now display the same data as `claude plugin list` terminal output (description, installed scope, enabled state, version).
- **Server-side CLI caching** — Plugin list output is cached with a 5-minute TTL (CachedUpstream pattern), so the page loads instantly on repeat visits.
- **ANSI stripping** — Raw CLI escape codes are stripped server-side before reaching the browser. No more garbled text in toast messages or error dialogs.
- **Scoped mutations** — Enable, disable, install, and uninstall all forward the correct scope parameter. Previously only install passed scope, leaving other actions broken for project-scoped plugins.
- **Mobile: Expo SDK 55 compatibility** — Updated react-native-screens (4.23.0), expo-router (55.0.4), platform-gated push notifications on web, cleaned up EAS build artifacts.
- **Registry** — New `invocables_for_plugin` method for querying plugin-specific invocable tools.

## Getting started

```bash
npx claude-view
```

## What's next

- Plugin usage analytics (which plugins you use most, per-session breakdown)
- Mobile plugin management (view and toggle plugins from the Expo app)
- Plugin dependency graph visualization


--- changelog/v0.12.1.md ---

---
title: v0.12.1 — Project-Scoped Plugin Actions
date: 2026-03-09
version: v0.12.1
---

## Fixes

**Project-scoped plugin actions** — Fixed a bug where uninstalling, enabling, or disabling a project-scoped plugin failed silently because the CLI subprocess wasn't given the correct working directory. The `projectPath` field is now wired end-to-end from the Rust backend through the API response, TypeScript types, React components, and back to the CLI subprocess as its CWD.

**Update All for project plugins** — The "Update All" button now correctly passes each plugin's `projectPath`, so bulk updates work for project-scoped plugins that require CWD context.

## Improvements

- **E2E test suite for Plugins page** — 26 Playwright tests covering API contract, search/filter, card interactions, action menu, health banner, marketplaces dialog, and keyboard accessibility. The Plugins page is now fully guarded against regressions.
- **Scope flag forwarding** — `--scope` is now only passed to the CLI for `install` and `uninstall` actions, matching the Claude CLI's actual behavior. Enable/disable use auto-detection.

## Getting started

```bash
npx claude-view@latest
```

## What's next

- Plugin usage analytics (which plugins you use most, per-session breakdown)
- Mobile plugin management (view and toggle plugins from the Expo app)
- Plugin dependency graph visualization


--- changelog/v0.13.0.md ---

---
title: "v0.13.0 — Workflows and Live Chat"
date: 2026-03-11
version: v0.13.0
---

## New features

**Workflow system** — Create, browse, and run multi-stage workflows from a dedicated Workflows page. Each workflow has a VS Code-style detail layout with a Mermaid diagram preview, YAML editor, and a streaming LLM chat rail that generates workflow definitions in real time. The runner tab shows stage columns, attempt cards, and a progress bar. Two built-in seed workflows ship out of the box: Plan Polisher and Plan Executor.

**Unified live chat** — The live session view now combines history and real-time messages in a single scrollable conversation. No more switching between tabs to see what happened before you opened the session versus what's happening now.

**Recently closed sessions** — When a session ends, it appears in a "Recently Closed" section on the Live Monitor instead of vanishing. Dismiss individual sessions or clear them all. Closed sessions persist across server restarts via SQLite.

**Dynamic model list** — The model selector now fetches available models from the backend instead of using a hardcoded list. Full model IDs are shown in tooltips for disambiguation.

**Queued message indicators** — User messages waiting in the queue appear as pending bubbles with a "Queued" badge, so you can see what's been sent but not yet processed.

## Improvements

- **Workflow sidecar runner** — Stage execution with gate polling and automatic crash recovery in the Node.js sidecar process.
- **Queue operation metadata** — System messages and queue operations now carry metadata through WebSocket events to the event cards.
- **Production hardening** — Six security and correctness fixes for the workflow endpoints.
- **Live monitor polish** — Resume button, consistent labels, batched SQLite writes, and FileEvent persistence.

## Getting started

```bash
npx claude-view@latest
```


--- changelog/v0.14.0.md ---

---
title: "v0.14.0 — Open in IDE, @Mentions, and Agent Chat"
date: 2026-03-11
version: v0.14.0
---

## New features

**Open in IDE** — Files referenced in your Claude Code sessions now have a one-click button to open them directly in your editor. claude-view auto-detects VS Code, Cursor, Zed, and other installed editors. The button appears in the Changes tab, file headers, and Kanban project headers. Your preferred editor is remembered across sessions.

**@File mention chips** — When Claude references files during a session, the `@filename` mentions are extracted and shown as chips on session cards in both the Live Monitor and session history. Hover a chip to see the full path.

**Agent SDK live chat upgrades** — The live chat rail now renders thinking blocks, tool calls, and tool results with full syntax highlighting and collapsible sections. A mode selector lets you switch between Control and Review modes. A token usage gauge shows how much of the context window is in use.

**Teams: members vs sub-agents** — The team panel now clearly separates human team members from Claude sub-agents spawned during the session. The layout is cleaner and easier to scan at a glance.

## Improvements

- **`teamName` extraction fixed** — Now correctly read from the top-level JSONL field instead of a phantom `input.team_name` path that never existed in real data.
- **Branch metadata guard** — Fixed a bug where `apply_jsonl_metadata` could overwrite an existing branch value with `None`.
- **File history filenames** — Resolved by content hash rather than `backupFileName`, which was unreliable for renamed files.
- **Live monitor animation** — Compacting card animation strengthened with border and glow pulse for clearer visual feedback.

## Getting started

```bash
npx claude-view@latest
```


--- changelog/v0.15.0.md ---

---
title: "v0.15.0 — Unified Search, Sidecar Rewrite, and Persistent Teams"
date: 2026-03-12
version: v0.15.0
---

## New features

**Unified search engine** — Search now uses Tantivy full-text indexing as the primary engine, with automatic ripgrep fallback when the index returns no results. A SQLite pre-filter narrows candidates by project, date, and model before the full-text pass. Results from the grep fallback are labeled "Substring matches" so you can see which engine answered.

**Sidecar ground-up rewrite** — The Node.js sidecar has been rewritten for Agent SDK v0.2.72 with a new typed protocol (27 server events, 8 client messages), a permission handler for `canUseTool` routing, a pure event mapper for all 22 SDK message types, and a session registry with sequenced event emission. Resume URL and pipe deadlock bugs are fixed.

**SSE-driven live data** — The live monitor now receives session data via server-sent events instead of polling, eliminating stale-cache risks.

**Persistent team browsing** — Team composition and inbox messages are now reconstructed from JSONL files on disk when the in-memory store is cold. Teams survive server restarts without losing member or message history.

**Evidence audit Phase 3** — Every `release.sh` run now verifies field coverage (6,874 paths) and detects phantom fields (struct fields with zero occurrences in real data) across all JSONL files as a pre-release gate.

## Improvements

- **Single-pass team summaries** — JSONL reconstruction for team summaries now does one pass instead of multiple, reducing startup I/O.
- **Search scope removed** — The scope selector has been removed from the frontend; the backend handles scope internally for a cleaner interface.
- **Session count accuracy** — `/api/search` now returns a true `total_sessions` count rather than a capped estimate.

## Getting started

```bash
npx claude-view@latest
```


--- changelog/v0.16.0.md ---

---
title: "v0.16.0 — Zero-Config Cloud Features"
date: 2026-03-12
version: v0.16.0
---

## New features

**Zero-config sharing and auth** — Supabase and relay URLs are now baked into the distributed binary at CI build time. `npx claude-view@latest` works with sharing and auth enabled out of the box — no env vars, no setup.

**Self-hosting stays clean** — Building from source (`cargo build`) produces a binary with no embedded URLs. Cloud features are opt-in: set `SUPABASE_URL`, `SHARE_WORKER_URL`, and `SHARE_VIEWER_URL` to enable them.

## Improvements

- **Self-hosting guide** — README now explains the opt-in cloud features model clearly, with instructions for running fully local.
- **Expanded feature docs** — npx README reorganized into grouped sections covering all major features.

## Getting started

```bash
npx claude-view@latest
```


--- changelog/v0.17.0.md ---

---
title: "v0.17.0 — System Monitor"
date: 2026-03-12
version: v0.17.0
---

## New features

**System Monitor page** — A new sidebar section shows real-time CPU, memory, and disk usage for your machine alongside your Claude sessions. Open it to see live gauges and a top-process list, all streaming via server-sent events.

**Animated gauges** — Gauge values tween smoothly using a rAF-based animation hook. Values interpolate between readings instead of snapping, making CPU spikes and memory changes easy to track visually.

**Live process list** — Processes are grouped and normalized by name, sorted by CPU usage, and updated in real time. See what your machine is actually doing while your agents run.

**Staggered card reveal** — On first load, monitor cards animate in sequentially for a clean entry.

## Improvements

- **Async correctness** — `std::thread::sleep` moved into `spawn_blocking`; the system observer no longer blocks the async runtime.
- **SSE event alignment** — `init` and `snapshot` event names now match between the Rust backend and the React frontend.

## Getting started

```bash
npx claude-view@latest
```


--- changelog/v0.19.0.md ---

---
title: v0.19.0 — Unified Model Catalog
date: 2026-03-14
version: v0.19.0
---

## New features

**Unified Model Catalog** — single source of truth for all model metadata including pricing, context windows, and capabilities. Eliminates scattered hardcoded model data and ensures accurate cost calculations across all supported Claude models.

## Fixes

**Sidebar Deduplication** — fixed duplicate project entries appearing when sessions were indexed after server startup. Non-worktree sessions now resolve `git_root` inline during indexing instead of relying on a one-shot startup backfill.

**Status Line** — suppressed curl response body from leaking into terminal output.

## Getting started

```bash
npx claude-view@latest
```


--- changelog/v0.2.0.md ---

---
title: "v0.2.0 — Security & UI Redesign"
date: 2026-01-30
version: v0.2.0
---

## New features

- Semantic card components for conversation UI redesign

## Improvements

- Hardening/security robustness across the application

## Getting started

```bash
npx claude-view
```


--- changelog/v0.2.1.md ---

---
title: "v0.2.1 — First Automated Release"
date: 2026-02-02
version: v0.2.1
---

## New features

- Full JSONL parsing — all 7 message types rendered
- Compact/Full toggle, syntax-highlighted code blocks, dark mode
- Analytics dashboard — token/model tracking, metrics engine, git correlation
- Rust backend (Axum) ~15MB binary, parallel JSONL indexing with mmap + SIMD

## Improvements

- SHA256 checksum verification, npm provenance attestation via Sigstore
- 4-platform CI builds

## Getting started

```bash
npx claude-view
```


--- changelog/v0.2.2.md ---

---
title: "v0.2.2 — Performance & Dark Mode"
date: 2026-02-02
version: v0.2.2
---

## New features

- Full dark mode support
- Thread visualization
- Paginated messages API

## Improvements

- Rusqlite write phase, typed struct dispatch, SIMD pre-filter, batch transactions, gzip compression
- Tail-first loading with infinite scroll

## Getting started

```bash
npx claude-view
```


--- changelog/v0.2.3.md ---

---
title: "v0.2.3 — Performance & Thread Viz"
date: 2026-02-02
version: v0.2.3
---

## New features

- Thread visualization and paginated messages API
- Auto re-index on data changes
- ErrorBoundary for graceful error handling

## Improvements

- ~8,000 lines changed across 98 files
- Performance: rusqlite, SIMD pre-filter, batch transactions, gzip, timing instrumentation
- Tail-first loading, infinite scroll, dark mode polish
- busy_timeout for database resilience
- Security hardening

## Getting started

```bash
npx claude-view
```


--- changelog/v0.2.4.md ---

---
title: "v0.2.4 — Plugin Dedup & CI"
date: 2026-02-03
version: v0.2.4
---

## New features

- README "Why claude-view?" highlights section

## Improvements

- Fix duplicate plugin entries in skill registry
- Cargo.toml version verification in release workflow

## Getting started

```bash
npx claude-view
```


--- changelog/v0.21.0.md ---

---
title: v0.21.0 — Single-Stream Chat & Linux Support
date: 2026-03-16
version: v0.21.0
---

## New features

**Single-Stream Chat Architecture** — replaced the dual-source merge model with a single-stream source selection pattern. User messages now echo back through the WebSocket, giving one source of truth for the full conversation. Auto-connect on page load, replay-complete signaling, and graceful buffer exhaustion make live sessions rock-solid.

**Linux Keychain Credentials** — added a `secret-tool` backend for reading Claude credentials from GNOME Keyring / Secret Service on Linux. Path scanning is now platform-universal.

**Session Integrity** — one WebSocket per session enforced (second connection closes the first with code 4001). No more stale state from duplicate connections.

**Token & Cost Attribution** — token/cost totals and sub-agent cost breakdowns are now visible in the session UI. Context window breakdown shows Used total and Available capacity.

## Improvements

- Install tracking worker at `get.claudeview.ai` for download analytics
- Cross-platform release script (replaced BSD-only `sed -i`)
- Sidecar rebuilds correctly in preview, start, and dist:test scripts
- Removed macOS-specific `/opt/homebrew` from NPX path scan

## Getting started

```bash
npx claude-view@latest
```


--- changelog/v0.23.0.md ---

---
title: v0.23.0 — Accurate Context Gauge & Shell Install
date: 2026-03-19
version: v0.23.0
---

## New features

**Shell Install** — install Claude View with a single command: `curl -fsSL https://get.claudeview.ai | sh`. Auto-detects your platform, fetches the latest binary, and adds it to PATH. No Node.js required.

## Fixes

**Context Gauge Accuracy** — fixed live sessions showing inflated context usage percentages (e.g. 84% when actual fill was 12%). The gauge now uses Claude Code's own statusline data as the authoritative source, with a 4-tier priority fallback chain.

## Improvements

- 49 new tests covering all chat lifecycle features: SDK hooks, watching mode, sidebar badges, race condition prevention, optimistic message dedup, and context gauge accuracy
- 3 regression tests guarding previously-fixed bugs
- Fixed 11 pre-existing test failures across multiple components

## Getting started

```bash
curl -fsSL https://get.claudeview.ai | sh
# or
npx claude-view@latest
```


--- changelog/v0.24.0.md ---

---
title: v0.24.0 — Multi-Session Chat
date: 2026-03-24
version: v0.24.0
---

## New features

**Multi-Session Chat (VSCode-style tabs)** — open multiple Claude Code sessions side-by-side in a dockview tabbed layout. Drag tabs to split horizontally or vertically. Each panel maintains its own connection, scroll position, and state.

**ConversationBlock Pipeline** — a new Rust-native block accumulator parses JSONL into structured conversation blocks (user, assistant, progress, system, notice, turn boundary). Served via `?format=block` REST endpoint and real-time WS block mode.

**FSM Chat Panel** — chat sessions are driven by a finite state machine with explicit phases (nobody → acquiring → active), typed events, and deterministic transitions. Eliminates an entire class of race conditions between connection, history load, and live streaming.

**Developer Mode Overhaul** — ToolCard, EventCard, CategoryFilterBar, and ThinkingIndicator replace the old raw-JSON terminal view. Toggle between Chat and Developer modes per session.

**Session Source Detection** — sessions are automatically classified by launch source (Terminal, IDE, Agent SDK) via parent process inspection. SourceBadge shown across all three pages.

**Message Threading** — parentUuid propagation enables indented sub-agent message display in ConversationThread.

**Share Viewer Migration** — the share viewer now uses the same ConversationThread + ConversationBlock rendering as the main app.

## Improvements

- Direct TCP sidecar connection (port 3001) replaces Unix socket relay
- Worktree-state and forkedFrom JSONL types fully handled in parser
- Live session sidebar groups by urgency with source badges
- Sub-agent block view with WS error surfacing
- Sidebar project deduplication via real path GROUP BY
- EventSource auto-retry on transient SSE connection errors
- Loading indicator while fetching history blocks
- PII-check pre-commit hook
- ~5,800 lines of deprecated code removed (RichPane, ActionLogTab, ComparisonGallery)
- Evidence audit baseline updated for new Claude CLI fields

## Getting started

```bash
npx claude-view@latest
```


--- changelog/v0.24.1.md ---

---
title: "v0.24.1 — Share Viewer Developer Mode"
date: 2026-03-24
version: v0.24.1
---

## Fixes

**Share viewer developer mode** — The share viewer now has a proper Chat/Developer toggle matching the main app's design. Developer mode shows the full execution trace with filter chips (User, Assistant, MCP, Tool, etc.), so shared conversations can be inspected in detail.

**Share blob raw data** — Share blobs now include raw JSON data from the session, enabling accurate developer mode rendering with proper tool cards, system events, and metadata.

## Getting started

```bash
npx claude-view@latest
```


--- changelog/v0.25.0.md ---

---
title: "v0.25.0 — Block Pipeline Polish"
date: 2026-03-25
version: v0.25.0
---

## New features

**Developer Rich mode — SOTA polish** — Developer Rich rendering has been overhauled with improved visual hierarchy, contrast, and information density. Block cards now use consistent spacing, semantic color coding, and better typography for scanning long execution traces.

**Enhanced block renderers** — New dedicated renderers for sidechain blocks, image blocks, hook metadata, and retry events. Each block type now has a purpose-built card with proper icons, expandable details, and dark mode support.

**Block pipeline integrity audit** — New `block-pipeline-audit.sh` script and `/block-integrity` command that validates the full stack: Rust parser → generated TS types → React components → Storybook stories. Catches type drift and missing renderers before they ship.

## Improvements

**Chat mode visual identity** — Chat mode UI now uses a semantic visual identity with refined typography, spacing, and color language that distinguishes it from developer mode at a glance.

**Dark mode theme fixes** — Fixed error border contrast across shared packages by adding the `@source` directive for cross-package Tailwind scanning. Added missing `dark:` variants to 29 hardcoded color classes that were invisible in dark mode.

## Getting started

```bash
npx claude-view@latest
```


--- changelog/v0.26.0.md ---

---
title: "v0.26.0 — Session Monitoring & Live Statusline"
date: 2026-03-25
version: v0.26.0
---

## New features

**SOTA session monitoring hardening** — closed 5 gaps in session lifecycle tracking. Sessions are now identified by process ID instead of heuristics, eliminating misattribution when multiple Claude Code instances run in the same project.

**Live statusline via SSE** — Claude Code's statusline updates (current file, tool use, thinking state) now broadcast to the Live Monitor in real-time via Server-Sent Events. The chat panel receives this context too, so you can see what the agent is doing without switching views.

**PostHog telemetry integration** — opt-in analytics with a polished consent UX. The API key is baked into release builds so telemetry works out of the box for users who opt in — no configuration required.

## Improvements

**Batch process scanning** — process tree classification now batches `ps` calls instead of spawning one per session, reducing CPU overhead on machines with many concurrent sessions.

**PID-based session identity** — sessions use process IDs as their primary identity, replacing the previous heuristic approach that could confuse sessions sharing a working directory.

## Getting started

```bash
npx claude-view@latest
```


--- changelog/v0.26.1.md ---

---
title: "v0.26.1 — Production Proxy & Theme Fix"
date: 2026-03-26
version: v0.26.1
---

## Fixes

**Sidecar proxy for production** — added a reverse proxy in the Rust server for sidecar HTTP and WebSocket routes. In development Vite handles proxying to the sidecar on port 3001, but in production these requests were silently failing. The chat page now works correctly in production builds.

**Light mode in chat page** — DockviewReact was missing the `theme` prop, causing it to default to the dark Abyss theme regardless of system or user preference. The theme prop is now passed explicitly so light mode renders correctly.

## Improvements

**Smart port binding** — the server now reclaims ports from stale claude-view processes and auto-increments (up to +10) when the port is held by another app, instead of failing on startup.

**Stale sidecar cleanup** — zombie Node processes on the sidecar port are killed before spawning a new instance, preventing EADDRINUSE failures.

**Enterprise sandbox support** — respects `CLAUDE_VIEW_DATA_DIR` for telemetry config path and `CLAUDE_VIEW_SKIP_HOOKS=1` to skip hook registration in read-only environments.

## Getting started

```bash
npx claude-view@latest
```


--- changelog/v0.27.0.md ---

---
title: "v0.27.0 — Geist Fonts, Agent Cost Breakdown & Collapsible Groups"
date: 2026-03-26
version: v0.27.0
---

## New features

**Per-agent cost and token breakdown** — the cost tooltip now shows which model each subagent used and how many tokens it consumed. Scrollable overflow handles sessions with many agents.

**Agent group collapsing** — conversation threads with nested agent groups can now be collapsed and expanded. Rich renderers with JSON syntax coloring make agent output easier to scan.

**Persistent detail panel tab** — the Live Monitor remembers your last-selected detail panel tab across sessions, so you don't have to re-select it every time.

## Improvements

**Geist font system** — replaced Fira Code and Fira Sans with Geist Sans and Geist Mono for a cleaner, more modern look across the entire app.

**Apple HIG type scale** — all font sizes normalized to Apple Human Interface Guidelines, giving consistent visual hierarchy from sidebar labels to conversation content.

**"Not signed in" FAQ** — new troubleshooting guide in the README covering credentials file, macOS Keychain, token expiry, and HOME environment issues.

## Getting started

```bash
npx claude-view@latest
```


--- changelog/v0.28.0.md ---

---
title: "v0.28.0 — On-Device AI, Component Dashboard & Settings Polish"
date: 2026-04-02
version: v0.28.0
---

## New features

**On-device AI with oMLX** — claude-view can now run a local LLM for phase classification. Managed lifecycle with auto-detect, spawn, restart, and graceful shutdown. Model switching with a curated registry, RAM guard, and HuggingFace download with resume, cancel, speed and ETA display.

**Smart phase classification** — 93% GPU waste reduction through an exponential backoff drain loop. The classifier now uses EMA stabilization with temp-diversified voting, settling into a dimmed badge state when sessions go idle.

**Component dashboard** — the System Monitor replaces the self-app row with a full component view showing sidecar and oMLX metrics including VRAM usage, CPU, RAM, and session count per component.

**Harness v3** — the Live Monitor gains a needs-you sidebar grouped by project/branch with collapsible headers, plus a redesigned Harness view with Design/Delivery swimlanes.

**Help dropdown** — new Help button in the header with keyboard shortcuts, release notes link, and feedback link. Auto-scrolls to the shortcuts section.

## Improvements

**Settings page polish** — feature scope labels, unified card headers, GitHub star CTA, release notes link, build date in About, improved Mobile Pairing and Privacy UX.

**SessionCoordinator** — 4-phase mutation pipeline (lifecycle, statusline, reconcile, control) replacing the monolithic manager. The 4337-line manager.rs was decomposed into 8 focused modules.

**25 hook events** — expanded from 14 to 25 Claude Code hook events with explicit match arms for every event type.

**Full API as MCP tools** — OpenAPI spec generation with utoipa annotations, automatic codegen producing 85 MCP tools from the spec.

**Unified block pagination** — single source of truth for all block consumers, fixing pagination state loss after format changes.

## Getting started

```bash
npx claude-view@latest
```


--- changelog/v0.29.0.md ---

---
title: "v0.29.0 — Entrypoint Badges, FSM Unification & Local CI"
date: 2026-04-02
version: v0.29.0
---

## New features

**Session entrypoint badges** — history session cards now show how each session was started: CLI, VS Code, SDK, or other entrypoints. Visual badge on each card so you can filter and identify sessions at a glance.

**Unified local CI pipeline** — new `./scripts/ci-local.sh` runs 8 sequential quality gates before every release: TS lint, typecheck, and tests; Rust clippy and workspace tests; evidence audit; Storybook build; and integrity gates. The release script now runs full local CI automatically.

## Improvements

**FSM-unified session views** — all session views (history, live, watching) now run on a single finite state machine, replacing the legacy TanStack hook chain. Removed 5,841 lines of duplicated state management and fixed pagination drift that had been present for a month.

**Stable scroll anchoring** — fixed `onStartReached` callback instability across all pagination consumers. Inline anonymous functions and conditional ternaries replaced with stable `useCallback` references, fixing silent scroll anchoring breakage in Virtuoso.

**Keyboard navigation fix** — arrow keys in the sidebar no longer hijack focus from the chat input. Global keyboard navigation removed from sidebar to prevent input stealing.

**Agent name parsing** — the block pipeline now parses `agent-name` JSONL entries for better sub-agent identification in conversation views.

**Evidence baseline sync** — added a baseline-to-parser sync guard that prevents stale evidence drift, catching schema changes before they ship.

## Getting started

```bash
npx claude-view@latest
```


--- changelog/v0.3.0.md ---

---
title: "v0.3.0 — Git Integration"
date: 2026-02-09
version: v0.3.0
---

## New features

- Session discovery & navigation
- Git integration & AI contribution tracking

## Improvements

- Improved session indexing and project detection

## Getting started

```bash
npx claude-view
```


--- changelog/v0.30.0.md ---

---
title: "v0.30.0 — On-Device AI, Hook Events & Sub-Agent Pagination"
date: 2026-04-05
version: v0.30.0
---

## New features

**On-Device AI settings** — redesigned settings card with a provider-agnostic architecture. Select models from a dropdown, connect to any OpenAI-compatible endpoint, and manage local LLM integrations without oMLX-specific tooling.

**Hook events in conversation** — hooks now render as conversation blocks across three paths: live WebSocket streaming, historical API, and JSONL replay. See your pre/post tool hooks inline with the rest of the conversation.

**Sub-agent pagination** — sub-agent block views now paginate, so large agent sessions with hundreds of blocks load incrementally instead of all at once.

**Server-side activity aggregation** — the Activity page now uses a dedicated `rich_activity()` database function, replacing client-side computation with faster, more accurate server-driven data.

## Improvements

**Sidecar memory fix** — removed `listSessions()` which spawned a full CLI process (900MB+ per call) on every invocation. The sidecar health endpoint now includes memory diagnostics for easier monitoring.

**Historical sub-agent sessions** — sub-agent WebSocket connections now fall back through live → recently_closed → database, fixing failures for 99% of sessions that aren't currently live.

**CLI plugin stdout fix** — prevented Node.js stdout truncation at 64KB in CLI plugin commands by switching from pipe to tempfile-based output.

**Block accumulator robustness** — string-content user messages (not just array-content) are now correctly parsed by the block accumulator, fixing silent data loss.

**Architecture cleanup** — centralized session mutations into a shared multiplexed WS hook, extracted pagination to a coordinator-level module, and introduced an AppState builder pattern for the server.

## Getting started

```bash
npx claude-view@latest
```


--- changelog/v0.30.1.md ---

---
title: "v0.30.1 — Data Integrity & Activity Fixes"
date: 2026-04-05
version: v0.30.1
---

## Fixes

**Monitor data correctness audit** — fixed all 15 findings from a comprehensive data audit. Eliminated `FROM sessions` leaks, added missing `project_path` filters, and upgraded all remaining 2-way project filters to 3-way (include/exclude/all) across trends, snapshots, insights, and contributions.

**Activity heatmap & sparkline** — charts now correctly respect the selected time range filter instead of showing all-time data. Daily timeline fetches on demand.

**Activity page binding** — fixed time range binding, project sort order, and backup session ingest. Removed a dead hook and protected backup sessions from premature pruning.

**PhaseBadge dynamic model** — badge now reads provider/model from settings instead of hardcoded values, and hides when on-device AI is turned off.

## Improvements

**App data consolidation** — all app data now lives under `~/.claude-view/`. One directory to manage, backup, or delete.

## Getting started

```bash
npx claude-view@latest
```


--- changelog/v0.31.0.md ---

---
title: "v0.31.0 — Historical Conversation Blocks"
date: 2026-04-06
version: v0.31.0
---

## New features

**Historical InteractionBlocks** — Plan and Question blocks are now synthesized from historical JSONL data. Your full conversation timeline is complete even for sessions recorded months ago — not just live or recent ones.

## Improvements

**Cost estimate accuracy** — plugged a 1-hour cache drift that was silently skewing token cost estimates. System message render gaps also resolved.

**Crash-aware sidecar supervisor** — replaced naked `node --watch` with a supervisor that detects crashes and restarts cleanly, eliminating silent failures during development.

**Dev orchestration cleanup** — replaced a 400-character inline `concurrently` command with a maintainable orchestrator script. Added `dev-cleanup.sh` to kill orphan processes (not just ports) after dev sessions.

**Sidecar ownership gate** — `CLAUDE_VIEW_SIDECAR_EXTERNAL` env var prevents the Rust server from spawning the sidecar in dev mode, eliminating the race between `tsx watch` and the production spawn path that caused phantom WebSocket failures.

## Getting started

```bash
npx claude-view@latest
```


--- changelog/v0.32.0.md ---

---
title: "v0.32.0 — Complete Block Pipeline Coverage"
date: 2026-04-06
version: v0.32.0
---

## New features

**Attachment blocks** — files added or removed from Claude's context mid-session are now visible as structured blocks in developer mode. See exactly what context changes happened and when.

**Permission mode change blocks** — when Claude's permission mode shifts during a session (e.g. from default to bypassPermissions), it now appears as an explicit event in the timeline rather than being invisible.

**Scheduled task fire blocks** — when a scheduled task triggers and spawns a Claude agent, the trigger event is now rendered in the session timeline.

## Improvements

**Hook progress blocks de-duplicated** — event and hook name were duplicated between the block header and the body. The body now shows only the status message and command, while the header carries the full event→name label.

**Stdout no longer silently truncated** — hard `.slice()` caps on hook command output and stdout have been removed. Long outputs now display in full. Height caps were also raised for better readability.

**Block pipeline exhaustiveness enforced at compile time** — the renderer switch is now a compile-time exhaustiveness check. Adding a new system block variant without a matching renderer is a type error, not a runtime blank.

## Getting started

```bash
npx claude-view@latest
```


--- changelog/v0.33.0.md ---

---
title: v0.33.0 — Teams, Transcripts & ~/.claude
date: 2026-04-07
version: v0.33.0
---

## New features

**Team Debate Transcripts** — view multi-agent discussions as clean conversation transcripts with progressive disclosure. Non-technical users see the debate flow; engineers can expand technical details. Dedicated cards for agent messages, moderator prompts, verdicts, and round dividers.

**Team Sidechains** — drill into sub-agent activity per team member. See per-sidechain cost and token usage, model info, timestamps, and duration. Event-driven refresh via inbox versioning — no polling.

**Team Cost Breakdown** — per-member cost breakdown with crown indicator for highest-spending member. Visible across all surfaces: sidebar, detail panel, and overview.

**~/.claude Integration** — browse your Claude Code memory files, settings, MCP servers, active sessions, and todos directly from the dashboard. Two-phase rollout: memory viewer + settings (Phase 1), MCP + active sessions + todos (Phase 2).

**Memory Page Redesign** — 2-column layout with resizable panel, type badges, and per-type memory counts.

**Sessions Directory Watcher** — live monitor now detects new sessions via filesystem watcher with startup scan and crash detection.

## Improvements

- SessionCard layout redesign with amber as the new primary color
- Member Sessions moved from bottom panel to resizable right sidebar
- SSE-driven real-time team updates (replaces polling)
- Snapshot team data before deletion for recovery
- Member discovery from inbox filenames, not just senders
- External schema fields made optional to survive upstream SDK changes
- Stable-sort hook block merge to eliminate timestamp violations
- Block pipeline drift check added as CI gate 7

## Getting started

```bash
npx claude-view@latest
```


--- changelog/v0.33.1.md ---

---
title: "v0.33.1 — Cost & Tasks Fixes"
date: 2026-04-07
version: v0.33.1
---

## Fixes

**Correct cost total in Overview tab** — the Overview tab now includes team sidechain costs in the total, matching the Cost tab and session card.

**Tasks tab for historical sessions** — the Tasks tab no longer disappears when persistent task files are cleaned up after a session ends. Falls back to progress items already parsed from JSONL.

## Getting started

```bash
npx claude-view@latest
```


--- changelog/v0.33.2.md ---

---
title: "v0.33.2 — Architecture Decomposition"
date: 2026-04-09
version: v0.33.2
---

## Improvements

**Decomposed monolithic Rust files into focused modules** — split ~69K lines of code across 3 batches into single-responsibility modules, improving build parallelism and code navigability.

**Extracted 4 new independent crates** — `server-process-tree`, `server-live-state`, `server-types`, and `server-local-llm` now compile in parallel with the main server crate, reducing incremental build times.

**Fixed 49 E2E test failures** — updated routes, selectors, and skip gates to match the new module structure.

**Scrubbed PII from doc comments and tests** — removed personally identifiable information from code documentation and test fixtures.

## Getting started

```bash
npx claude-view@latest
```


--- changelog/v0.34.0.md ---

---
title: "v0.34.0 — Cross-Platform, Terminals & Webhooks"
date: 2026-04-12
version: v0.34.0
---

## New features

**Native Linux support** — linux-x64 binary now ships in every release. No more `CLAUDE_VIEW_ALLOW_LINUX=1` env var bypass.

**Interactive CLI terminals** — tmux CLI sessions render as real xterm terminals inside Chat and Monitor pages. Close button on terminal tabs lets you manage multiple sessions.

**Webhook notifications API** — CRUD API for managing webhooks with Lark and Slack formatters. HMAC-SHA256 signed deliveries with automatic retry. Test-send endpoint for validating configs before going live.

**Session ownership model** — new `OwnershipTier` type replaces the old `LiveStatus` enum. Cleaner session lifecycle with pid.json as the single root for live detection. All session list, sidebar, and badge components rewired.

**Unified interaction UI** — plan approvals, permission prompts, and user questions surface through a single interaction card system. `bypassPermissions` flows through the full plan approval path.

**API authentication** — API key generation and validation with `cv_live_` prefix format. Tower middleware with automatic localhost bypass for local development.

## Improvements

**Zero-data-loss block rendering** — 17 missing system variant renderers added to chat mode. Missing fields added across TurnBoundary, ToolChip, ToolCard, Interaction Cards, NoticeBlock, ProgressBlock, UserBlock, and AssistantBlock. TeamTranscriptBlock renderers for both chat and dev modes.

**Claude Code plugin expansion** — marketplace manifest for one-click plugin install. 18 MCP tools unlocked. System-monitor, live, and usage skills. OpenAPI drift check ensures all handlers stay documented.

**Cross-platform terminal backend** — replaced node-pty with Rust-native portable-pty, removing the native addon dependency that caused ABI mismatch issues.

**Storybook gallery** — AllBlocks mega-story for scrollable full gallery. 3-column comparison layout with a11y addon.

**12 state-swallowing gaps closed** — error reasons now carry through the full pipeline instead of being silently dropped.

**TaskItem deserialization fixed** — 23% of task files were silently dropped due to missing field defaults.

## Getting started

```bash
npx claude-view@latest
```


--- changelog/v0.34.1.md ---

---
title: "v0.34.1 — Rust Toolchain & Nextest"
date: 2026-04-12
version: v0.34.1
---

## Improvements

**Pinned Rust toolchain to 1.94.1 stable** — ensures reproducible builds across all contributors and CI environments with `rust-toolchain.toml`.

**cargo-nextest routing in cq** — `./scripts/cq test` now automatically routes through `cargo-nextest` when installed, falling back to `cargo test` for `--doc` tests or when `--` args are present. Faster test execution with better output formatting.

**Rust tests added to pre-push gate** — lefthook pre-push now runs `cq test --workspace` alongside clippy and cargo-deny, catching test failures before they reach CI.

## Getting started

```bash
npx claude-view@latest
```


--- changelog/v0.35.0.md ---

---
title: "v0.35.0 — Ownership & Performance"
date: 2026-04-12
version: v0.35.0
---

## New features

**Session Ownership Model** — every session now carries computed ownership data (SDK-spawned, tmux-managed, or standalone CLI) enriched at both REST and SSE boundaries. No extra client requests needed — ownership is always available for display and filtering.

**Runtime Configuration** — new `config.toml` file with feature toggles. Configure behavior without recompiling the server.

**Eager CLI Session Ownership** — CLI sessions resolve ownership immediately on discovery with automatic stale refresh, so tmux and SDK relationships appear instantly.

## Improvements

**50% smaller binary** — two-profile build split and feature-gated swagger reduce the release binary from 35MB to 17MB.

**50MB heap reduction** — two-phase Tantivy writer releases search index heap after bulk indexing completes.

**Lazy sidecar initialization** — the Node.js sidecar no longer spawns at startup, only on first use. Faster cold start.

**Accurate macOS memory** — process monitor now reports physical footprint instead of inflated RSS values.

**Per-block error isolation** — one malformed block in a conversation no longer crashes the entire chat view. Each block renders independently with its own error boundary.

**Plugin remote install** — fixed npm source and npx MCP pattern so `claude plugin install` works from the registry.

**Shared tab components** — extracted reusable `TabContent` and `TabContextMenu` from dockview, reducing duplication across chat and monitor panels.

## Getting started

```bash
npx claude-view@latest
```


--- changelog/v0.36.0.md ---

---
title: "v0.36.0 — PID Lifecycle & Terminal Panes"
date: 2026-04-13
version: v0.36.0
---

## New features

**PID-driven session lifecycle** — session detection now uses PID files as the single source of truth, replacing process tree scanning. A unified session store eliminates the dual-store split, and a two-tier oracle refresh (PIDs every 2s, full system every 10s) keeps the dashboard accurate with lower CPU overhead.

**Zed-level terminal panes** — new terminal pane layout with chrome elimination, zoom, auto-layout, and keyboard shortcuts. Each session gets a single identity — no more duplicate CLI panels.

**Spawning status indicator** — sessions now show a pulsing blue dot while booting. The Born handler enriches spawning sessions from tmux POST so you see the session the moment it appears.

**CLI beta banner** — experimental banner variant with dismiss functionality for upcoming CLI features.

## Improvements

**Tmux ownership reconciliation** — server restarts no longer leave ghost sessions. Ownership is reconciled from tmux state on startup.

**Bounded closed session ring** — replaced unbounded HashMap with a VecDeque(100) ring buffer for closed sessions, capping memory usage.

**Stabilized active sessions selector** — useMemo-wrapped selector prevents spurious re-renders in the Live Monitor.

**Dockview layout persistence** — layout saves now flush on unload, visibility-hidden, and unmount — no more lost layouts on browser close.

**PID publisher resilience** — the oracle handles RecvError::Lagged by resyncing instead of dying, preventing silent monitoring gaps.

## Getting started

```bash
npx claude-view@latest
```


--- changelog/v0.36.1.md ---

---
title: "v0.36.1 — TLS Crash Fix"
date: 2026-04-13
version: v0.36.1
---

## Fixes

**macOS ARM startup crash** — fixed a panic during deep indexing caused by rustls 0.23+ failing to auto-detect the TLS crypto provider. Cargo feature unification compiled both `ring` and `aws-lc-rs` into the binary; the server now explicitly installs `aws-lc-rs` as the process-level CryptoProvider before any network I/O. Also applied to the relay binary for consistency.

## Getting started

```bash
npx claude-view@latest
```


--- changelog/v0.37.0.md ---

---
title: "v0.37.0 — Archived Projects & Zero-Poll Resolution"
date: 2026-04-14
version: v0.37.0
---

## New features

**Archived project detection** — projects whose directories no longer exist on disk are automatically detected and rendered in a collapsed "Archived" section within the Scope panel. A new `project_dir_status` table tracks directory existence, with smart startup backfill that probes each project directory without blocking the server.

**Zero-poll PID resolution** — the "born waiter" pattern replaces polling for CLI session identity resolution. An FSEvents watcher races against a 50ms fallback poll — in production, the watcher wins with sub-millisecond latency. New lifecycle debug instrumentation captures the full timing waterfall from `POST /api/cli-sessions` through to session identity resolution.

## Improvements

**Single-writer event-driven architecture** — eliminated dual-path data flow where both imperative fetch and reactive SSE could create the same entity. Buttons now own fetch; parents react to callbacks. SSE syncs existing state but never creates.

**Double session spawn fix** — fixed a race where new CLI sessions could spawn two tmux processes instead of one.

**Oracle stability** — fast ticks no longer blank the top processes and disk gauges in the system monitor. Resource snapshots use Option-based fields to distinguish "not yet collected" from "empty."

**Git root inference** — worktree paths now correctly walk up the directory tree to find the real `.git` root, fixing project detection for repos using `git worktree`.

## Getting started

```bash
npx claude-view@latest
```


--- changelog/v0.37.1.md ---

---
title: "v0.37.1 — Trust Dialog Auto-Accept for npx Users"
date: 2026-04-14
version: v0.37.1
---

## Fixes

**First-run hang from untrusted directories** — `npx claude-view` could hang indefinitely when starting a CLI session from a directory Claude hadn't previously trusted (like `$HOME`). Claude CLI was blocking on its interactive "trust this folder?" dialog, but nobody was there to press Enter in the detached tmux pane, so the session never wrote `pid.json` and the API timed out with a 503 after 5 seconds. claude-view now sends Enter to the tmux pane automatically 1s and 2s after creation to auto-accept the dialog. For already-trusted directories the poll resolves in under 300ms and the Enter is a harmless no-op.

## Improvements

**Nested session detection** — CLAUDE* environment variables are now stripped from the tmux command when spawning CLI sessions. This prevents Claude CLI from mis-detecting a nested session when the claude-view server is itself launched from inside a Claude Code terminal.

## Getting started

```bash
npx claude-view@latest
```


--- changelog/v0.38.0.md ---

---
title: v0.38.0 — Production Observability
date: 2026-04-15
version: v0.38.0
---

## New features

**Unified Observability Stack** — a new `claude-view-observability` crate provides structured JSON logging with daily rolling files, correlation IDs, panic crash logs, and opt-in Sentry integration across the entire Rust workspace.

**Request ID Propagation** — every HTTP request gets a ULID `x-request-id` header that flows through WebSocket init frames, block pipeline phases, and tmux environment variables. Trace any operation end-to-end from browser to CLI session.

**Crash Logs** — unhandled panics now write `crash-*.log` files with full backtraces to `~/.claude-view/logs/`, so you can diagnose issues even when the process exits unexpectedly.

**OTLP Export** — behind the `otel` feature flag, send traces to any OpenTelemetry-compatible backend (Jaeger, Grafana Tempo, Datadog) for custom dashboards.

**Linux ARM64 Binaries** — the release pipeline now builds for `linux-arm64`, supporting ARM servers and Raspberry Pi.

## Improvements

- Release pipeline hardened with artifact verification contracts, build provenance attestations, and post-publish smoke tests
- Dev-loop recompile time cut 24-43% via Cargo profile tuning
- OpenAPI spec now includes field descriptions for all observability structs
- Dead dependencies removed from `claude-view-core`
- Anthropic pricing data synced to latest official rates

## Getting started

```bash
npx claude-view@latest
```


--- changelog/v0.39.0.md ---

---
title: v0.39.0 — Stability and Analytics Polish
date: 2026-04-28
version: v0.39.0
---

## New features

**Tokens and Cost Hero Cards** — total tokens processed and total cost now sit at the top of the analytics page, above everything else. The headline numbers shouldn't have to be scrolled to.

**CLI Terminal Tab** — a new tab for tmux-managed sessions. Env-probe discovery resolves `TMUX_PANE` from the CLI process's environment, so attaching to an existing session "just works."

**Auto-Recap Blocks** — when Claude Code emits an `away_summary` block (the recap it writes when you return after stepping away), claude-view now renders it as a proper system event in both chat and developer mode instead of falling through to a generic block.

**Devices and Pairing Endpoints** — server-side scaffolding for paired-device support: `/api/devices`, `/api/pairing/qr`, JWT-authenticated relay protocol, Supabase-backed device registry with PII-aware RLS isolation. The receiving mobile client lands in a follow-up.

## Improvements

- **No more freeze at 100+ closed sessions.** Live Monitor's reconciler cooldown is replaced with lazy sidecar recovery so the UI stays responsive even with hundreds of historical sessions on screen (#53, #54).
- **Sidecar memory bounded.** Per-session stream buffers now cap, with heap telemetry to catch regressions early — the slow leak under heavy load is fixed (#54).
- **Blue-green search index migration.** When the search index schema bumps, the previous version keeps serving queries while the new one builds in the background. No more "rebuilding index, please wait" on startup.
- **Quieter chat mode.** Hook noise and empty assistant blocks are hidden in chat mode for a cleaner conversation view.
- **Worktree hooks fixed.** `WorktreeCreate` is a *replacement* hook — async observers were silently breaking `isolation: worktree`. Hooks now have explicit replacement-vs-observer taxonomy with a 3-layer defense.
- **Cleaner relay logs.** WebSocket lazy-start stops spamming auth-rejected logs when nothing is paired.
- **Pricing data updated.** Opus 4.7 added with a boot-time drift detector to flag stale pricing tables.
- **Six-month database rebuild landed.** A multi-phase CQRS-style rewrite splits the writer hot path from the read path through `session_stats`, `session_flags`, and `session_action_log` tables, with a `stage_c_outbox` for reliable cross-table fanout. The legacy `sessions` table is gone.
- **`rustls-webpki` security bump** — 0.103.12 → 0.103.13 (RUSTSEC-2026-0104).

## Getting started

```bash
npx claude-view@latest
```


--- changelog/v0.4.0.md ---

---
title: "v0.4.0 — Dashboard Analytics"
date: 2026-02-10
version: v0.4.0
---

## New features

- Time range filter with presets (today, 7d, 30d, 90d, all time)
- Heatmap tooltips and Git sync redesign with SSE
- AI generation breakdown with model usage distribution
- Storage overview with donut chart
- Project/branch filters

## Improvements

- 65% fewer database round-trips (26 → 9 queries)
- 17 production-readiness fixes, epoch-zero guards
- 922+ tests (548 backend, 374+ frontend)

## Getting started

```bash
npx claude-view
```


--- changelog/v0.4.1.md ---

---
title: "v0.4.1 — Patch Release"
date: 2026-02-10
version: v0.4.1
---

## New features

- No new features in this patch release

## Improvements

- Bug fixes and stability improvements following v0.4.0

## Getting started

```bash
npx claude-view
```


--- changelog/v0.4.2.md ---

---
title: "v0.4.2 — Patch Release"
date: 2026-02-11
version: v0.4.2
---

## New features

- No new features in this patch release

## Improvements

- Bug fixes and stability improvements

## Getting started

```bash
npx claude-view
```


--- changelog/v0.4.3.md ---

---
title: "v0.4.3 — Chat Insights & Worktrees"
date: 2026-02-11
version: v0.4.3
---

## New features

- Chat Insights & Pattern Discovery (Theme 4)
- Unified session detail API endpoints
- Git worktree session support with DB file_path fallback
- Resume button for quick session re-entry

## Improvements

- Release script bumps all version sources

## Getting started

```bash
npx claude-view
```


--- changelog/v0.4.4.md ---

---
title: "v0.4.4 — Mission Control Phase A"
date: 2026-02-11
version: v0.4.4
---

## New features

- Live session monitoring dashboard
- Continue This Chat (Cmd+Shift+R) with context summary
- Unified Settings page (merged System status)
- Cold start UX with bandwidth-aware progress tracking

## Improvements

- Streamlined navigation with consolidated settings

## Getting started

```bash
npx claude-view
```


--- changelog/v0.4.5.md ---

---
title: "v0.4.5 — Multi-View & HTML Export"
date: 2026-02-14
version: v0.4.5
---

## New features

- Multi-view support: Grid, List, Kanban, Monitor
- Live filtering by status, project, branch
- Keyboard navigation (j/k, 1-4, Enter, ?)
- Command palette (Cmd+K)

## Improvements

- HTML export upgrade: dark/light toggle, metadata header, collapsible thinking blocks

## Getting started

```bash
npx claude-view
```


--- changelog/v0.40.0.md ---

---
title: v0.40.0 — Trustworthy OAuth Pill and Plugin Cleanup
date: 2026-04-29
version: v0.40.0
---

## New features

**Trustworthy OAuth usage pill** — the rate-limit pill now recognises six new Anthropic windows (`seven_day_opus`, `seven_day_omelette`, `seven_day_oauth_apps`, `seven_day_cowork`, plus extras), groups tiers by kind in the tooltip (Session / Weekly windows / Additional / Extra usage), and hides any bucket whose utilization is unknown or that has been quietly decommissioned. Goodbye misleading "Weekly Sonnet 0%, no reset" pill.

**Multi-currency `extra_usage`** — non-USD spend (EUR, etc.) renders correctly with the actual currency code instead of a fabricated dollar sign.

**Subagent attribution metadata recognised** — Claude Code 2.1.123 added `attributionAgent`, `attributionSkill`, and `attributionPlugin` to sidechain JSONL entries. claude-view's evidence audit now baselines these so future schema additions don't break the integrity gate while we work on surfacing the data in the UI.

## Improvements

- **Plugin: `/usage` renamed to `/cv-usage`.** Claude Code shipped a built-in `/usage` skill that shadowed the plugin's. Updating it to `cv-usage` (matching the npm package) keeps both addressable. Update bookmarks and aliases.
- **Legacy Tantivy session-search index fully removed.** Post-v0.39.0 cleanup — the search migration is complete.
- **Webhook engine integration test stabilised.** Bumped the poll deadline from 5s to 15s to fix a race that surfaced under full nextest load on M-series hardware.
- **Plugin SKILL.md reference tables now match the live OpenAPI spec.** OAuth endpoint descriptions are concrete paths (`GET /api/oauth/usage`) instead of generic labels.
- **Backend OAuth handler split into 5 focused files** (`oauth/{mod,anthropic,tiers,identity,handlers}.rs`), and the OAuth pill component into 6 (`oauth-usage-pill/{format,statusline-overlay,tier-row,tooltip-content,types}`). Both well inside the CLAUDE.md size ceilings.

## Getting started

```bash
npx claude-view@latest
```


--- changelog/v0.41.0.md ---

---
title: v0.41.0 — Truthful Telemetry, App Store Privacy, Plan Badge
date: 2026-05-18
version: v0.41.0
---

## New features

**Default-on anonymous usage analytics with one-command opt-out.** Official builds now report which features and screens are used so development is guided by real usage — never code, prompts, paths, or session content. A one-time notice prints on first run. Turn it off permanently with `CLAUDE_VIEW_TELEMETRY=0`. Builds from source send nothing. A closed event taxonomy enforces this in the schema, not just in policy.

**`installed` acquisition event** fires exactly once per machine, deduplicated by a persistent anonymous ID, so adoption is measurable without double-counting on every server restart.

**Plan-mode badge on session cards (#61).** When a session is in plan mode, a `Plan` badge appears on the card — but only when the session is *actually* in plan mode, never guessed. Following the project's "trust over accuracy" principle: better to show nothing than show something wrong.

**Sub-agent ordering on cards (#62).** Sub-agents now sort running + newest first. The visible slice surfaces the most relevant agents, and the "+N more" overflow hides the oldest instead of the working ones.

**Full privacy policy at [claudeview.ai/privacy](https://claudeview.ai/privacy/)** with Apple App Store privacy nutrition labels, third-party processor list, retention, and your rights. Privacy copy is now consistent across all 10 README translations.

## Fixes

- **`install_source` detection rewritten.** The old detection matched `.cache/claude-view` in the binary's exe path — broken by the `~/.cache → ~/.claude-view` migration earlier in the year, silently misclassifying every `install.sh` install as `npx`. Now uses an explicit marker file beside the binary; install.sh / npx / plugin installs are correctly distinguished and survive `CLAUDE_VIEW_INSTALL_DIR` overrides.
- **Statusline wrapper** moved to `~/.claude-view/statusline-wrapper.sh`, matching the app-data-dir rule. Sandbox-setup script updated to match.
- **AudioContext unlock** for notification sounds. `audioUnlocked` state now mirrors the real browser context state instead of being set optimistically. The "click the page to enable sound" hint only shows when the browser genuinely blocks audio.
- **Notification sound** guarded against concurrent re-entrancy.
- **Cloudflare landing-page cache rule.** Removed a `/*` catch-all that was concatenating `max-age=0, must-revalidate` onto every fingerprinted asset, forcing edge revalidation on every request (the cause of the ~0% cache hit rate on `_astro/*`).
- **`~/.cache → ~/.claude-view` cleanup swept** — the last four shipped references (npx-cli error message, npx-cli README, package.json dev scripts, classifier test fixtures) now point at the real location. Users following the old `rm -rf ~/.cache/claude-view/` error hint no longer hit a dead path.

## Improvements

- **`permission_mode` threaded end-to-end** from Claude Code hooks through the mutation pipeline to the UI, with full type-safety and Latest-wins semantics.
- **Indexer `stop_hook_summary` parser** simplified via Rust match guards (no behaviour change).
- **CI**: `scripts/cq` now pins clippy to `rust-toolchain.toml` so Homebrew's newer clippy can no longer shadow the pinned channel and false-fail the gate with style lints the project doesn't target.
- **`/api/telemetry/event`** + `Surface` / `ActionId` schemas registered in OpenAPI; the `telemetry_ingest_event` plugin tool is now exposed for explicit ingress.

## Getting started

```bash
curl -fsSL https://get.claudeview.ai/install.sh | sh
# or
npx claude-view@latest
```


--- changelog/v0.41.1.md ---

---
title: v0.41.1 — Telemetry quality fixes
date: 2026-05-20
version: v0.41.1
---

## Fixes

**`app_version` stamped on every server-captured telemetry event.** v0.41.0 server events reached PostHog without a version property, collapsing every install into a single bucket on rollout and adoption dashboards. From v0.41.1 forward, every server event carries `app_version = CARGO_PKG_VERSION` (compile-time const, override-resistant at the callsite), so version breakdowns populate cleanly as soon as users update.

## Improvements

**`posthog-js` bumped 1.362 / 1.356 → 1.374.2** in the web and share apps, clearing the SDK Doctor "outdated" warning. No API surface change; opt-in default, closed-enum event taxonomy, and disabled autocapture / pageview / session recording are all preserved.

## Getting started

```bash
npx claude-view@latest
```


--- changelog/v0.5.0.md ---

---
title: "v0.5.0 — Mission Control"
date: 2026-02-19
version: v0.5.0
---

## New features

- Biggest release — live agent monitoring dashboard
- Sub-agent visualization with swim lanes and drill-down
- Rich tool rendering with verbose mode
- Unified SessionDetailPanel (Overview, Sub-Agents, Timeline, Cost)
- Tantivy full-text search, Cmd+K palette
- Cost tracking with tiered cache pricing
- AI Fluency Score (0-100)
- Smart Rules Engine

## Improvements

- Major architecture overhaul for real-time monitoring

## Getting started

```bash
npx claude-view
```


--- changelog/v0.6.0.md ---

---
title: "v0.6.0 — Rebranded to claude-view"
date: 2026-02-20
version: v0.6.0
---

## New features

- Project renamed from vibe-recall to claude-view
- Hook events logging support
- Terminal view modes
- Context gauge auto-compact threshold marker

## Improvements

- Full rebrand across all packages and documentation

## Getting started

```bash
npx claude-view
```


--- changelog/v0.6.1.md ---

---
title: "v0.6.1 — Live Monitor Fix"
date: 2026-02-20
version: v0.6.1
---

## New features

- README rewrite with live monitoring focus

## Improvements

- Fixed Live Monitor blank on first load (isInitialized flag)

## Getting started

```bash
npx claude-view
```


--- changelog/v0.7.0.md ---

---
title: "v0.7.0 — Work Reports & Crash Recovery"
date: 2026-02-20
version: v0.7.0
---

## New features

- Work Reports page with expandable session details
- Token breakdown and cost analysis
- Sessions survive server crashes — v2 snapshot format
- Live session cards show MCP servers and skills
- `claude-view cleanup` CLI command

## Improvements

- CWD-based session discovery fixes

## Getting started

```bash
npx claude-view
```


--- changelog/v0.8.0.md ---

---
title: v0.8.0 — Mission Control
date: 2026-02-28
version: v0.8.0
---

## New features

**Mission Control** — real-time dashboard for all running Claude Code agents. See status, cost, and current tool calls live.

**Agent Control** — approve/reject tool calls, send messages to agents (requires cloud relay).

**Claude Code Plugin** — `@claude-view/plugin` ships as a native Claude Code plugin with 8 read-only MCP tools, 3 skills (`/session-recap`, `/daily-cost`, `/standup`), and a SessionStart hook that auto-starts the dashboard. Install with `claude plugin add @claude-view/plugin`.

**AI Fluency Score** — composite 0–100 metric measuring AI collaboration effectiveness.

## Improvements

- Full-text search now uses Tantivy for faster, more relevant results
- Cost tracking includes cache read/write breakdown
- Session browser shows model and git commit per session
- Performance: ~15MB binary with sub-second startup

## Getting started

```bash
npx claude-view
```


--- changelog/v0.9.0.md ---

---
title: v0.9.0 — Activity & Sharing
date: 2026-03-08
version: v0.9.0
---

## New features

**Activity Page** — calendar heatmap, project breakdown, daily timeline, and summary stats. See your Claude Code usage patterns at a glance.

**Conversation Sharing** — share any session via end-to-end encrypted link on share.claudeview.ai. Recipients view in-browser with zero setup. Your data is never readable by our servers.

**Content-based Session Classification** — sessions are automatically classified using SIMD pre-filter for fast, accurate categorization.

**Kanban Swimlane View** — organize sessions visually with drag-and-drop swimlanes.

**Bulk Select & Archive** — select multiple sessions and archive them in one action.

**Hook Event Tracking** — monitor Claude Code hook events (SessionStart, tool calls) directly in the dashboard.

## Improvements

- Session topology and cwd resolution from JSONL — project paths are sandbox-proof
- `CLAUDE_VIEW_DATA_DIR` env var for sandbox and corporate environments
- Mobile app pivot from PWA to Expo/React Native (Tamagui v2)
- Unified pipeline with batch reliability fixes (fixes 1–6)
- Project path resolution no longer depends on encoded directory names

## Getting started

```bash
npx claude-view
```


--- docs/docs.mdx ---

---
title: Getting Started
description: Install claude-view and start monitoring your Claude Code sessions in 15 seconds.
---

import { Steps } from '@astrojs/starlight/components';

**claude-view** is an open-source developer tool that monitors Claude Code sessions in real time. Watch token usage, costs, tool calls, and agent state — from your browser or phone.

**Zero config. One command.**

<Steps>
1. **Install** — run `curl -fsSL https://get.claudeview.ai/install.sh | sh` in any terminal
2. **Open** — your browser opens automatically at `http://localhost:47892`
3. **Monitor** — all active Claude Code sessions appear automatically
</Steps>

## What you'll see

- **Session browser** — searchable list of all past and active sessions
- **Mission Control** — live view of running agents with real-time cost tracking
- **Agent Control** — approve/reject tool calls, send messages (with cloud relay)
- **AI Fluency Score** — measure how effectively you collaborate with AI

## Requirements

- macOS (Apple Silicon or Intel) — Linux support in v2.1
- Claude Code installed and running
- Node.js 18+ only needed if using `npx claude-view` (shell install has no dependencies)

## Next steps

- [Installation →](/docs/installation/) — detailed setup, ports, and config
- [Mission Control →](/docs/features/mission-control/) — real-time agent monitoring
- [Claude Code Plugin →](/docs/guides/plugin/) — 8 tools, 3 skills, auto-start hook


--- docs/docs/features/agent-control.mdx ---

---
title: Agent Control
description: Send messages, approve tool calls, and resume Claude Code sessions from your web dashboard.
---

Agent Control lets you interact with running Claude Code sessions directly from the web dashboard — approve tool calls, send follow-up messages, review plans, or stop runaway agents.

## What you can do

- **Approve tool calls** — when an agent requests permission (e.g., `git push`), approve or reject from the dashboard
- **Send messages** — inject a follow-up message into the agent's conversation
- **Review plans** — approve or reject agent plans before implementation starts
- **Answer questions** — respond to agent clarification prompts (AskUserQuestion, Elicitation)
- **Stop agent** — gracefully stop a running session

## How it works

Agent control uses a Node.js sidecar process powered by the Claude Agent SDK. The sidecar connects to your running Claude Code sessions via IPC and exposes control actions through the claude-view web dashboard.

All control actions work **locally** — no cloud relay needed for web dashboard control.

## Remote control (mobile)

For controlling agents from your phone or a remote browser, the cloud relay is required. The relay forwards encrypted control messages between your device and the desktop server.

> **Pro plan** — Cloud relay access is included in the Pro tier (coming soon). The web dashboard is always free.

## Chat interface

The dashboard includes a full chat interface with:
- Streaming message display
- Interactive permission cards with countdown auto-deny
- Plan approval cards
- Elicitation/question response cards
- Session resume with cost estimation (ResumePreFlight)

## Related

- [Mission Control →](/docs/features/mission-control/) — live agent monitoring
- [Mobile Setup →](/docs/guides/mobile-setup/) — iOS and Android app setup
- [Claude Code Plugin →](/docs/guides/plugin/) — auto-start, 8 tools, 3 skills


--- docs/docs/features/ai-fluency-score.mdx ---

---
title: AI Fluency Score
description: Measure how effectively you collaborate with Claude Code agents.
---

The AI Fluency Score (0–100) measures how effectively you work with AI coding agents. It's a composite metric derived from session patterns, not a simple token count.

## What it measures

The score combines multiple signals:
- **Session efficiency** — cost per meaningful outcome (commits, files changed)
- **Cache utilization** — how well you leverage prompt caching
- **Session patterns** — consistent, focused sessions score higher
- **Recovery rate** — how quickly errors are resolved

## Interpreting your score

| Range | Level | Description |
|-------|-------|-------------|
| 0–39 | Beginner | Learning to work with AI agents effectively |
| 40–59 | Developing | Good fundamentals, room to optimize |
| 60–79 | Proficient | Consistent, effective AI collaboration |
| 80–100 | Expert | Highly optimized AI-first workflow |

## Improving your score

- **Keep sessions focused** — one task per session is more efficient than context-switching
- **Reuse context** — start sessions from the same project to maximize cache hits
- **Review tool calls** — unnecessary tool calls increase cost without outcomes

## Plugin access

After [installing the plugin](/docs/guides/plugin/), ask Claude Code directly:

```
"What's my AI Fluency Score?"
→ Uses get_fluency_score tool automatically
```


--- docs/docs/features/cost-tracking.mdx ---

---
title: Cost Tracking
description: Real-time token usage and USD cost tracking for all Claude Code sessions.
---

claude-view tracks token usage and cost for every session in real time.

## How costs are calculated

Token counts are read from Claude Code's JSONL event log (`~/.claude/projects/`). claude-view applies Anthropic's current pricing to calculate USD costs.

| Token type | Description |
|------------|-------------|
| Input | Tokens sent to Claude in the prompt |
| Output | Tokens generated by Claude |
| Cache read | Prompt cache hits (reduced cost) |
| Cache write | Tokens stored in prompt cache |

## Cache efficiency

The cache hit ratio shows what percentage of input tokens were served from the prompt cache. A higher ratio means lower costs. claude-view displays this prominently because it's one of the most actionable cost metrics.

## Daily / session breakdown

The dashboard shows:
- **Today's total cost** across all sessions
- **Per-session cost** in the session browser
- **Running total** in Mission Control (live updates)

## Cost & token breakdown popover

Hover over any cost figure in the live monitor or session detail to see a full breakdown:
- **Color-coded categories** — input tokens, output tokens, cache read tokens, and cache creation tokens each have a distinct color
- **Per-category estimated cost** based on current model pricing
- **Cache savings** highlighted in green, showing how much you saved from prompt cache hits
- Available in both the live monitor agent cards and the session detail panel

## MCP tools

Access cost data programmatically via the MCP server:
- `get_token_stats` — token usage with cache hit ratio
- `get_live_summary` — aggregate cost and status for today
- `get_stats` — dashboard overview with cost trends


--- docs/docs/features/mission-control.mdx ---

---
title: Mission Control
description: Real-time dashboard for monitoring and controlling all active Claude Code agents.
---

Mission Control is a live view of all running Claude Code sessions. It updates in real time via WebSocket — no refresh needed.

## What you see

Each agent card shows:
- **Status** — running (green), waiting for input (amber), done (gray), error (red)
- **Current task** — the most recent tool call or user message
- **Cost** — cumulative token cost for the session
- **Duration** — time elapsed since session start
- **Context gauge** — real-time context window usage
- **Cache countdown** — time until prompt cache expires
- **IDE file** — which file the user was editing when they last messaged

## Views

Mission Control offers three layout modes:
- **Grid** — compact card grid for monitoring many agents at once
- **List** — detailed single-column view with more information per session
- **Monitor** — live chat grid showing streaming conversations side by side
- **Kanban swimlanes** — group running sessions into visual swimlanes by project or branch. Use the group-by dropdown to switch between project grouping, branch grouping, or flat view. Swimlane headers show the project/branch name with session counts.

You can also create **custom layouts** using drag-and-drop panels (powered by dockview). Save and load layout presets.

## Cost tracking

Token costs update live as agents work. claude-view uses current Anthropic pricing per model (with tiered pricing for large contexts). The total across all active agents is shown in the header.

## Sub-agent visualization

When a session spawns sub-agents (via the Agent tool), Mission Control shows the full agent tree — parent and children, each with their own status and cost tracking.

## Session control

From Mission Control, you can:
- **Click a session** to open the full session detail view with chat history
- **Send messages** to a running agent
- **Approve or reject** tool call permissions
- **Review plans** before the agent implements them
- **Stop a session** (with confirmation)

## Hook events

Mission Control tracks hook events from two sources — live events captured in real-time via the file watcher (Channel A) and historical events backfilled from JSONL files (Channel B). Events are deduplicated automatically, so you see a complete timeline even for sessions that started before claude-view.

## Real-time updates

Mission Control connects via WebSocket to the claude-view server. Data refreshes every second. If the connection drops (network issue, server restart), it reconnects automatically with exponential backoff.

## Crash recovery

If the sidecar process crashes, Mission Control automatically detects stale bindings and recovers on the next startup. Active sessions resume monitoring without manual intervention.

## Related

- [Agent Control →](/docs/features/agent-control/) — interactive control details
- [Cost Tracking →](/docs/features/cost-tracking/) — detailed token usage breakdown
- [Session Browser →](/docs/features/session-browser/) — historical session list


--- docs/docs/features/search.mdx ---

---
title: Search
description: Grep search across all Claude Code sessions.
---

claude-view includes session search powered by Rust grep over Claude Code JSONL files. There is no persistent session search index to build, migrate, or repair.

## What's indexed

- All message content (user and assistant)
- Tool call inputs and outputs
- File paths referenced in sessions
- Session metadata (project, model, date)

## Using search

**In the UI:** Click the search bar or press `Cmd+K` / `Ctrl+K`.

**Via MCP:**
```
search_sessions(query: "authentication refactor", limit: 10)
```

## Search syntax

Search uses literal, case-insensitive matching:
- Plain text: `refactor auth module`
- Exact substrings: `git push origin`
- UI/API filters can narrow by project, model, and date before grep runs

## Performance

Search scans the filtered JSONL candidate set directly, so startup does not need to build a separate session search index.


--- docs/docs/features/session-browser.mdx ---

---
title: Session Browser
description: Search and browse all past and active Claude Code sessions.
---

The Session Browser is the main view in claude-view. It shows a searchable, filterable list of all Claude Code sessions detected on your machine.

## What's tracked

For each session:
- Project name and directory
- Start time, end time, duration
- Token counts (input, output, cache read, cache write)
- Total cost (USD)
- Model used (e.g., `claude-opus-4-5`, `claude-sonnet-4-5`)
- Git commit (if a commit was made during the session)

## Search

Grep search across all session content — tool calls, messages, and file names — without a separate session search index.

Search is available via:
- The search bar in the Session Browser
- `Cmd+K` / `Ctrl+K` global shortcut
- The MCP `search_sessions` tool

## Filters

Filter sessions by:
- **Project** — sessions grouped by project directory
- **Model** — filter by Claude model used
- **Date range** — sessions from a specific period
- **Status** — active, completed, or error sessions

## Bulk select & archive

Select multiple sessions using checkboxes (click the checkbox on each row, or use the bulk select mode toggle). An archive toolbar appears with options to archive the selected sessions. Filter state persists in the URL, so you can bookmark filtered views.

## Collapsible sidebar sections

The sidebar uses VS Code-style collapsible sections. Click any section header to collapse or expand it. Collapse state persists across sessions.

## Session detail

Click any session to see:
- Full conversation timeline (all messages, tool calls, results)
- Per-message token counts
- Tool call details (input/output)
- Timeline of events


--- docs/docs/guides/mobile-setup.mdx ---

---
title: Mobile App Setup
description: Set up the claude-view mobile app on iOS or Android.
---
import WaitlistForm from '../../../../components/WaitlistForm.astro';

The claude-view mobile app lets you monitor and control your Claude Code agents from your phone.

> **Status:** The mobile app is currently in development. Join the waitlist to be notified when it launches.

<WaitlistForm variant="compact" />

## Prerequisites

- claude-view server running on your desktop (`npx claude-view`)
- iOS 16+ or Android 12+
- Same network OR cloud relay (Pro tier)

## Coming soon

The mobile app will include:
- Real-time Mission Control view
- Push notifications for agent events (tool approvals, completions)
- Agent control (approve/reject tool calls, send messages)
- QR code pairing — scan once, connect automatically

## Pairing flow (preview)

1. Install the claude-view app (App Store or Google Play)
2. Open claude-view on desktop and click **Pair Mobile**
3. A QR code appears — scan it with the mobile app
4. Your phone connects securely via end-to-end encrypted relay

All data in transit is encrypted with NaCl (libsodium). The relay never sees decrypted content.

## Notifications

The mobile app receives push notifications when:
- An agent requests tool approval
- A long-running session completes
- An agent encounters an error

Notification delivery requires the cloud relay (Pro tier).


--- docs/docs/guides/plugin.mdx ---

---
title: Claude Code Plugin
description: Install the claude-view plugin for Claude Code — auto-starts the dashboard, adds 8 tools and 3 skills. One command, zero config.
---

import { MCP_TOOL_COUNT } from '../../../../data/site';

## Overview

`@claude-view/plugin` is a **Claude Code plugin** that gives Claude native access to {MCP_TOOL_COUNT} session tools and 3 skills — no manual `settings.json` editing required.

Install with one command:

```bash
claude plugin add @claude-view/plugin
```

## What you get

### Auto-start hook

Every time you start a Claude Code session, the plugin checks if the claude-view server is running. If not, it starts it in the background. The web dashboard appears at `http://localhost:47892` — no manual `npx claude-view` needed.

### {MCP_TOOL_COUNT} MCP tools

The plugin exposes {MCP_TOOL_COUNT} read-only tools via MCP (Model Context Protocol):

| Tool | Description |
|------|-------------|
| `list_sessions` | Browse sessions with filters (project, model, date, status) |
| `get_session` | Session detail with messages, tool calls, and metrics |
| `search_sessions` | Grep search across all conversations |
| `get_stats` | Dashboard overview — total sessions, costs, trends |
| `get_fluency_score` | AI Fluency Score (0–100) with breakdown |
| `get_token_stats` | Token usage with cache hit ratio |
| `list_live_sessions` | Currently running agents (real-time) |
| `get_live_summary` | Aggregate cost and status for today |

All tools are read-only. All data stays local — no external requests.

### 3 skills

| Skill | Description |
|-------|-------------|
| `/session-recap` | Summarize a specific session — commits, metrics, duration |
| `/daily-cost` | Today's spending, running sessions, token usage |
| `/standup` | Multi-session work log for standup updates |

## Example usage

```
"How much have I spent on Claude Code today?"
→ Uses get_live_summary

"Find my last session about authentication"
→ Uses search_sessions(query: "authentication")

"What's my AI Fluency Score?"
→ Uses get_fluency_score

/session-recap
→ Summarizes your most recent session

/standup
→ Generates a standup update from the last 24h
```

## Architecture

The plugin connects to the running claude-view server on `localhost:47892`. The auto-start hook ensures the server is always running when Claude Code starts.

```
Claude Code session starts
  → Plugin SessionStart hook fires
  → Hook checks localhost:47892/api/health
    → Running? Skip.
    → Not running? Spawn: npx claude-view (background)
  → MCP server registered via plugin .mcp.json
  → Claude has 8 tools + 3 skills available
  → Web dashboard at localhost:47892
```

## Prerequisites

- **Node.js 18+** — required by the MCP server
- The plugin auto-starts the server, but `npx claude-view` must be available (downloads the Rust binary on first run)

:::note[First run]
The very first session after install may take 5–30 seconds to download the Rust binary. The hook times out gracefully — the server starts in the background and will be ready for your next tool call or session.
:::

## Configuration

Set `CLAUDE_VIEW_PORT` to override the default port (47892). Both the hook and MCP client respect this variable.


--- docs/docs/installation.mdx ---

---
title: Installation
description: Install claude-view on macOS. Zero config — one command.
---

import { DEFAULT_PORT, PLATFORM } from '../../../data/site';

<script is:inline type="application/ld+json" set:html={JSON.stringify({
  "@context": "https://schema.org",
  "@type": "HowTo",
  "name": "Install claude-view",
  "description": "Install and start claude-view to monitor your Claude Code sessions. Zero config -- one command, 15-second setup.",
  "totalTime": "PT15S",
  "tool": [{"@type": "HowToTool", "name": "Terminal (macOS or Linux)"}],
  "step": [
    {"@type": "HowToStep", "position": 1, "name": "Run the install command", "text": "Open your terminal and run: curl -fsSL https://get.claudeview.ai/install.sh | sh"},
    {"@type": "HowToStep", "position": 2, "name": "Wait for download", "text": "The installer downloads the pre-built binary (~10MB) automatically. No Rust toolchain or compilation required."},
    {"@type": "HowToStep", "position": 3, "name": "Open the dashboard", "text": `claude-view starts a local server and opens your browser to http://localhost:${DEFAULT_PORT}. You'll see all active Claude Code sessions automatically detected.`}
  ]
})} />

## Quick install (recommended)

```bash
curl -fsSL https://get.claudeview.ai/install.sh | sh
```

That's it. Downloads a native binary (~10 MB) to `~/.claude-view/bin` and adds it to your PATH. No Node.js needed.

Then run:

```bash
claude-view
```

## npx (alternative)

If you prefer npm, you can also run:

```bash
npx claude-view
```

`npx` downloads the pre-built binary and starts the server. Requires Node.js {PLATFORM.nodeMin}+.

## Claude Code plugin

If you use Claude Code, install the plugin for the best experience — it auto-starts the server, adds 8 MCP tools, and 3 skills:

```bash
claude plugin add @claude-view/plugin
```

After installing, every Claude Code session automatically starts the dashboard. No manual `npx claude-view` needed. See the [plugin guide](/docs/guides/plugin/) for details.

## Requirements

<table>
  <thead>
    <tr><th>Requirement</th><th>Version</th></tr>
  </thead>
  <tbody>
    <tr><td>macOS</td><td>{PLATFORM.macosMin} or later</td></tr>
    <tr><td>Node.js</td><td>{PLATFORM.nodeMin} or later</td></tr>
    <tr><td>Claude Code</td><td>Latest</td></tr>
  </tbody>
</table>

> **Linux:** Supported in {PLATFORM.linuxVersion} (coming soon). Windows in {PLATFORM.windowsVersion}.

## What happens on first run

1. The installer downloads the pre-built `claude-view` binary for your platform (~10 MB)
2. Installs to `~/.claude-view/bin` and adds it to your PATH
3. Run `claude-view` — it starts a local HTTP server on port <code>{DEFAULT_PORT}</code>
4. Your default browser opens <code>http://localhost:{DEFAULT_PORT}</code>
5. claude-view scans for active Claude Code processes automatically

## Configuration

### Change the port

```bash
CLAUDE_VIEW_PORT=8080 npx claude-view
```

Or set permanently in your shell profile:

```bash
export CLAUDE_VIEW_PORT=8080
```

If port <code>{DEFAULT_PORT}</code> is unavailable, claude-view automatically falls back to an ephemeral port and prints the URL.

### Persistent binary (faster startup)

```bash
npm install -g claude-view
claude-view
```

Global install skips the `npx` download step on subsequent runs.

## Verify it's running

Open <code>http://localhost:{DEFAULT_PORT}</code> in your browser. You should see the session browser. If Claude Code is running, your active sessions appear automatically.

## Troubleshooting

**"Port {DEFAULT_PORT} already in use"**
Another instance is running. Kill it with `pkill claude-view` or use a different port.

**"No sessions found"**
Start a Claude Code session in another terminal: `claude`. Sessions appear within a few seconds.

**Binary download fails**
Check your Node.js version: `node --version`. Requires v{PLATFORM.nodeMin}+. If behind a proxy, set `HTTPS_PROXY`.


--- docs/docs/reference/api.mdx ---

---
title: API Reference
description: HTTP API endpoints exposed by the claude-view server.
---

The claude-view server exposes a REST API on `http://localhost:47892/api`. All endpoints return JSON.

## Sessions

### `GET /api/sessions`

Returns a list of sessions.

**Query params:**
- `limit` — max results (default: 50)
- `offset` — pagination offset
- `project` — filter by project name
- `model` — filter by model ID

### `GET /api/sessions/{id}`

Returns full session detail including messages and metrics.

### `GET /api/sessions/{id}/messages`

Returns all messages for a session.

### `GET /api/sessions/{id}/parsed`

Returns parsed session data.

## Live sessions

### `GET /api/live/sessions`

Returns currently active (running) sessions.

### `GET /api/live/sessions/{id}`

Returns detail for a specific live session.

### `GET /api/live/summary`

Returns aggregate stats for today's sessions.

### `GET /api/live/stream`

Server-Sent Events stream. Connect with `EventSource` for real-time updates.

**Events:**
- `session_update` — session status changed
- `live_update` — live session data refreshed

### `GET /api/live/pricing`

Returns current model pricing used for cost calculations.

## Stats

### `GET /api/stats/dashboard`

Returns dashboard overview: total sessions, costs, fluency score, trends.

### `GET /api/stats/storage`

Returns storage usage statistics.

## Search

### `GET /api/search?q=<query>`

Grep search across all session content.

**Query params:**
- `q` — search query (required)
- `limit` — max results (default: 20)

## Score

### `GET /api/score`

Returns the AI Fluency Score (0–100) with breakdown.

## Health

### `GET /api/health`

Health check endpoint. Returns server status.


--- docs/docs/reference/cli-options.mdx ---

---
title: CLI Options
description: Command-line usage, subcommands, and environment variables for claude-view.
---

import { DEFAULT_PORT } from '../../../../data/site';

## Usage

```bash
npx claude-view
```

Or if globally installed:
```bash
claude-view
```

The server starts, opens your browser, and begins discovering Claude Code sessions automatically.

## Subcommands

| Subcommand | Description |
|------------|-------------|
| `cleanup` | Remove stale lock files and temporary data |

```bash
claude-view cleanup
```

## Environment variables

<table>
  <thead>
    <tr><th>Variable</th><th>Description</th><th>Default</th></tr>
  </thead>
  <tbody>
    <tr><td><code>CLAUDE_VIEW_PORT</code></td><td>Override server port</td><td><code>{DEFAULT_PORT}</code></td></tr>
    <tr><td><code>PORT</code></td><td>Alternative port variable (fallback)</td><td>—</td></tr>
    <tr><td><code>RUST_LOG</code></td><td>Log level filter</td><td><code>warn</code></td></tr>
  </tbody>
</table>

## Examples

```bash
# Default — starts server and opens browser
npx claude-view

# Custom port via env var
CLAUDE_VIEW_PORT=8080 npx claude-view

# Verbose logging
RUST_LOG=info npx claude-view

# Debug logging for the server crate only
RUST_LOG=warn,claude_view_server=debug npx claude-view

# Clean up stale data
npx claude-view cleanup
```

## Port fallback

If the specified port (default <code>{DEFAULT_PORT}</code>) is unavailable, claude-view automatically binds to an ephemeral port and prints the actual URL. Logs show the actual address on startup.


--- docs/docs/reference/keyboard-shortcuts.mdx ---

---
title: Keyboard Shortcuts
description: Keyboard shortcuts for the claude-view web dashboard.
---

## Global

| Shortcut | Action |
|----------|--------|
| `Cmd+K` / `Ctrl+K` | Open search |
| `Escape` | Close dialog / clear search |
| `?` | Show keyboard shortcuts |

## Session browser

| Shortcut | Action |
|----------|--------|
| `↑` / `↓` | Navigate sessions |
| `Enter` | Open selected session |
| `F` | Toggle filters panel |

## Session detail

| Shortcut | Action |
|----------|--------|
| `←` | Back to session list |
| `T` | Jump to timeline |
| `Cmd+F` / `Ctrl+F` | Search within session |
