$ operad boot

operad.stream

Manage all your Claude Code sessions from one dashboard

Web UI for skills, memories, and prompt history across every project. Auto-boots all saved projects on startup. Health checks, memory monitoring, and crash recovery keep everything running.

Android/TermuxLinuxmacOS

GitHub npm: operadic CLI Reference

Unified dashboard

Browse and manage skills, memories, and CLAUDE.md files across all your repos from one web interface. Start, stop, restart any session with a click.

Prompt history + search

Full conversation history across every project with search, starring, and token usage tracking. Never lose a useful prompt or solution again.

Auto-boot on startup

All saved projects start automatically in dependency order. Health checks, auto-restart, and memory pressure management keep them running 24/7.

# Install

quick start

$ npm i -g operadic

# create config

$ mkdir -p ~/.config/operad

$ operad config --init

# boot everything

$ operad boot

Or from source: git clone https://github.com/tribixbite/operad && cd operad && bun install && bun run build

# Architecture

┌─────────────────────────────────────────────────────────┐
│  operad.toml  ──>  operad daemon (:18970)                │
│                       │                                  │
│             ┌─────────┼─────────┐                         │
│             ▼         ▼         ▼                         │
│         Session   Session   Session                     │
│         (claude)  (daemon)  (service)                    │
│             │         │         │                         │
│             └─────────┼─────────┘                         │
│                       ▼                                  │
│                 tmux server                              │
│                       │                                  │
│             ┌─────────┼─────────┐                         │
│             ▼         ▼         ▼                         │
│       Health    Memory    Dashboard                  │
│       checks    monitor   SSE + REST                 │
└─────────────────────────────────────────────────────────┘

Session Types

claude — polls readiness, sends "go"
daemon — custom command with env
service — headless background process

Health Checks

tmux_alive, http, process, custom.
Configurable thresholds + auto-restart.

Memory Pressure

Real-time memory monitoring.
Levels: normal → warning → critical → emergency.

# Platform Support

Android / Termux

Termux notifications + battery
ADB phantom process fix
Wake lock (termux-wake-lock)
Tab creation via am intents
Process budget tracking

Linux

notify-send notifications
/sys battery via power_supply
systemd-inhibit wake lock
/proc process monitoring
XDG path conventions

macOS

osascript notifications
pmset battery monitoring
caffeinate wake lock
ps/lsof process inspection
Terminal.app tab support

platform detection at runtime

TERMUX_VERSION set? → android

process.platform === "darwin" → darwin

else → linux

# Configuration

Config lives at ~/.config/operad/operad.toml. Supports $ENV_VAR expansion and schema validation.

~/.config/operad/operad.toml

[operad]

dashboard_port = 18970

health_interval_s = 120

wake_lock_policy = "active_sessions"

# Claude Code session

[[session]]

name = "my-project"

type = "claude"

path = "$HOME/git/my-project"

# Daemon with custom command

[[session]]

name = "api"

type = "service"

command = "bun run dev"

depends_on = ["my-project"]

Field	Type	Description
name	string	Unique session identifier (becomes tmux session name)
type	enum	claude \| daemon \| service
path	string?	Working directory ($ENV expansion supported)
command	string?	Command to run (daemon/service types)
depends_on	string[]	Sessions that must start first
priority	number?	Boot order priority (lower = earlier)
health	object?	Health check config (check, url, threshold)
auto_go	bool?	Auto-send 'go' to Claude sessions on ready

# CLI

~ $ operad boot

✓ wake lock acquired

✓ my-project started (claude)

✓ api started (service)

~ $ operad status

operad daemon uptime 4h 23m

NAME STATUS RSS UPTIME HEALTH

my-project running 245MB 4h 23m ok

api running 38MB 4h 22m ok

operad boot — Start daemon + all sessions in dependency order

operad status — Show daemon uptime, memory, battery, and session table

operad health — Run health checks on all sessions

operad go <name> — Send "go" to a Claude session waiting for input

operad start <name> — Start a stopped session

operad stop <name> — Stop a running session

operad restart <name> — Stop + start a session

operad open <path> — Open a new Claude session dynamically

operad close <name> — Stop and remove a dynamic session from registry

operad recent — List recent Claude projects from history

operad tabs — Open terminal tabs for running sessions

operad memory — Show system memory and per-session RSS

operad config — Validate and display parsed config

operad suspend <name> — Freeze session (SIGSTOP)

operad resume <name> — Unfreeze session (SIGCONT)

operad upgrade — Rebuild, restart daemon

operad shutdown — Gracefully stop daemon (sessions persist)

# Dashboard

Web dashboard on port 18970 with real-time SSE updates. Manage everything from your browser — sessions, skills, memories, prompt history.

Sessions

Start/stop/restart any session.
System gauges (memory, battery, ADB).
Recent projects with search + quick open.

Prompt History

Full conversation history across all projects.
Search by content, project, or date.
Star and save important prompts. Token tracking.

Skills & Memories

Browse skills and CLAUDE.md across repos.
View and edit auto-memories per project.
Unified config management.

Memory Monitor

System memory breakdown.
Per-session RSS usage.
Process manager (force-stop on Android).

Logs

Real-time structured log tail via SSE.
Filter by level and session.
Auto-scroll with pause on hover.

Settings

Edit operad config from the browser.
Manage notification preferences.
ADB and wake lock controls.

# REST API

All endpoints on http://127.0.0.1:18970. SSE endpoint pushes state updates in real time.

Endpoint	Method	Description
/api/status	GET	Full daemon state (sessions, memory, battery)
/api/events	SSE	Real-time state push
/api/start/:name	POST	Start a session
/api/stop/:name	POST	Stop a session
/api/restart/:name	POST	Stop + start
/api/go/:name	POST	Send "go" to Claude session
/api/open/:name	POST	Register + start dynamic session
/api/close/:name	POST	Stop + unregister dynamic session
/api/recent	GET	Recent Claude projects
/api/memory	GET	System memory + per-session RSS
/api/processes	GET	Running processes (Android: app list)
/api/kill/:pkg	POST	Force-stop a process

# Session Lifecycle

pending → waiting → starting → running ↔ degraded
                                            │
                                            ├→ failed
                                            │
                                            └→ stopping → stopped

pending — Defined in config, not yet processed

waiting — Waiting for depends_on sessions

starting — Tmux session created, process launching

running — Active, health checks passing

degraded — Running but health checks failing

failed — Exceeded restart limit

stopped — Gracefully stopped

# Crash Resilience

Designed so that every running session survives host app crashes. The daemon, watchdog, and tmux server all run as independent processes (PPid: 1).

Wake lock

Acquired once, never released. Prevents OS from killing background processes.

Phantom fix

Android: disables phantom process killer, Doze standby, and app idle.

Process detach

Daemon, watchdog, and tmux all run as PPid: 1 — independent of host app.

Socket self-heal

IPC socket recreated via HTTP API when tmpfs is cleaned. Recovery in <1s.

Watchdog loop

Bash loop restarts daemon after OOM kill. Sessions persist in tmux for re-adoption.

Trace log

appendFileSync log survives crashes. Check last line for daemon state before SIGKILL.