CLI Reference

The hive binary is the Hive CLI client. It connects to an hived daemon over WebSocket and manages Claude Code sessions.

Global Options

hive [OPTIONS] <COMMAND>

Option	Env Var	Default	Description
`--host <HOST>`	`HIVE_HOST`	`127.0.0.1`	Daemon host address
`--port <PORT>`	`HIVE_PORT`	`9178`	Daemon port
`--token <TOKEN>`	`HIVE_TOKEN`	(auto*)	Authentication token
`--nodes <NODES>`	`HIVE_NODES`	(none)	Comma-separated cluster node addresses
`--tls`	`HIVE_TLS`	`false`	Connect over TLS (wss://)

*The token is optional in most cases. Local-only commands (ps, install, update, guide, daemon) never connect to a daemon. For commands that do connect, when --token/HIVE_TOKEN is not supplied the CLI falls back to the token stored in the local hived config - so commands against the local node work out of the box. Supply --token explicitly only when targeting a remote node whose token differs from the local one.

When --nodes is set, the client tries each address until one succeeds. Every node is a co-equal authority under leaderless clustering, so any reachable node can serve the request. This overrides --host/--port.

Commands

`hive new` - Create a session

hive new [OPTIONS]

Option	Short	Default	Description
`--dir <DIR>`	`-d`	`.`	Working directory for the session
`--name <NAME>`		(none)	Optional session name

Creates a new SDK-mode session. The working directory is resolved to an absolute path. Prints the session ID on success.

$ hive new --dir /home/user/project --name "refactor"
Session created: 550e8400-e29b-41d4-a716-446655440000
  Mode: Sdk
  Dir:  /home/user/project
  Name: refactor

`hive ls` - List sessions

hive ls

Lists all sessions on the daemon with their ID, status, mode, attached client count, and working directory.

$ hive ls
ID                                     STATUS       MODE     CLIENTS  DIR
550e8400-e29b-41d4-a716-446655440000   idle         sdk      0        /home/user/project
6ba7b810-9dad-11d1-80b4-00c04fd430c8   running      sdk      1        /home/user/other

Status values: running, idle, detached, exited

`hive send` - Send a prompt

hive send <SESSION> <PROMPT>

Argument	Description
`SESSION`	Session ID (UUID)
`PROMPT`	The prompt text to send

Sends a prompt to an SDK-mode session. Spawns a new Claude process for the prompt. Automatically attaches to the session and streams output until completion.

$ hive send 550e8400-e29b-41d4-a716-446655440000 "explain the main function"
{"type":"assistant","content":"The main function..."}

Output is Claude's raw stream-json format (one JSON object per line).

`hive attach` - Attach to a session

hive attach <SESSION>

Subscribes to an existing session's output stream. Prints all output in real-time until the connection closes or you press Ctrl+C.

$ hive attach 550e8400-e29b-41d4-a716-446655440000
Attached to session 550e8400-e29b-41d4-a716-446655440000. Streaming output...
{"type":"assistant","content":"..."}

`hive kill` - Kill a session

hive kill <SESSION>

Terminates the session and its Claude process. The session is removed from the daemon.

$ hive kill 550e8400-e29b-41d4-a716-446655440000
Session 550e8400-e29b-41d4-a716-446655440000 killed.

`hive tag` - Set session tags

hive tag <SESSION> [TAG...]

Argument	Description
`SESSION`	Session ID (UUID)
`TAG`	One or more tags to set (replaces all existing tags)

Sets tags on a session. All existing tags are replaced by the new list. Pass no tags to clear all tags.

$ hive tag 550e8400-e29b-41d4-a716-446655440000 backend refactor
Session 550e8400-e29b-41d4-a716-446655440000 tags: backend, refactor

$ hive tag 550e8400-e29b-41d4-a716-446655440000
Session 550e8400-e29b-41d4-a716-446655440000 tags cleared.

`hive export` - Export a session transcript

hive export <SESSION> [--format text|json]

Argument/Option	Description
`SESSION`	Session ID (UUID)
`--format`	Output format: `text` (default) or `json`

Exports a session's full output history with metadata. The text format prints the pre-formatted transcript directly (suitable for piping to a file). The json format emits a JSON object with session_id, filename (suggested save name), and content fields.

$ hive export 550e8400-e29b-41d4-a716-446655440000 > transcript.txt

$ hive export 550e8400-e29b-41d4-a716-446655440000 --format json
{"session_id":"550e8400-...","filename":"my-session_2026-03-11.txt","content":"..."}

`hive cluster-status` - Show cluster info

hive cluster-status

Displays the cluster topology: this node and all known peers with their connection state. The Role, Term, Leader ID, and Leader Address fields are vestigial under leaderless clustering - every node reports Role: Leader, Term: 0, and itself as the leader. Treat every node as a co-equal authority.

$ hive cluster-status
Cluster Status
==============
  Node ID:        a1b2c3d4-e5f6-7890-abcd-ef1234567890 (node-a)
  Role:           Leader
  Term:           0
  Leader ID:      a1b2c3d4-e5f6-7890-abcd-ef1234567890
  Leader Address: 10.0.0.1:9178

PEER ID                                NAME               ROLE         ADDRESS                  CONNECTED
b2c3d4e5-f6a7-8901-bcde-f12345678901   node-b             leader       10.0.0.2:9179            yes

Returns an error if the connected node is not part of a cluster.

`hive adopt` - Adopt a running Claude process

hive adopt [OPTIONS]

Option	Short	Default	Description
`--pid <PID>`	`-p`	(none)	PID of the Claude process to adopt
`--name <NAME>`		(none)	Optional session name
`--dir <DIR>`	`-d`	(none)	Working directory for the adopted session

Adopts an already-running Claude Code process into daemon management. Without --pid, discovers running Claude processes and lists them interactively.

The adopted process becomes a managed session (mode: adopted) that can be attached, monitored, and killed like any other session.

$ hive adopt --pid 12345 --name "existing-work"
Session created: 7f3a2b10-...
  Mode: Adopted
  PID:  12345

`hive open` - Open a terminal on the daemon

hive open [OPTIONS]

Option	Short	Default	Description
`--dir <DIR>`	`-d`	`.`	Working directory for the terminal
`--shell <SHELL>`	`-s`	`$SHELL` (Unix) or `powershell.exe` (Windows)	Shell or command line to launch (e.g. `bash`, `powershell`, `cmd`, `zsh`, `"pwsh -NoExit"`)
`--name <NAME>`		(none)	Optional human-readable name for this terminal

Opens an interactive shell or command terminal on the daemon. The terminal runs as a managed session that can be attached from other clients.

The working directory is resolved to an absolute path. If --shell is not provided, the command defaults to $SHELL on Unix systems or powershell.exe on Windows.

--shell accepts a whole command line, not just a program name. The daemon first looks the value up in its command registry by name or program path; on a miss it tokenizes the string into a program plus arguments, honouring single quotes, double quotes and backslash escapes. So --shell "claude --dangerously-skip-permissions" and --shell "'/opt/my tools/claude' --flag" both work. A value that names an existing file is used verbatim, so an unquoted path containing spaces is never split. This is a tokenizer, not a shell: &&, pipes and redirection are passed through as literal arguments - wrap them yourself (--shell "bash -lc 'make && ./run'") when you need shell syntax.

The terminal is created and automatically attached - output streams to stdout in real-time. Press Ctrl+C to detach (the terminal continues running on the daemon).

$ hive open --dir /tmp --shell bash --name "build"
Terminal opened: a1b2c3d4-... (bash)
Attaching... Press Ctrl+C to detach.

The terminal behaves like an attached session: you can send input (keystrokes) and receive output in real-time. To detach and later reattach, use hive attach <session-id> in another terminal.

`hive team` - Manage agent teams

hive team <SUBCOMMAND>

Subcommands for listing and managing agent teams - headless multi-agent orchestration where a leader and its workers each run as a headless claude or codex agent, one provider and model per member (see teams.md). Create a team with hive team create --name <n> --working-dir <dir> [--permission-mode bypass|accept_edits|plan] and add workers with hive team spawn-worker <TEAM_ID> [--agent claude|codex] [--model <m>|--tier fast|balanced|deep] [--role <r>]. Teams are persistent: they have no completion state and end only when deleted. --node <NODE_ID> runs the team on another cluster node - use it when --working-dir lives on a machine other than the one you are connected to, since the agents read that node's filesystem and OS accounts. In autopilot, agents coordinate through the hive-team MCP tools; the subcommands below are the CLI mirror of those tools.

`hive team ls`

Lists all active teams.

$ hive team ls
ID                                     LEADER SESSION       STATUS       WORKERS  NAME
a1b2c3d4-...                           550e8400-...         running      3        my-team

`hive team get <TEAM_ID>`

Shows details for a specific team.

$ hive team get a1b2c3d4-e5f6-7890-abcd-ef1234567890
Team:    a1b2c3d4-...
Name:    my-team
Status:  Running
Leader:  550e8400-...
Workers: 3
  - 6ba7b810-...
  - 7c8d9e0f-...
  - 8d9e0f1a-...

`hive team delete <TEAM_ID>`

Deletes a team and kills all its sessions.

$ hive team delete a1b2c3d4-e5f6-7890-abcd-ef1234567890
Team a1b2c3d4-... deleted.

Autopilot subcommands

A headless leader normally orchestrates workers through the hive-team MCP tools (see teams-autopilot.md); these subcommands mirror those tools for shell scripts, humans, and non-Claude (PTY) leaders:

Command	Purpose
`hive team handoff <TEAM_ID> --name <n> --prompt <p> [--agent claude\|codex] [--model <m>\|--tier fast\|balanced\|deep] [--role <r>]`	Spawn worker + block until report. Returns a `wait_id` on timeout.
`hive team assign <TEAM_ID> --name <n> --prompt <p> [--agent ...] [--model <m>\|--tier <t>] [--role <r>]`	Spawn worker and return immediately. Pair with `wait`.
`hive team send <TEAM_ID> [--to <id> \| --broadcast] --message <m>`	DM a worker or broadcast to the team.
`hive team inbox <TEAM_ID> [--session <id>] [--since <seq>] [--watch]`	Replay relayed messages (NDJSON). At-least-once on `seq`.
`hive team workers <TEAM_ID>`	Print the roster with per-worker status (`pending` / `reported(success\|failure)`).
`hive team report <TEAM_ID> --success\|--failure [--result <s>]`	Worker reports its result. Auto-called by the Claude `Stop` hook.
`hive team summary <TEAM_ID> [--result <s>]`	Leader publishes a progress summary. Teams are persistent - this does not end the team.
`hive team models [--provider <p>] [--refresh] [--json]`	List the models this node offers per agent CLI, with tier and the recommended pick.
`hive team wait <TEAM_ID> [--for <ids>] [--timeout <secs>] [--wait-id <id>]`	Bounded block on pending workers.
`hive team status`	Print env-derived identity (`HIVE_TEAM_ID`, `HIVE_SESSION_ID`, role) and team summary.

Workers spawned via handoff/assign default to an isolated git worktree under .hive/worktrees/<worker-id> (or a plain sandbox dir if the leader cwd is not a git repo). At most 5 workers may be active without a recorded result; completed workers remain in the roster but no longer consume capacity.

hive team mcp runs the stdio MCP server that exposes these operations as mcp__hive-team__* tools. The daemon wires it into each headless agent via --mcp-config; it is not meant to be run by hand. New Claude team members require this CLI to report the same version as hived and pass the daemon's team mcp capability check.

`hive internal stop` - Stop-hook helper (not for direct use)

Called by the Claude Stop hook in .claude/settings.json that the autopilot skill materialises. Reads HIVE_TEAM_ID / HIVE_SESSION_ID from the env, extracts the last assistant message from --transcript or the hook payload's transcript_path on stdin, and emits ReportWorkerResult to the daemon.

hive internal stop [--team-id <id>] [--session-id <id>] [--transcript <path>] [--failure]

`hive ps` - List local Claude processes

hive ps

Lists Claude Code processes running on the local machine. Does not require a daemon connection or token.

$ hive ps
PID     CMD
12345   claude --print --output-format stream-json ...
67890   claude --print --output-format stream-json ...

`hive version` - Show version information

hive version

Prints the version of this CLI binary, its build platform, and the version of the locally installed hived daemon (if one is installed). Does not require a daemon connection or token. hive --version (and -V) print the CLI version alone.

$ hive version
hive (CLI):    v1.12.9
platform:      linux-x64
hived (local): hived 1.12.9

`hive install` - Install the daemon

hive install [OPTIONS]

Option	Default	Description
`--non-interactive`	`false`	Skip interactive prompts, use defaults
`--name <NAME>`	(none)	Node display name (skips name prompt)
`--port <PORT>`	`9178`	Daemon listen port (skips port prompt)
`--bind <ADDR>`	`0.0.0.0`	Bind address (skips bind address prompt)
`--user-secret <SECRET>`	(none)	User secret to set in daemon config
`--json`	`false`	Output a single JSON summary line (for automation)

Extracts the bundled hived daemon binary and runs a configuration wizard. Does not require a daemon connection or token.

The wizard prompts for: display name, port, bind address, token, claude binary path, and optional cluster settings. The config is written to the platform config directory.

Resolving the claude binary. The installer resolves the configured claude command to an absolute path so the daemon does not depend on its own PATH at runtime. Beyond a plain PATH lookup it also probes the sudo-invoking user's ~/.local/bin/claude and ~/.npm-global/bin/claude, since Claude Code is commonly installed there for the human user rather than root. When no claude is found anywhere, the install still completes but prints a warning so you can set claude_bin by hand later.

Client config for the desktop app (sudo installs). The daemon config lives under the root/service user (for example /root/.config/hive/...), which the desktop app running as your normal user cannot read. So when hive install runs via sudo, it also writes a minimal client connect config to the invoking user's ~/.config/hive/config.toml - just display_name, bind, port, and token - owned by that user with 0600 permissions. This lets the app's "Connect to local node" work out of the box. An existing user config is never overwritten.

Install paths:

Windows: %LOCALAPPDATA%\Programs\Hive\hived.exe
Linux/macOS: /usr/local/bin/hived

$ sudo hive install
Installing Hive daemon...
  Binary:  /usr/local/bin/hived
  Config:  /root/.config/hive/Hive/config.toml
  Client:  /home/alice/.config/hive/config.toml
  Claude:  /home/alice/.local/bin/claude
  Token:   a3f8b2c1d4e5...
Done. Start the daemon with: hived

`hive rename-node` - Rename a cluster node

hive rename-node <NODE_ID> <NAME>

Argument	Description
`NODE_ID`	Node UUID (from `hive cluster-status`)
`NAME`	New display name for the node

Renames a cluster node. The name is saved to the node's config file and propagated to all peers immediately.

$ hive rename-node a1b2c3d4-e5f6-7890-abcd-ef1234567890 "production-1"
Node renamed.

`hive update` - Update the CLI

hive update [OPTIONS]

Option	Default	Description
`--from <URL>`	local node's `[update].manifest_url`, else `https://hive.vazac.dev/`	Remote manifest base URL
`--channel <CHANNEL>`	local node's `[update].channel`, else `semi-stable`	Release channel: `semi-stable` or `unstable`
`--remote-token <TOKEN>`	`$HIVE_UPDATE_TOKEN`, else local node's `[update].token`	Bearer token for private remote manifests

Updates the running hive CLI binary in place. This is a local-only command - it does not connect to a daemon.

By default the CLI reads the local hived config's [update] section and follows the same manifest URL and channel the node itself tracks. So on a node set to the unstable channel, a plain hive update pulls the unstable CLI; no flags needed. --from, --channel, and --remote-token override the config values. The concrete manifest file is derived from the channel (manifest.json for semi-stable, manifest-unstable.json for unstable). The binary is verified by SHA-256 before the running CLI is replaced and restarted.

Examples:

bash

# Follow the local node's configured channel and manifest URL
hive update

# Force the unstable channel for this update only
hive update --channel unstable

# Pull the CLI directly from a specific remote manifest base URL
hive update --from https://updates.example.com/hive/

# Private manifest
HIVE_UPDATE_TOKEN=secret hive update --from https://updates.example.com/hive/

`hive update-node` - Update a node from a URL

hive update-node [OPTIONS]

Option	Default	Description
`--from <URL>`	local node's `[update].manifest_url`, else `https://hive.vazac.dev/`	Remote manifest base URL
`--channel <CHANNEL>`	local node's `[update].channel`, else `semi-stable`	Release channel: `semi-stable` or `unstable`
`--remote-token <TOKEN>`	`$HIVE_UPDATE_TOKEN`, else local node's `[update].token`	Bearer token for private remote manifests
`--refresh-artifacts`	`false`	Also refresh remaining artifacts for other platforms and app clients

Asks the connected node to fetch a remote manifest, download the daemon and CLI binaries for its own platform, verify both, stage them, install or update the CLI, and restart the daemon. A missing or invalid same-platform CLI artifact fails the update before the restart begins. If the staged CLI cannot be copied, made executable, or renamed into place on the next boot, daemon startup fails instead of running with a missing or stale CLI.

With no arguments this updates the local node (the daemon on --host, which defaults to 127.0.0.1), following the same [update] manifest URL and channel the node already tracks - mirroring how hive update self-updates the CLI. So a plain hive update-node is all you need to bring the local daemon and CLI up to date. --from, --channel, and --remote-token override the config values.

The current node's CLI is always refreshed. Use --refresh-artifacts when you also want the daemon to stage the remaining manifest entries, including CLIs and daemons for other platforms, desktop app installers, and Android APKs.

bash

# Update the local node, following its configured channel and manifest URL
hive update-node

# Force the unstable channel for this update only
hive update-node --channel unstable

# Update a specific node from an explicit manifest URL
hive --host node2.example.com update-node --from https://updates.example.com/hive/
hive update-node --from https://updates.example.com/hive/ --refresh-artifacts

The previous name hive update-daemon still works as an alias.

`hive discover` - Discover Hive nodes on Tailscale

hive discover

Scans the Tailscale network for other Hive nodes. Prints discovered nodes with their address, version, and platform. The scan identifies TLS-only nodes (those that serve wss:// and reject plain ws://) too. Does not require a daemon connection.

$ hive discover
ADDRESS              VERSION   PLATFORM
100.64.1.2:9178      1.8.103   linux-arm64
100.64.1.3:9178      1.8.103   windows-x64

`hive daemon` - Local daemon management

hive daemon <SUBCOMMAND>

Read-only subcommands for inspecting the locally installed daemon. These read the local config file directly and do not require a daemon connection.

`hive daemon get-token`

Prints the auth token from the local daemon config.

$ hive daemon get-token
a3f8b2c1d4e5f6a7b8c9d0e1f2a3b4c5...

`hive daemon get-config`

Prints the full daemon config as TOML.

$ hive daemon get-config
[daemon]
name = "my-node"
port = 9178
...

`hive daemon status`

Shows whether the daemon is installed, its version, and whether it is currently running.

$ hive daemon status
Installed: yes
Version:   1.8.103
Running:   yes (PID 4321)

`hive cert` - Provision TLS for the web client

hive cert [OPTIONS]

A browser served over HTTPS cannot open a plain ws:// socket to a remote host, so the web client only connects to nodes that serve TLS (wss://). This command makes that one step: it detects the node's Tailscale MagicDNS name (<node>.<tailnet>.ts.net), issues a browser-trusted certificate with tailscale cert, writes it next to the daemon config, sets tls_cert/tls_key, and (with --restart) restarts the daemon.

Option	Description
`--name <NAME>`	Domain to issue the cert for. Defaults to this machine's Tailscale MagicDNS name.
`--restart`	Restart hived after writing the config (systemd hosts only).
`--config <PATH>`	Daemon config file to update. Defaults to the per-user config dir; pass this when hived runs with `--config <path>` (e.g. a system install at `/etc/hive/config.toml`). The daemon also passes its own config path automatically when it invokes `hive cert`.

Run it on the machine the daemon runs on (usually with sudo, since tailscale cert and the config write need privileges):

$ sudo hive cert --restart
Provisioning a TLS certificate for: my-node.tailnet.ts.net
Wrote certificate: /root/.config/hive/tls/my-node.tailnet.ts.net.crt
Wrote private key: /root/.config/hive/tls/my-node.tailnet.ts.net.key
Updated /root/.config/hive/config.toml (tls_cert / tls_key set).
Restarting hived (systemctl restart hived)...
hived restarted.

Requirements: the Tailscale CLI on PATH (override with HIVE_TAILSCALE_BIN) and HTTPS Certificates enabled for the tailnet. hive cert fails fast with a clear message if Tailscale is not installed on the node. Tailscale certs expire after ~90 days - re-run to renew, then restart the daemon. Any node with its own public-domain certificate works too; this just automates the Tailscale path.

Once a node serves TLS, connect to it by its Tailscale MagicDNS hostname (<node>.<tailnet>.ts.net), not a bare IP - the certificate is issued for that hostname, so an IP fails validation. The app auto-negotiates wss:// vs ws:// per connection profile, so there is no manual TLS toggle to set.

`hive project` - Manage projects

hive project <SUBCOMMAND>

Projects are working directories tracked by the cluster. They are the anchor point for file operations, git operations, and task scheduling.

`hive project ls`

Lists all projects.

$ hive project ls
ID                                     NAME                           DIR
a1b2c3d4-...                           my-app                         /home/user/my-app

`hive project new`

hive project new --name <NAME> --dir <DIR> [--description <DESC>] [--node <NODE_ID>]

Creates a new project. The working directory is resolved to an absolute path.

$ hive project new --name "my-app" --dir /home/user/my-app
Project created: a1b2c3d4-...
  Name: my-app
  Dir:  /home/user/my-app

`hive project get <PROJECT_ID>`

Shows full details for a project.

`hive project update <PROJECT_ID>`

hive project update <PROJECT_ID> [--name <N>] [--dir <D>] [--description <D>] [--node <N>]

Updates a project. Only the fields you provide are changed.

`hive project rm <PROJECT_ID>`

Deletes a project. Sessions and files under the project directory are not affected.

`hive task` - Manage scheduled tasks

hive task <SUBCOMMAND>

Tasks are shell commands scheduled to run by the daemon.

Schedule formats

Format	Example	Meaning
`once`	`once`	Run once immediately
`cron:<expr>`	`cron:0____`	Cron expression (use `_` instead of spaces)
`interval:<secs>`	`interval:300`	Repeat every N seconds

`hive task ls`

hive task ls [--node <NODE_ID>]

Lists tasks with their status, schedule, owning node, project, and command. Use --node to show only tasks owned by one cluster node.

`hive task new`

hive task new --cmd <CMD> [--dir <DIR>] [--schedule <SCHED>] [--name <NAME>] [--project <ID>] [--node <NODE_ID>]

Creates a new task. --node routes creation to that online cluster node. When it is omitted, the task is created on the connected node.

$ hive task new --name "nightly-backup" --cmd "rsync -a /data /backup" --schedule "cron:0_2_*_*_*"
Task created: b2c3d4e5-...
  Name: nightly-backup

`hive task get <TASK_ID> [--node <NODE_ID>]`

Shows full details for a task.

`hive task update <TASK_ID> [--node <NODE_ID>]`

Updates a task on its owning node. Only provided fields are changed. --node selects the existing task's owner; it does not move the task to that node.

`hive task move <TASK_ID>`

hive task move <TASK_ID> \
  --from-node <NODE_ID> \
  --to-node <NODE_ID> \
  --working-dir <ABSOLUTE_PATH> \
  [--project <PROJECT_ID>] \
  [--operation-id <OPERATION_ID>]

Moves a non-running task and its retained run history to another online node. The destination working directory is required and must exist on that node. An optional project must also exist on and belong to the destination node. Hive preserves the task ID, schedule, configuration, and timestamps.

The CLI prints a generated operation ID before starting. If a recoverable phase fails, rerun the printed command with the same --operation-id; Hive resumes the durable move instead of duplicating the task.

`hive task move-abort`

hive task move-abort \
  --operation-id <OPERATION_ID> \
  --from-node <NODE_ID> \
  --to-node <NODE_ID>

Aborts and cleans up a recoverable move that has not committed source removal. Use the same operation and node IDs printed by hive task move.

`hive task rm <TASK_ID> [--node <NODE_ID>]`

Deletes a task.

`hive task cancel <TASK_ID> [--node <NODE_ID>]`

Cancels a running or pending task.

`hive task trigger <TASK_ID> [--node <NODE_ID>]`

Triggers a task immediately, regardless of its schedule.

`hive file` - Manage project files

hive file <SUBCOMMAND> <PROJECT_ID> ...

All file operations work on paths relative to a project's working directory. Path traversal outside the project root is rejected by the daemon.

`hive file ls <PROJECT_ID> [PATH]`

Lists files in a project directory. PATH defaults to the project root.

$ hive file ls a1b2c3d4-... src
dir              src/components/
file        1024  src/main.rs
file        2048  src/lib.rs

`hive file read <PROJECT_ID> <PATH>`

Prints a file's contents to stdout.

$ hive file read a1b2c3d4-... src/main.rs
fn main() { ... }

`hive file write <PROJECT_ID> <PATH>`

Reads from stdin and writes to the file (overwrites). Use shell redirection:

bash

echo "hello" | hive file write a1b2c3d4-... src/main.rs
cat local.rs   | hive file write a1b2c3d4-... src/main.rs

`hive file touch <PROJECT_ID> <PATH>`

Creates an empty file. Fails if the path already exists.

`hive file mkdir <PROJECT_ID> <PATH>`

Creates a directory. The parent must already exist.

`hive file mv <PROJECT_ID> <FROM> <TO>`

Moves or renames a file or directory. The destination must not already exist.

`hive file cp <PROJECT_ID> <FROM> <TO>`

Copies a file or directory recursively. The destination must not already exist.

`hive file rm <PROJECT_ID> <PATH>`

Deletes a file or directory. Directories are removed recursively.

`hive git` - Git operations on a project

hive git <SUBCOMMAND> <PROJECT_ID> ...

All git operations run against a project's working directory on the daemon host.

`hive git status <PROJECT_ID>`

Shows branch, ahead/behind count, staged changes, unstaged changes, and untracked files.

$ hive git status a1b2c3d4-...
On branch main (upstream: origin/main, +1 -0)

Staged changes:
  M src/main.rs

Untracked files:
  ? scratch.txt

`hive git diff <PROJECT_ID> <PATH> [--cached]`

Prints the unified diff for a file. --cached shows the staged diff (index vs HEAD); without it shows the unstaged diff (worktree vs index).

`hive git stage <PROJECT_ID> <PATH...>`

Stages one or more files. Pass . to stage everything.

`hive git unstage <PROJECT_ID> <PATH...>`

Unstages one or more files. Pass . to unstage everything.

`hive git commit <PROJECT_ID> --message <MSG>`

Commits staged changes.

$ hive git commit a1b2c3d4-... --message "fix: null pointer in parser"

`hive git pull <PROJECT_ID>`

Pulls from the configured upstream.

`hive git push <PROJECT_ID>`

Pushes to the configured upstream.

Cluster Usage

When using --nodes, the client connects to the first reachable node:

bash

# Connect to whichever node answers first - any node can serve the request
hive --nodes 10.0.0.1:9178,10.0.0.2:9178 ls

# Environment variable form
export HIVE_NODES="10.0.0.1:9178,10.0.0.2:9178"
hive ls

Leaderless clustering has no leader to find: every node serves reads and writes locally and gossips changes to its peers, so any reachable node returns the same cluster-wide view. The connected address is printed to stderr:

Connected to 10.0.0.1:9178

Exit Codes

Code	Meaning
0	Success
1	Error (auth failure, connection refused, session not found, etc.)

Logging

Set the RUST_LOG environment variable to control log output:

bash

RUST_LOG=debug hive ls       # Verbose logging
RUST_LOG=warn hive ls        # Only warnings (default)

CLI Reference ​

Global Options ​

Commands ​

hive new - Create a session ​

hive ls - List sessions ​

hive send - Send a prompt ​

hive attach - Attach to a session ​

hive kill - Kill a session ​

hive tag - Set session tags ​

hive export - Export a session transcript ​

hive cluster-status - Show cluster info ​

hive adopt - Adopt a running Claude process ​

hive open - Open a terminal on the daemon ​

hive team - Manage agent teams ​

hive team ls ​

hive team get <TEAM_ID> ​

hive team delete <TEAM_ID> ​

Autopilot subcommands ​

hive internal stop - Stop-hook helper (not for direct use) ​

hive ps - List local Claude processes ​

hive version - Show version information ​

hive install - Install the daemon ​

hive rename-node - Rename a cluster node ​

hive update - Update the CLI ​

hive update-node - Update a node from a URL ​

hive discover - Discover Hive nodes on Tailscale ​

hive daemon - Local daemon management ​

hive daemon get-token ​

hive daemon get-config ​

hive daemon status ​

hive cert - Provision TLS for the web client ​

hive project - Manage projects ​

hive project ls ​

hive project new ​

hive project get <PROJECT_ID> ​

hive project update <PROJECT_ID> ​

hive project rm <PROJECT_ID> ​

hive task - Manage scheduled tasks ​

Schedule formats ​

hive task ls ​

hive task new ​

hive task get <TASK_ID> [--node <NODE_ID>] ​

hive task update <TASK_ID> [--node <NODE_ID>] ​

hive task move <TASK_ID> ​

hive task move-abort ​

hive task rm <TASK_ID> [--node <NODE_ID>] ​

hive task cancel <TASK_ID> [--node <NODE_ID>] ​

hive task trigger <TASK_ID> [--node <NODE_ID>] ​

hive file - Manage project files ​

hive file ls <PROJECT_ID> [PATH] ​

hive file read <PROJECT_ID> <PATH> ​

hive file write <PROJECT_ID> <PATH> ​

hive file touch <PROJECT_ID> <PATH> ​

hive file mkdir <PROJECT_ID> <PATH> ​

hive file mv <PROJECT_ID> <FROM> <TO> ​

hive file cp <PROJECT_ID> <FROM> <TO> ​

hive file rm <PROJECT_ID> <PATH> ​

hive git - Git operations on a project ​

hive git status <PROJECT_ID> ​

hive git diff <PROJECT_ID> <PATH> [--cached] ​

hive git stage <PROJECT_ID> <PATH...> ​

hive git unstage <PROJECT_ID> <PATH...> ​

hive git commit <PROJECT_ID> --message <MSG> ​

hive git pull <PROJECT_ID> ​

hive git push <PROJECT_ID> ​

Cluster Usage ​

Exit Codes ​

Logging ​

CLI Reference

Global Options

Commands

`hive new` - Create a session

`hive ls` - List sessions

`hive send` - Send a prompt

`hive attach` - Attach to a session

`hive kill` - Kill a session

`hive tag` - Set session tags

`hive export` - Export a session transcript

`hive cluster-status` - Show cluster info

`hive adopt` - Adopt a running Claude process

`hive open` - Open a terminal on the daemon

`hive team` - Manage agent teams

`hive team ls`

`hive team get <TEAM_ID>`

`hive team delete <TEAM_ID>`

Autopilot subcommands

`hive internal stop` - Stop-hook helper (not for direct use)

`hive ps` - List local Claude processes

`hive version` - Show version information

`hive install` - Install the daemon

`hive rename-node` - Rename a cluster node

`hive update` - Update the CLI

`hive update-node` - Update a node from a URL

`hive discover` - Discover Hive nodes on Tailscale

`hive daemon` - Local daemon management

`hive daemon get-token`

`hive daemon get-config`

`hive daemon status`

`hive cert` - Provision TLS for the web client

`hive project` - Manage projects

`hive project ls`

`hive project new`

`hive project get <PROJECT_ID>`

`hive project update <PROJECT_ID>`

`hive project rm <PROJECT_ID>`

`hive task` - Manage scheduled tasks

Schedule formats

`hive task ls`

`hive task new`

`hive task get <TASK_ID> [--node <NODE_ID>]`

`hive task update <TASK_ID> [--node <NODE_ID>]`

`hive task move <TASK_ID>`

`hive task move-abort`

`hive task rm <TASK_ID> [--node <NODE_ID>]`

`hive task cancel <TASK_ID> [--node <NODE_ID>]`

`hive task trigger <TASK_ID> [--node <NODE_ID>]`

`hive file` - Manage project files

`hive file ls <PROJECT_ID> [PATH]`

`hive file read <PROJECT_ID> <PATH>`

`hive file write <PROJECT_ID> <PATH>`

`hive file touch <PROJECT_ID> <PATH>`

`hive file mkdir <PROJECT_ID> <PATH>`

`hive file mv <PROJECT_ID> <FROM> <TO>`

`hive file cp <PROJECT_ID> <FROM> <TO>`

`hive file rm <PROJECT_ID> <PATH>`

`hive git` - Git operations on a project

`hive git status <PROJECT_ID>`

`hive git diff <PROJECT_ID> <PATH> [--cached]`

`hive git stage <PROJECT_ID> <PATH...>`

`hive git unstage <PROJECT_ID> <PATH...>`

`hive git commit <PROJECT_ID> --message <MSG>`

`hive git pull <PROJECT_ID>`

`hive git push <PROJECT_ID>`

Cluster Usage

Exit Codes

Logging