c9watch

See every Claude Code, Codex, Cursor Agent and Pi session on your machine — one dashboard for you, one JSON CLI for your agents.

Built with AI (Claude Code and Codex). A human sets direction, tests, and reviews. How this was built

c9watch (short for claude code watch, like k8s for Kubernetes) gives you a real-time view of every Claude Code, Codex, Cursor Agent, and Pi session running on your machine. A desktop dashboard for you, and a JSON CLI for your agents — both watching the same sessions at the same time.

You see which agent needs permission, which one is working, and which one is idle. Your agents can do the same — querying session status, searching past work, and coordinating with each other — all through the same tool.

Claude Code and Codex are fully monitored. Cursor Agent is monitor-only. Pi is read-only. OpenCode is a preview that needs a manual server connection. See Compatibility for what each one supports.

From the same author: rmdv

Demo

Works with everything. Tied to nothing.

Unlike other Claude Code management tools that require you to launch sessions from within their app, c9watch doesn't care where you start your sessions. It discovers them automatically by scanning running processes at the OS level.

Start Claude Code or Codex from any terminal or IDE you already use -- VS Code, Zed, iTerm2, Antigravity, you name it -- and c9watch picks them all up. No plugins to install. No workflows to change. No vendor lock-in.

Just open c9watch and see everything.

Lightweight and fast.

Built with Tauri, Rust, and Svelte -- not Electron. The app binary is small, memory usage is minimal, and the UI stays snappy. Rust handles process scanning and file parsing at native speed. Svelte compiles away the framework overhead. You're already running multiple Claude Code agents eating up resources -- your monitoring tool shouldn't add to the pile.

Install

Desktop app (macOS)

With Homebrew:

brew install --cask minchenlee/tap/c9watch

The cask installs the app only. To use the CLI, symlink it: ln -s /Applications/c9watch.app/Contents/MacOS/c9watch ~/.local/bin/c9watch.

Or with the install script, which also sets up the CLI:

curl -fsSL https://raw.githubusercontent.com/minchenlee/c9watch/main/install.sh | bash

This installs the app to /Applications and symlinks the CLI to ~/.local/bin/c9watch, so both the GUI and c9watch list, c9watch view, etc. work out of the box.

Or grab the latest .dmg from the Releases page (you'll need to symlink the CLI manually: ln -s /Applications/c9watch.app/Contents/MacOS/c9watch ~/.local/bin/c9watch).

CLI only (macOS & Linux)

curl -fsSL https://raw.githubusercontent.com/minchenlee/c9watch/main/install-cli.sh | bash

Installs to ~/.local/bin by default. Use | bash -s -- --global to install to /usr/local/bin instead.

Build from source

Prerequisites: Rust, Node.js (v18+), and the Tauri CLI.

git clone https://github.com/minchenlee/c9watch.git
cd c9watch
npm install
npm run tauri build       # Desktop app → src-tauri/target/release/bundle/macos/

To build just the CLI (no Node.js or Tauri CLI needed):

cd src-tauri
cargo build --release --no-default-features --features cli
# Binary → target/release/c9watch

Screenshots

Monitor -- see what needs your attention first

Sessions grouped by status. Permission requests surface to the top so you never leave an agent stuck waiting.

History -- browse and search past sessions

Search all past sessions with instant metadata filter and deep content search. Click a result to view the full conversation.

Cost -- track your spending

Daily, per-project, and per-model spending breakdowns across all your Claude Code sessions.

Conversation viewer -- inspect any session

Expand any session to see the full conversation with formatted markdown, code blocks, inline images, and a navigation sidebar.

Tray popover -- monitor without opening the dashboard

A quick-glance overlay showing all active sessions and their status directly from the menu bar.

Memory -- browse Claude Code memory files

View and inspect all Claude Code memory files in a two-panel layout with quick access to Claude commands.

Token distance -- visualize your usage

See your total token usage as a rice stack towering past real-world landmarks. Share the result as an Instagram-ready PNG.

CLI

The same c9watch binary doubles as a CLI for scriptable session management. All output is JSON, designed for piping into jq or consumption by other coding agents.

# List active sessions
c9watch list
c9watch list --project myapp --status Working --compact

# Aggregate status summary
c9watch status

# View a conversation (prefix matching works)
c9watch view abc123 --last 5 --pretty
# Use the provider-scoped key from `c9watch list` when IDs collide
c9watch view codex:<session-id> --last 5

# Browse and search history
c9watch history -n 20
c9watch search "fix the auth bug" --project myapp

# Identify the calling agent's own session
c9watch self

# Stop a session
c9watch stop 12345

# Watch for status changes (NDJSON stream, see docs/cli-events.md)
c9watch watch --interval 2 --compact --changes-only

# Block until a session needs you, finishes, or ends (exit 124 on timeout)
c9watch wait abc123 --until needs-input --timeout 600

# View tasks/todos for a session
c9watch tasks abc123

# Cost breakdown, including per-session lookup
c9watch cost --daily
c9watch cost --session abc12345 --pretty
c9watch cost --session codex:<session-id> --pretty
c9watch cost --session-prefix abc

Use --pretty on any command for human-readable JSON. The watch command streams newline-delimited JSON events (started, status_changed, stopped) for real-time monitoring.

c9watch ships with a Claude Code skill that teaches Claude how to use the CLI. Install it to let Claude Code monitor sibling sessions, search past work, and coordinate with other agents:

ln -s /path/to/c9watch/skills/c9watch-cli ~/.claude/skills/c9watch-cli

See SKILLS.md for more install options.

Features

• Zero-integration setup -- Works with any terminal or IDE, no plugins or extensions required
• Auto-discovery -- Detects running Claude Code, Codex, Cursor Agent, and Pi sessions automatically. OpenCode (preview) connects to one server you start yourself
• Provider filter -- Switch between All and each agent in Monitor, History, Cost, and Memory
• Attention inbox -- One list of the sessions that wait for you, with a health badge so a stale session does not look live
• While you were away -- Each waiting card shows what it waits for (approval of a named tool, a question, or your next prompt), the last thing the agent said, and what it did since you last looked (files edited, commands run, subagents done). Counted from the transcript on your machine, no AI summary. Activity counts are Claude Code only; other agents show "—"
• Real-time status -- See at a glance which sessions are Working, Need Attention (permission requests or user questions), or Idle
• Status accuracy matrix -- Every agent × situation cell (working, waiting, idle, killed, pid reuse, subagent) is backed by a test; known gaps are listed in docs/accuracy-matrix.md
• Conversation viewer -- Expand any session to view the full conversation with formatted markdown, code blocks, and inline images
• Session control -- Stop sessions, open their parent terminal/IDE, or rename them for easier tracking
• Multi-project view -- Sessions grouped by project with git branch info
• Tray popover -- Click the menu bar icon for a quick-glance overlay with session status indicators and latest messages
• Status notifications -- Get a native macOS notification when a session needs your attention
• Mobile/Web client -- Watch sessions from a phone or another browser over WebSocket. Remote access is off by default: turn on LAN access in Settings → Remote access, then pair the device with a one-time code or QR code from Connect Mobile. Conversations and opening a terminal from the device are separate opt-in settings. LAN traffic is plain ws://, so use it only on a network you trust. See docs/mobile-migration-c0h.md
• Session history -- Browse and search all past sessions with instant metadata filter and deep content search; click a result to scroll to and highlight the matching message
• Memory viewer -- Browse and inspect Claude Code and Codex memory files with a two-panel layout and quick Claude command access
• Cost tracker -- Track Claude Code spending, plus Codex and Pi cost data, with daily, per-project, and per-model breakdowns; click any session to preview the conversation; sort by date or cost
• Subscription usage -- Quota meters for Claude Code, Codex, and Cursor in the toolbar and tray, with an elapsed-time marker for each window
• Claude Code hook bridge (opt-in) -- c9watch hooks --install lets Claude Code report permission prompts directly; see docs/claude-hooks.md
• CLI for agents -- c9watch list, view, history, search, stop, watch, wait, cost commands for scriptable session management and agent-to-agent monitoring
• Subagent visibility -- Detect and display Task-tool subagents spawned inside any session, with click-to-preview transcripts
• Entry animations -- Staggered cascade transitions across tabs and overlay panels for fluid navigation
• Token distance visualizer -- See your token usage as a rice stack towering past 22 real-world landmarks, with animated stacking, native share sheet, and Instagram-ready PNG export
• Debug console -- Hidden diagnostic panel (Cmd+Shift+D) for troubleshooting session detection issues

How it works

Live monitoring -- A background thread polls every 2 seconds, scanning for running claude processes using sysinfo. Each process is matched to its session file in ~/.claude/projects/ via path encoding and timestamp correlation. The last N entries of each session's JSONL file are parsed to determine status:

• Working -- Claude is generating a response or executing tools
• Needs Attention -- A tool requires user approval, or Claude is asking the user a question

Run c9watch hooks --install to have Claude Code report permission prompts directly, instead of c9watch inferring them from the transcript. See docs/claude-hooks.md.

• Idle -- Session is waiting for your next prompt

Status updates are pushed to the Svelte frontend via Tauri events. The UI reactively updates, sorting sessions by priority (permission requests surface first).

Session history -- Reads ~/.claude/history.jsonl for the session index, then scans individual JSONL files across all project directories for deep content search. Results link back to the full conversation viewer with scroll-to-match highlighting.

Cost tracking -- Parses assistant message metadata from JSONL files to extract model usage and token counts. Costs are computed using per-model pricing tables and cached by file mtime to avoid re-scanning unchanged sessions.

Tech stack

Layer	Technology
Desktop framework	Tauri 2
Frontend	SvelteKit + Svelte 5
Backend	Rust
Process discovery	sysinfo
Design system	Vercel Noir (true black, Geist fonts)

Development

npm install
npm run tauri dev

This starts both the Vite dev server (hot-reload for the frontend) and the Tauri Rust backend.

Project structure

c9watch/
├── src/                        # SvelteKit frontend
│   ├── routes/
│   │   ├── (app)/              # Main dashboard (monitor, history, cost tabs)
│   │   └── popover/            # Tray popover window
│   ├── lib/
│   │   ├── components/         # Svelte components
│   │   │   ├── SessionCard     # Live session cards with status
│   │   │   ├── SessionHistory  # History browser with search
│   │   │   ├── CostTracker     # Spending dashboard
│   │   │   ├── MessageBubble   # Conversation message rendering
│   │   │   └── ...             # Overlays, nav map, status bar, etc.
│   │   ├── stores/             # Reactive state management
│   │   ├── demo/               # Demo mode with mock data
│   │   ├── api.ts              # Tauri command wrappers
│   │   └── types.ts            # TypeScript type definitions
│   └── app.css                 # Global styles (Vercel Noir theme)
├── src-tauri/                  # Rust backend (Tauri)
│   └── src/
│       ├── lib.rs              # App setup, tray icon, NSPanel popover
│       ├── polling.rs          # Background session detection loop
│       ├── actions.rs          # Stop/open session, IDE detection
│       ├── web_server.rs       # WebSocket server for mobile clients
│       ├── auth.rs             # Token generation, local IP discovery
│       └── session/
│           ├── parser.rs       # JSONL file parsing and message extraction
│           ├── detector.rs     # Process-to-session matching
│           ├── status.rs       # Status determination from JSONL entries
│           ├── history.rs      # Session history index and deep search
│           ├── cost.rs         # Cost aggregation with mtime caching
│           ├── enrichment.rs   # Session metadata enrichment (titles, first prompt)
│           ├── conversation.rs # Conversation loading and rendering
│           ├── sanitize.rs     # Strip internal XML tags from messages
│           ├── permissions.rs  # Auto-approval rule checking
│           └── custom_names.rs # User-defined session titles

Demo mode

Press Cmd+D to toggle demo mode, which loads simulated sessions with animated status transitions. Useful for testing the UI without running real Claude Code sessions.

How this was built

c9watch is developed mostly with AI coding agents: Claude Code (Anthropic) and Codex (OpenAI). Most of the code in this repository was written by them. The repository is open; read the code and judge it on its merits. Pull requests from outside contributors (listed below) are their own work.

About the process

My role is direction, not authorship:

• Product direction: deciding what to build, what not to build, and why
• Testing: running the app every day with my own sessions, finding bugs, checking that features behave
• Review: reading the generated code and the diffs before they land
• Measurement: numbers in the release notes come from real runs; where a number comes from a contributor or a single machine, the notes say so

I'm disclosing this because it's true, and so that anyone who prefers to avoid AI-built software can decide for themselves. If something is wrong, open an issue.

Contributing

Contributions are welcome! Please read CONTRIBUTING.md for guidelines on:

• Setting up the development environment
• Coding standards and commit message format
• Pull request process
• Platform-specific contributions (Windows, Linux)

Contributors

Thanks to these wonderful people who have contributed to c9watch:

Min-Chen Lee 💻 📖 🎨	Ray Lee 💻 📦	Grimmer Kang 💻	Stanimir 💻	josh.dev 💻	Max Harris 💻	Vladan 💻
Alex Jones-Wolsey 💻	Jeff Carey 💻	Mamed 💻	Jamie Goodfellow 💻	Alex Popescu 💻

See CONTRIBUTORS.md for the full list and contribution details.

License

MIT