$ 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.

04 read more →

Agentic AI

OODA cognitive loop with 4 specialized agents: master controller, optimizer, preference learner, and ideator. Goal trees, decision journals, strategy versioning, cross-agent knowledge sharing, mind-meld personality layer.

Token Quota

Weekly token tracking with velocity trends, daily breakdowns, and per-session usage attribution. Configurable warning and critical thresholds with automated optimizer responses.

Tool System

Extensible tool registry with autonomy levels from observe to autonomous. Trust calibration, tool leases, persistent scheduling (cron/interval), and TOML-based custom tools.

# 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.