---
title: CLI reference
summary: Every vyre command, how to call it and what it does, taken from the CLI's own command list.
audience: users, operators, agents
owner: polish-cli
status: stable
generated: scripts/gen-docs-reference
---

# CLI reference

> Generated by `scripts/gen-docs-reference` from the command files in `core/cli/commands/`. Do not edit this page: edit the code, then run `npm run docs:ref`.

`vyre` is a thin client: every command is a call to vyred, so the terminal, the Deck and Lumen never disagree about what is true. With no arguments, `vyre` runs `vyre home` (your projects, a new session and your agents).

## Commands

In the order `vyre help` lists them.

| Command | What it does |
| --- | --- |
| [`vyre needs`](#vyre-needs) | everything waiting on you: held drafts and open asks, newest first, each with the command that answers it |
| [`vyre up`](#vyre-up) | start vyred and print the onboarding link, or this box's address |
| [`vyre down`](#vyre-down) | stop it |
| [`vyre box`](#vyre-box) | put Vyre on a server from this Mac, and look after it |
| [`vyre doctor`](#vyre-doctor) | check Vyre, your link, the relay, your devices, passkey, pairing, Claude and Lumen, and say what to fix |
| [`vyre status`](#vyre-status) | is it running, and what is it running |
| [`vyre config`](#vyre-config) | every setting, at account or project level (the Deck's Settings, in the terminal) |
| [`vyre projects`](#vyre-projects) | every project |
| [`vyre recall`](#vyre-recall) | search every session for what was said (vyre recall eval <file> to measure it) |
| [`vyre index`](#vyre-index) | index new and changed sessions now |
| [`vyre new`](#vyre-new) | make a project by picking sessions (flags: --home --thread --workspace --person --org --no-pick) |
| [`vyre open`](#vyre-open) | a project: what its threads are told, and its threads |
| [`vyre roll`](#vyre-roll) | continue a long Claude Code session in a fresh window, with nothing lost |
| [`vyre threads`](#vyre-threads) | sessions vyred runs: start, send, list, get, watch, queue, interrupt, mode, model, rewind, shell, tasks, open, asks, answer, stop (anything else searches sessions) |
| [`vyre sessions`](#vyre-sessions) | how the sessions Vyre starts run: driver, sign-in, the model per purpose, the system prompt |
| [`vyre threads`](#vyre-threads-1) | every session on this machine, searched by what was said |
| [`vyre resume`](#vyre-resume) | open a thread in Claude Code where it ran, with its project's brief (--project, --name) |
| [`vyre start`](#vyre-start) | a new thread in this folder's project, with its brief (--project) |
| [`vyre context`](#vyre-context) | what a new thread in a project is told |
| [`vyre pick`](#vyre-pick) | put threads into a project by hand |
| [`vyre unpick`](#vyre-unpick) | take picked threads out of a project |
| [`vyre setup`](#vyre-setup) | where setup stands and where to continue (--new-link: a fresh link) |
| [`vyre agenda`](#vyre-agenda) | what is on today: alarms, reminders, events and todos due |
| [`vyre agents`](#vyre-agents) | agents: list, create, update, ask, history, threads, resume, computer, usage, stop, delete |
| [`vyre capsule`](#vyre-capsule) | the Mac command bar: Control twice, anywhere |
| [`vyre gate`](#vyre-gate) | drafts held at the Gate: list, show one, approve (send), reject, or revise the words |
| [`vyre memory`](#vyre-memory) | what memory holds, or everything about one thing |
| [`vyre name`](#vyre-name) | the name this server serves: <space>.vyre.run |
| [`vyre alarm`](#vyre-alarm) | set an alarm, list them, change, turn off or delete one |
| [`vyre why`](#vyre-why) | the turns a fact came from |
| [`vyre learn`](#vyre-learn) | the lessons Vyre learned from you, and what it proposed |
| [`vyre timer`](#vyre-timer) | a timer that rings on every device |
| [`vyre remind`](#vyre-remind) | a reminder at a time |
| [`vyre assistant`](#vyre-assistant) | your assistant, or make one: vyre assistant Juno |
| [`vyre todo`](#vyre-todo) | open todos by list; add, change, finish and delete them |
| [`vyre notes`](#vyre-notes) | notes, pinned first |
| [`vyre snooze`](#vyre-snooze) | ring again later (9 minutes by default) |
| [`vyre ringing`](#vyre-ringing) | what is ringing now: alarms, timers and reminders |
| [`vyre dismiss`](#vyre-dismiss) | stop a ringing alarm, timer or reminder without finishing a todo |
| [`vyre vault`](#vyre-vault) | credentials, sealed; shared by pass; used without being seen |
| [`vyre watchers`](#vyre-watchers) | what the watchers are doing, and turning them on and off |
| [`vyre words`](#vyre-words) | the four words to compare with the Vyre app while it adds this server |
| [`vyre connect`](#vyre-connect) | MCP servers and Google accounts Vyre can reach for you |
| [`vyre run`](#vyre-run) | run a program with vault values in its environment; reads ./.env references |
| [`vyre hooks`](#vyre-hooks) | webhooks from the internet, one route at a time |
| [`vyre link`](#vyre-link) | pair this Mac with your box, or approve a Mac on the box |
| [`vyre phone`](#vyre-phone) | install the app on a phone, list, remove and test the phones the box has |
| [`vyre relay`](#vyre-relay) | reach this box from anywhere, and manage the devices that do |
| [`vyre send`](#vyre-send) | send files to another of your computers through your server |
| [`vyre vitals`](#vyre-vitals) | CPU, RAM, disk, network, GPU and battery, for this device or the server |
| [`vyre apps`](#vyre-apps) | drive the Mac's apps: timer 10 min, note: buy milk, weather tomorrow |
| [`vyre wink`](#vyre-wink) | free a server that still belongs to an app you no longer have |
| [`vyre team`](#vyre-team) | Project teammates: add one, send it work, read what came back |
| [`vyre sideview`](#vyre-sideview) | this session on the left, Chrome filling the rest |
| [`vyre spend`](#vyre-spend) | today's spend per provider and its daily cap |
| [`vyre kit`](#vyre-kit) | the Kits Vyre ships, and putting one on this Space |
| [`vyre statusline`](#vyre-statusline) | Vyre's line under every Claude Code session |
| [`vyre voice`](#vyre-voice) | push-to-talk from the terminal (Enter to talk), status, and the speech key |
| [`vyre mcp`](#vyre-mcp) | the Vyre MCP server on stdio, for plain claude |
| [`vyre update`](#vyre-update) | install the newest release after a backup, and roll back if it does not come up |
| [`vyre backup`](#vyre-backup) | seal your data, project files and session transcripts into one passphrase-locked file (an unfinished one resumes) |
| [`vyre presence`](#vyre-presence) | the keys that prove you are here, and a code to enroll a passkey |
| [`vyre reboot`](#vyre-reboot) | restart this computer the planned way (FileVault Macs come back by themselves) |
| [`vyre signin`](#vyre-signin) | sign in this terminal (approve on your phone) |
| [`vyre signout`](#vyre-signout) | sign this terminal out |
| [`vyre space`](#vyre-space) | this server's space: its details, its setup code, and which space this terminal acts in |
| [`vyre tips`](#vyre-tips) | short tips on using each part of Vyre |
| [`vyre module`](#vyre-module) | make, check, test and add a module of your own |
| [`vyre modules`](#vyre-modules) | every module and whether it started |
| [`vyre tools`](#vyre-tools) | every tool Claude and the surfaces can call |
| [`vyre call`](#vyre-call) | run any tool, e.g. vyre call system.echo '{"text":"hi"}' |
| [`vyre commands`](#vyre-commands) | every command and its verbs, as a list (--json for Lumen and chat) |
| [`vyre help`](#vyre-help) | every command, with a line on what it does |
| [`vyre version`](#vyre-version) | the version of Vyre installed |

### vyre needs

Everything waiting on you: held drafts and open asks, newest first, each with the command that answers it.

```
vyre needs [--json]
```

One list of what waits on you: drafts held at the Gate and the asks (permissions and questions)
your sessions raised. Each row has a short id, what it is, how long it has waited, where it came
from, and the command to act on it.

  vyre gate show <id>             a held draft in full
  vyre gate approve|reject <id>   send it, or discard it
  vyre threads answer <id> allow|deny, or --pick N for a question

### vyre up

Start vyred and print the onboarding link, or this box's address.

```
vyre up [--box] [--connect <addr>] [--no-capsule] [--keep-link] [--quiet] [--dry-run] [--json]
```

### vyre down

Stop it.

```
vyre down [--json]
```

### vyre box

Put Vyre on a server from this Mac, and look after it.

```
vyre box [status|add <user@host> [--yes] [--version <v>|latest]|update|backup [file] [--force]|move <user@newhost> [--yes]|remove [--purge] [--yes]] [--json]
```

### vyre doctor

Check Vyre, your link, the relay, your devices, passkey, pairing, Claude and Lumen, and say what to fix.

```
vyre doctor [--json] [--repair]
```

Read-only and under 2 s. ✓ passed, ✗ failed (the line under it is what to do), ? could not be checked.
Exit 0 when nothing failed, 1 when something did. --json: { ok, role, checks: [{ id, label, ok, detail, fix }] }.

### vyre status

Is it running, and what is it running.

```
vyre status [--json] [--ready]
```

### vyre config

Every setting, at account or project level (the Deck's Settings, in the terminal).

```
vyre config [list [group]|get <key>|set <key> <value>|reset <key>] [--project <slug>] [--account] [--json]
```

### vyre projects

Every project.

```
vyre projects [list] [--json]
```

### vyre recall

Search every session for what was said (vyre recall eval <file> to measure it).

```
vyre recall [search <query...>|status|setup|eval <file>] [--limit n] [--here] [--json]
```

vyre recall <query> or vyre recall search <query>: search · --user or --assistant: only what that side said · --keyword: no vectors
vyre recall (or vyre recall status): how much is indexed
vyre recall setup (or --setup): install the search model now (it installs itself on first use)
vyre recall eval <labelled.json> [--k 10]: measure search against a labelled set

### vyre index

Index new and changed sessions now.

```
vyre index [--json]
```

### vyre new

Make a project by picking sessions (flags: --home --thread --workspace --person --org --no-pick).

```
vyre new [name]
```

### vyre open

A project: what its threads are told, and its threads.

```
vyre open <project> [--json]
```

### vyre roll

Continue a long Claude Code session in a fresh window, with nothing lost.

```
vyre roll [--session <id>] [--thread <id>] [--print] [--no-start] [--json]
```

Run it in the folder, after /exit. It builds a seed from what you decided, an index of what came before and the last turns word for word, then starts claude here under a fresh session with the seed as its first message. Every earlier turn stays stored: memory_search finds it and memory_turn reads it back exactly.
--session <id>: roll this session (the start of its id is enough), not the newest one in this folder
--thread <id>: a session Vyre runs: ask it to roll its window over now (it does this by itself when the window fills)
--print: print the seed and start nothing, for any agent to use
--no-start: build the seed and a fresh session id, write the seed to a file, and start nothing

### vyre threads

Sessions vyred runs: start, send, list, get, watch, queue, interrupt, mode, model, rewind, shell, tasks, open, asks, answer, stop (anything else searches sessions).

```
vyre threads start|send|list|get|watch|queue|take-back|send-now|edit|interrupt|mode|model|thinking|rewind|fork|shell|remember|tasks|kill-task|commands|open|lease|release|asks|answer|stop … [--json]
```

Running a session vyred owns:
  vyre threads start [prompt] [--cwd D | --project P] [--name N] [--model M] [--purpose P]
                                                    purpose: chat, agent, project, teammate, capsule, job, memory, planner, learn, helper
  vyre threads send <thread> <text>                 mid-turn, vyred joins it to the running turn
  vyre threads send <thread> --queue <text>         hold it until the turn ends (a terminal session always does)
  vyre threads send <thread> --steer <text>         join the running turn at its next step
  vyre threads send <thread> --image F [text]       with a picture (.png .jpg .gif .webp, 5 MB, 5 at most)
  vyre threads send <thread> "!ls"                  a leading ! runs it (shell), /remember saves it; --raw sends as typed
  vyre threads send <thread> /compact               a slash command; vyre threads commands <thread> lists them
  vyre threads list [--all] [--agent A]             the headless threads of the last day (ls)
  vyre threads queue <thread>                       what is queued and not yet handed over
  vyre threads take-back|send-now <thread> <queued> take a queued message back, or hand it over now
  vyre threads edit <thread> <queued> [text]        change it (no text: $EDITOR)
  vyre threads get <thread> [--since ID] [--limit N]  one read: the record, open asks, events (show)
  vyre threads watch <thread>                       follow it live; reconnects on its own
  vyre threads interrupt <thread>                   stop the turn (Escape); the session stays
  vyre threads fork <thread> [prompt]               a new session from this one's history
  vyre threads mode <thread> [default|acceptEdits|plan]
                                                    say or set the permission mode
  vyre threads model <thread> [opus|sonnet|haiku|ID]
                                                    say or switch the model (/model)
  vyre threads thinking <thread> on|off             thinking on (the model decides how much) or off
  vyre threads rewind <thread>                      the messages to go back to; in a terminal, pick one
  vyre threads rewind <thread> <n|uuid> [--restore conversation|code|both]
                                                    back to a message (double Esc); its words come back
  vyre threads shell <thread> <command...>          run it in the thread's folder (! mode); Claude sees it next
  vyre threads remember <thread> <text> [--scope project|user|local]   a line for CLAUDE.md (/remember)
  vyre threads tasks <thread>                       its background tasks (shells, subagents)
  vyre threads kill-task <thread> <task>            stop one
  vyre threads commands <thread>                    the slash commands the running session offers
  vyre threads lease|release <thread>               take the keyboard for this terminal, or give it back
  vyre threads open <thread>                        open it in claude here (vyred lets go of an idle one)
  vyre threads stop <thread>                        end its process; the transcript stays
  Setting a mode is refused from inside Claude Code: use the Deck or a plain terminal.

Answering an ask (vyre needs and vyre threads asks [thread] list them):
  vyre threads answer <ask> allow|deny [message]    a permission, once
  vyre threads answer <ask> always [--scope project]  allow, and stop asking (where offered)
  vyre threads answer <ask> --pick 2                 a question: option 2 (1,3 for several)
  vyre threads answer <ask> --answer "Palette=Warm crust"   by question, header or number; words
                                                    that match no option are your own answer
  vyre threads answer <ask>                          in your terminal: shows it and asks
  vyre threads answer <ask> deny [message]           declines a question

--json prints each verb's data; --view prints it as frames a surface draws (a picker is a prompt frame).
Anything else (a search, --project P, --all) searches every session: vyre threads search <words>.

### vyre sessions

How the sessions Vyre starts run: driver, sign-in, the model per purpose, the system prompt.

```
vyre sessions [status|setup|models|prompt] … [--json]
```

vyre sessions [status]                          the driver, sign-in, Claude Code, the Agent SDK
  vyre sessions setup                             install the Agent SDK now and wait
  vyre sessions models                            the model each kind of session runs on
  vyre sessions models <purpose|project> <model>  set one (opus, sonnet, haiku or a model id)
  vyre sessions models <purpose|project> --clear  back to the default
                                                  purposes: chat, agent, project, teammate, capsule, job, memory, planner, learn, helper
  vyre sessions prompt [scope] [show]             what sessions are told at one level
  vyre sessions prompt [scope] set [--text T | --file F] [--replace] [--note N]
                                                  a new version; with neither, opens $EDITOR
  vyre sessions prompt [scope] history            every version, newest first
  vyre sessions prompt [scope] revert <version>   go back to one (itself a new version)
  vyre sessions prompt [scope] preview            what a session there would start with
  scope: assistant (the default), agent:<name> or project:<slug>
  --replace drops Claude Code's own system prompt: for experts.
  Setting a model or a prompt is refused from inside Claude Code: use the Deck or a plain terminal.

### vyre threads

Every session on this machine, searched by what was said.

```
vyre threads [search] [--project p] [--all] [--json]
```

### vyre resume

Open a thread in Claude Code where it ran, with its project's brief (--project, --name).

```
vyre resume <thread>
```

### vyre start

A new thread in this folder's project, with its brief (--project).

```
vyre start [name]
```

### vyre context

What a new thread in a project is told.

```
vyre context [project] [--json]
```

### vyre pick

Put threads into a project by hand.

```
vyre pick <project> <thread>...
```

### vyre unpick

Take picked threads out of a project.

```
vyre unpick <project> <thread>...
```

### vyre setup

Where setup stands and where to continue (--new-link: a fresh link).

```
vyre setup [--new-link] [--json]
```

### vyre agenda

What is on today: alarms, reminders, events and todos due.

```
vyre agenda [today|tomorrow|on <date>] [--json]
```

vyre agenda (today) · vyre agenda tomorrow · vyre agenda on 2026-10-01 (vyre agenda 2026-10-01 too)
Times are the planner's zone.

### vyre agents

Agents: list, create, update, ask, history, threads, resume, computer, usage, stop, delete.

```
vyre agents [list|create|update|ask|history|threads|resume|computer|usage|stop|delete] … [--json]
```

vyre agents [list] · every agent, what it is doing and where
vyre agents create|update <name> [--assistant --projects a,b|* --model m --vault item --fallback item --budget 20 --instructions text] · make one, or change the fields named
vyre agents ask <name> <text> · ask it something and wait for its answer
vyre agents history <name> [--limit n] [--before id] · what was asked of it, and its answers
vyre agents resume <name> [thread] · bring its latest thread (or that one) back, with its own credentials
vyre agents computer <name> · its computer: state, screen, cores and memory
vyre agents computer <name> restart · a new container on the same home; what is open on its screen closes
vyre agents computer <name> limits [--cpus n] [--memory gb] · shown, or set for the next restart
vyre agents threads <name> · its threads · vyre agents usage [name] · turns, time, tokens and spend
vyre agents stop <name> · stop its threads · vyre agents delete <name> · delete it (its transcripts stay)

### vyre capsule

The Mac command bar: Control twice, anywhere.

```
vyre capsule [open [--hidden] | install | build] [--json]
```

### vyre gate

Drafts held at the Gate: list, show one, approve (send), reject, or revise the words.

```
vyre gate [list|show <id>|approve <id>|reject <id> [reason]|revise <id>] [--json]
```

Also: `vyre drafts`.

Everything an agent or session wants to send, spend or delete waits at the Gate until you say.

  vyre gate                          the held drafts, newest first (--project, --thread)
  vyre gate show <id>                one in full: where it goes, the words, what approving takes
  vyre gate approve <id>             send exactly what show shows; asks you to prove it is you
                                     once, then this terminal is trusted for 30 minutes
  vyre gate reject <id> [reason]     discard it; nothing is sent
  vyre gate revise <id>              change the words in $EDITOR, or --text <words> / --file <path>
                                     (--file - reads stdin); --subject, --to a,b, --set key=value

An id is its first few characters, as vyre needs and vyre gate print them.

### vyre memory

What memory holds, or everything about one thing.

```
vyre memory [about [<thing...>]|ask <question...>|fix [<answer id> <fix>]|correct <fact> <action>|corrections|uncorrect <id>|merge <node> <into>|split <node>|pin <node>|mute <node>] [--project <slug>] [--json]
```

Read it:
  vyre memory [about] [<thing>] [--project <slug>]   what it holds, or everything about one thing
Ask it:
  vyre memory ask "<question>" [--sources]   Vyre Memory: an answer from your past sessions and what you have said, with where it came from
  vyre memory fix <answer id> wrong | forget | "<the right answer>"   correct an answer; remembered next time
  vyre memory fix [undo <n>]   what you corrected this week, or undo one
Change what it holds:
  vyre memory correct <fact> wrong|ended|replace|confirm [new object] [--at <date>] [--note <why>] [--project <slug>]
  vyre memory correct '<subject>|<rel>|<object>' add [--project <slug>]
  vyre memory corrections [--all] · vyre memory uncorrect <id>
  vyre memory merge <node> <into>
  vyre memory split <node> --project <slug>   (that project's one is someone else)
  vyre memory split <node> <other>             (keep two nodes apart)
  vyre memory pin|mute <node> [--off]

### vyre name

The name this server serves: <space>.vyre.run.

```
vyre name [status|check <n>] [--json]
```

### vyre alarm

Set an alarm, list them, change, turn off or delete one.

```
vyre alarm [list|set <time...>|off <id>|edit <id> <time...>|rm <id>] [--json]
```

vyre alarm 7am (or vyre alarm set 7am) · vyre alarm 6:30 weekdays · vyre alarm (upcoming, or vyre alarm list) · vyre alarm off <id>
vyre alarm edit <id> 8am (a repeating alarm keeps its days unless you name new ones) · vyre alarm rm <id>
Times are the planner's zone (vyre agenda shows it). Alarms follow the zone when it changes.

### vyre why

The turns a fact came from.

```
vyre why <fact> [--project <slug>] [--json]
```

### vyre learn

The lessons Vyre learned from you, and what it proposed.

```
vyre learn [list|show|add|accept|retire|level|scope|relax|stats|signals|skills] [--json]
```

Also: `vyre lessons`.

vyre learn [list]                          the active lessons and the ones waiting for your yes
  vyre learn show <id>                       one lesson, its check and its effect
  vyre learn add <text>                      a lesson in your own words
  vyre learn accept|retire <id>              say yes to a proposed lesson, or stop one
  vyre learn level <id> remind|ask|block     how firmly it holds (lowering it needs you)
  vyre learn scope <id> all|project [slug]|agent <name>
  vyre learn relax <id> level <l> | max <l> | pin | paths <pattern> | when <text> | scope ...
  vyre learn stats · vyre learn signals      each lesson's effect · what Learning heard
  vyre learn skills [show|install|retire|dismiss <id>] [--agent name|--account|--project] [--private]

### vyre timer

A timer that rings on every device.

```
vyre timer [list|set <length> [label...]|edit <id> <length> [label...]|rm <id>] [--json]
```

vyre timer 10m (or vyre timer set 10m) · vyre timer 1h30m · vyre timer 25m bread · vyre timer list
vyre timer edit <id> 15m (it starts again from now) · vyre timer rm <id>

### vyre remind

A reminder at a time.

```
vyre remind [list|set <words...>|edit <id> <words...>|rm <id>] [--json]
```

vyre remind "call juno" at 6 (or vyre remind set ...) · vyre remind me in 20 minutes to check the oven · vyre remind me tomorrow at 9 to email juno
vyre remind list · vyre remind edit <id> "call juno" at 7 (words without a time keep the time) · vyre remind rm <id>

### vyre assistant

Your assistant, or make one: vyre assistant Juno.

```
vyre assistant [name] [--json]
```

With no name: who your assistant is. With a name: make it, as onboarding does, if there is none yet.
On a Mac paired with a box, the assistant lives on the box.

### vyre todo

Open todos by list; add, change, finish and delete them.

```
vyre todo [list|add <text...>|done <id>|edit <id> <text...>|rm <id>] [--json]
```

vyre todo (or vyre todo list) · vyre todo add buy flour !high · vyre todo add call kit by friday · vyre todo done <id>
vyre todo edit <id> buy rye flour !! · vyre todo rm <id>
Priority: !low, !!, !high.

### vyre notes

Notes, pinned first.

```
vyre notes [list|add <text...>|show <id>|edit <id> <text...>|rm <id>] [--json]
```

vyre notes (or vyre notes list) · vyre notes add kit prefers mornings · vyre notes show <id>
vyre notes edit <id> kit prefers afternoons · vyre notes rm <id>

### vyre snooze

Ring again later (9 minutes by default).

```
vyre snooze <id> [minutes] [--json]
```

### vyre ringing

What is ringing now: alarms, timers and reminders.

```
vyre ringing [--json]
```

### vyre dismiss

Stop a ringing alarm, timer or reminder without finishing a todo.

```
vyre dismiss <id> [--json]
```

vyre dismiss <firing id or item id> · vyre ringing lists what rings
A one-off alarm, timer or reminder ends; a repeating alarm rings again at its next time.

### vyre vault

Credentials, sealed; shared by pass; used without being seen.

```
vyre vault [list|get|read|put|edit|delete|inject|share|ssh|git-credential|pair|devices|unlock-passphrase|backup|restore|autobackup|relay|grant|revoke|pending|approve|run|totp|scan-env|health|remind|breach|history|revert|clear-clipboard|needs|connect|connections|sweep|rotate|agent|uses|codes|emergency|generate|import|audit|card|people|fingerprint|kit|vaults|members|move|device|pass|offboard|unlock|lock|account|migrate-key|help] [--json]
```

### vyre watchers

What the watchers are doing, and turning them on and off.

```
vyre watchers [list|test|create|pause|resume|logs|items] [name] [--json]
```

### vyre words

The four words to compare with the Vyre app while it adds this server.

```
vyre words [--json]
```

While the Vyre app is adding this server, the server and the app each show four words.
If they are the same, choose Same in the app. This prints the server's four.

### vyre connect

MCP servers and Google accounts Vyre can reach for you.

```
vyre connect list|apps|add|remove|rm|test|help [--json]
```

### vyre run

Run a program with vault values in its environment; reads ./.env references.

```
vyre run [--env-file f] [<item...>] -- <command...>
```

### vyre hooks

Webhooks from the internet, one route at a time.

```
vyre hooks [list|status|on|off|open <name>|close <name>] [--json]
```

### vyre link

Pair this Mac with your box, or approve a Mac on the box.

```
vyre link [status|pair <address>|approve <code>|deny <id>|unpair [id]|signin|signout] [--json]
```

### vyre phone

Install the app on a phone, list, remove and test the phones the box has.

```
vyre phone [add --android [--usb|--wireless]|list|remove <id...>|test [id]] [--json]
```

vyre phone add --android --usb      the native app over a cable: downloads the APK the box serves,
                                      checks its size and sha256 and installs it with adb
  vyre phone add --android --wireless the same over Wireless debugging
  vyre phone list                     the devices that get notifications, and the passkeys
  vyre phone remove <id>...           forget a notification device, or remove a passkey (asks you first)
  vyre phone test [id]                send a test notification to every device, or one

  A phone joins by signing in with your name and being approved on a device you already use: Devices, Add a device.
  The old pairing code is gone, so add installs the app and says so; it pairs nothing.

### vyre relay

Reach this box from anywhere, and manage the devices that do.

```
vyre relay [status|devices|remove <id>|rename <id> <name>|trust <id> [--off]|on [--url u]|off|pin <release>|unpin] [--json]
```

vyre relay: whether the relay is on and connected
vyre relay devices: paired devices, which are connected, and how
vyre relay remove|rename|trust: manage one (a browser from the web app is limited until trusted)
vyre relay on|off, pin <release>|unpin: the relay itself, and which web app build this box trusts

### vyre send

Send files to another of your computers through your server.

```
vyre send <file...> [--to <computer>] [--json]
```

### vyre vitals

CPU, RAM, disk, network, GPU and battery, for this device or the server.

```
vyre vitals [status|explain|advice] [--device <name>] [--json]
```

### vyre apps

Drive the Mac's apps: timer 10 min, note: buy milk, weather tomorrow.

```
vyre apps [list | find <words...> | targets <app> [words...] | setup <app> | <words...>] [--app <App>] [--to <who>] [--model] [--json]
```

### vyre wink

Free a server that still belongs to an app you no longer have.

```
vyre wink reset --begin | --confirm <code> | vyre wink confirm [--no] [--json]
```

vyre wink reset --begin: run on the server, in a terminal. It shows a one-time code (5 minutes, once) on that terminal only. Then vyre wink reset --confirm <code> frees the server: it forgets its owner and can be paired again. Its keys stay. Five wrong codes lock it for an hour.

### vyre team

Project teammates: add one, send it work, read what came back.

```
vyre team [add|ask|status|cancel|notes] … [--project slug] [--json]
```

vyre team                     this project's teammates, states and queues
vyre team add <role>          add a teammate
vyre team ask <role> <text>   send it work; --urgent, --wait, --model codex|grok|provider/model
vyre team status <request>    one request's state and result
vyre team cancel <request>    cancel a queued request
vyre team notes <agent>       read its notes

### vyre sideview

This session on the left, Chrome filling the rest.

```
vyre sideview [open|close|status] [--glass [name]] [--url U] [--ratio R] [--terminal] [--json]
```

### vyre spend

Today's spend per provider and its daily cap.

```
vyre spend [raise <provider> <usd|+usd|off>] [--json]
```

Read it:
  vyre spend                          today's spend (UTC) per provider against its cap
Change a cap:
  vyre spend raise <provider> <usd>   set the cap in dollars (provider all: every provider together)
  vyre spend raise <provider> +<usd>  add to it
  vyre spend raise <provider> off     no cap
At a cap the spending thread pauses with one line, and Vyre Memory answers from facts and search.

### vyre kit

The Kits Vyre ships, and putting one on this Space.

```
vyre kit [deploy <kit>] [--json]
```

List them:
  vyre kit                  the Kits on offer, with what each adds and whether it is installed
Put one on this Space:
  vyre kit deploy <kit>     propose the Kit, and the Kit it needs first, in one step. Each waits for your yes in Now; nothing installs until you say it (vyre needs).

### vyre statusline

Vyre's line under every Claude Code session.

```
vyre statusline [show | install [--chain] [--yes] | uninstall] [--json]
```

### vyre voice

Push-to-talk from the terminal (Enter to talk), status, and the speech key.

```
vyre voice [talk [--send <thread>] | status | key [provider] [--stdin]] [--json]
```

### vyre mcp

The Vyre MCP server on stdio, for plain claude.

```
vyre mcp [serve | design | connect | list | revoke <id> | install [--yes]] [--json]
```

### vyre update

Install the newest release after a backup, and roll back if it does not come up.

```
vyre update [--check] [--channel stable|beta] [--to <version>] [--yes] [--allow-unsigned] [--rollback [--restore-data]] [--json]
```

--check          say whether a newer release is out; exit 0 when current, 1 when one waits
--channel NAME   stable (the default, or config update.channel) or beta
--to VERSION     a given release, for stepping through one an update asks for
--yes            do not ask first (needed when there is no terminal to ask on)
--rollback       put the previous release back and keep the current data
--restore-data   with --rollback: also put back the data from before the update

Every download is checked against the release's SHA256SUMS. On a box, the host's
vyre update does this; from a checkout, update with git.

### vyre backup

Seal your data, project files and session transcripts into one passphrase-locked file (an unfinished one resumes).

```
vyre backup [file] [--skip-projects] [--skip-transcripts] [--work DIR] [--with-provider-logins]
```

### vyre presence

The keys that prove you are here, and a code to enroll a passkey.

```
vyre presence [keys|code|remove <id>] [--json]
```

### vyre reboot

Restart this computer the planned way (FileVault Macs come back by themselves).

```
sudo vyre reboot [--yes] [--dry-run]
```

--dry-run   say what it would do and stop
--yes       do not ask first (needed when there is no terminal to ask on)

A Mac server with FileVault on restarts through `fdesetup authrestart`, so it returns to the
desktop and Vyre starts without anyone at the login window. Other computers restart normally.

### vyre signin

Sign in this terminal (approve on your phone).

```
vyre signin [--json]
```

Asks your phone to approve. On a yes this terminal acts as you until `vyre signout`, or 30 days without use. Run it in a terminal you are logged in on.

### vyre signout

Sign this terminal out.

```
vyre signout [--json]
```

### vyre space

This server's space: its details, its setup code, and which space this terminal acts in.

```
vyre space [up | use <name> | use --clear | add-agent <space> <agent>] [--json]
```

`vyre space` shows the space's name, owner, members, Records, vault and version. `vyre space up` shows the code that sets it up from the Vyre app (again, any time). `vyre space use harlow` remembers harlow for this terminal's calls: `vyre call records.list` then acts in it, and `--space <name>` on one call overrides it. With none, calls act in the home's own space.

### vyre tips

Short tips on using each part of Vyre.

```
vyre tips [module | new | reset] [--json]
```

### vyre module

Make, check, test and add a module of your own.

```
vyre module new <name> [--dir <parent>] | check [dir] | test [dir] | upgrade [dir] [--dry-run] | add <path|git url> [--yes]
```

new <name>        a module on module API 1 that passes check, test and its own test, in
                  <home>/modules/<name>, with AGENTS.md: the brief to hand an agent
  --dir PARENT    make it in PARENT/<name> instead
check [dir]       the manifest (schema and loader rules) and the entry file; exit 1 on a problem
test [dir]        the conformance checks every module passes, then its own *.test.js files
upgrade [dir]     move a module onto the current contract: apiVersion to vyre, string tools to
                  objects, ctx.memory.teach to ctx.memory.write; lists what it can't do, then
                  runs the conformance checks
  --dry-run       show the changes and check a copy; write nothing
add <source>      a folder or a git URL (https://, git@, file://): check it, show what it asks
                  for, copy it into <home>/modules and restart vyred to load it
  --yes           do not ask first (needed without a terminal, and with --json or --view)

A module runs inside vyred, trusted like an npm package. A module named like one of Vyre's
own is refused, and in 0.2 an added module may not say "replaces".
In the box's container, the host restarts vyred: docker compose restart vyre.
--view prints frames for Lumen and the phone (docs/reference/cli-json.md).

### vyre modules

Every module and whether it started.

```
vyre modules [--json]
```

### vyre tools

Every tool Claude and the surfaces can call.

```
vyre tools [--json]
```

### vyre call

Run any tool, e.g. vyre call system.echo '{"text":"hi"}'.

```
vyre call [--tty] [--space <name>] <tool> [json]
```

Prints the tool's data as JSON. A tool that needs you (approving a draft, answering an ask)
asks you to prove you are here first: Touch ID, or with --tty a code typed back.

### vyre commands

Every command and its verbs, as a list (--json for Lumen and chat).

```
vyre commands [<command>] [--all] [--json]
```

Reads the command files, so it works before vyre up. --all includes hidden commands.

### vyre help

Every command, with a line on what it does.

```
vyre help
```

Also: `vyre --help`, `vyre -h`.

### vyre version

The version of Vyre installed.

```
vyre version
```

Also: `vyre --version`, `vyre -v`.

## Not listed by vyre help

These work, but `vyre help` leaves them out: they are for the box's service manager, for setup and recovery, or what `vyre` runs with no arguments.

| Command | What it does |
| --- | --- |
| [`vyre home`](#vyre-home) | your projects, a new session, and your agents |
| [`vyre restore`](#vyre-restore) | put a backup back (vyred must be stopped); --recovery-code brings the Space back too |
| [`vyre uninstall`](#vyre-uninstall) | remove the systemd units (the data stays unless --purge) |
| [`vyre daemon`](#vyre-daemon) | run vyred in the foreground (what systemd runs) |

### vyre home

Your projects, a new session, and your agents.

```
vyre home
```

### vyre restore

Put a backup back (vyred must be stopped); --recovery-code brings the Space back too.

```
vyre restore <file> [--force] [--skip-projects] [--skip-transcripts] [--work-to DIR] [--recovery-code CODE]
```

### vyre uninstall

Remove the systemd units (the data stays unless --purge).

```
vyre uninstall --system [--purge] [--dry-run]
```

### vyre daemon

Run vyred in the foreground (what systemd runs).

```
vyre daemon
```
