wire::cli

Enum Command

pub enum Command {
Show 59 variants    Init {
        relay: Option<String>,
        offline: bool,
        json: bool,
    },
    Whoami {
        json: bool,
        short: bool,
        colored: bool,
    },
    Peers {
        json: bool,
    },
    Dash {
        watch: bool,
        json: bool,
        all: bool,
        probe: bool,
        retired: bool,
        retire_idle: bool,
        older_than: Option<u64>,
        dry_run: bool,
        force: bool,
    },
    Retire {
        target: String,
        force: bool,
        json: bool,
    },
    Revive {
        target: String,
        json: bool,
    },
    Completions {
        shell: Shell,
    },
    Here {
        json: bool,
    },
    Pending {
        json: bool,
    },
    Send {
        peer: String,
        kind_or_body: String,
        body: Option<String>,
        deadline: Option<String>,
        no_auto_pair: bool,
        queue: bool,
        json: bool,
    },
    SendProject {
        project: String,
        body: String,
        kind: String,
        deadline: Option<String>,
        json: bool,
    },
    Project {
        tag: Option<String>,
        clear: bool,
        json: bool,
    },
    Dial {
        name: String,
        message: Option<String>,
        json: bool,
    },
    Tail {
        peer: Option<String>,
        json: bool,
        limit: usize,
        oldest: bool,
    },
    Monitor {
        peer: Option<String>,
        json: bool,
        include_handshake: bool,
        interval_ms: u64,
        replay: usize,
    },
    Verify {
        path: String,
        json: bool,
    },
    Mcp,
    RelayServer {
        bind: String,
        local_only: bool,
        uds: Option<PathBuf>,
    },
    BindRelay {
        url: String,
        scope: Option<String>,
        replace: bool,
        migrate_pinned: bool,
        json: bool,
    },
    AddPeerSlot {
        handle: String,
        url: String,
        slot_id: String,
        slot_token: String,
        json: bool,
    },
    Push {
        peer: Option<String>,
        json: bool,
    },
    Pull {
        json: bool,
    },
    Ping {
        peer: String,
        json: bool,
    },
    Status {
        peer: Option<String>,
        json: bool,
        wait_daemon_running: bool,
        timeout: u64,
    },
    Responder {
        command: ResponderCommand,
    },
    Pin {
        card_file: String,
        json: bool,
    },
    RotateSlot {
        no_announce: bool,
        json: bool,
    },
    ForgetPeer {
        handle: String,
        purge: bool,
        json: bool,
    },
    Supervisor {
        json: bool,
    },
    Daemon {
        interval: u64,
        once: bool,
        all_sessions: bool,
        session: Option<String>,
        json: bool,
    },
    Session(SessionCommand),
    Identity {
        cmd: IdentityCommand,
    },
    Mesh(MeshCommand),
    Group(GroupCommand),
    Enroll(EnrollCommand),
    Org(OrgCommand),
    Nostr(NostrCommand),
    Setup {
        apply: bool,
        statusline: bool,
        remove: bool,
    },
    Whois {
        handle: Option<String>,
        json: bool,
        relay: Option<String>,
    },
    Add {
        handle: String,
        relay: Option<String>,
        local_sister: bool,
        json: bool,
    },
    Up {
        relay: Option<String>,
        offline: bool,
        with_local: Option<String>,
        no_local: bool,
        json: bool,
    },
    Demo {
        json: bool,
    },
    Doctor {
        json: bool,
        recent_rejections: usize,
    },
    Upgrade {
        check: bool,
        local: bool,
        restart_mcp: bool,
        refresh_stale_children: bool,
        json: bool,
    },
    Nuke {
        force: bool,
        purge: bool,
        dry_run: bool,
        really_this_machine: bool,
        json: bool,
    },
    Service {
        action: ServiceAction,
    },
    Diag {
        action: DiagAction,
    },
    Claim {
        nick: String,
        relay: Option<String>,
        public_url: Option<String>,
        hidden: bool,
        json: bool,
    },
    Unclaim {
        relay: Option<String>,
        json: bool,
    },
    Profile {
        action: ProfileAction,
    },
    Invite {
        relay: String,
        ttl: u64,
        uses: u32,
        share: bool,
        json: bool,
    },
    Accept {
        target: String,
        json: bool,
    },
    AcceptInvite {
        url: String,
        json: bool,
    },
    Reject {
        peer: String,
        json: bool,
    },
    BlockPeer {
        did: String,
        note: Option<String>,
        json: bool,
    },
    UnblockPeer {
        did: String,
        json: bool,
    },
    Blocked {
        json: bool,
    },
    Notify {
        interval: u64,
        peer: Option<String>,
        once: bool,
        json: bool,
    },
    Quiet {
        action: QuietAction,
    },
}

Variants§

§

Init

Generate a keypair, write self-card, and bind an inbound slot. (HUMAN-ONLY — DO NOT exec from agents.)

v0.9: refuses to create a slotless session by default. Pre-v0.9 the silent slotless state caused the 2026-05-23 silent-fail incident — pairing + sending succeeded but peers black-holed inbound. Operators must now name how the session is reachable: --relay <url> (binds a slot inline) or --offline (opt into slotless, acknowledge wire bind-relay is required before any pair or send).

Internal primitive — folded into wire up and hidden. Your handle is your DID-derived persona (one-name rule); there is no name to type. Init is the sole naming event: it mints the keypair and the persona is derived from it. Users never type this — wire up runs it, and wire up --offline covers offline keygen. Kept as a callable command only because wire up / wire session new invoke it internally.

Fields

§relay: Option<String>

Relay URL — binds an inbound slot in the same step. Required unless --offline is passed. Example: --relay http://127.0.0.1:8771 (local), --relay https://wireup.net (federation).

§offline: bool

v0.9: opt into a slotless session — keypair only, no inbound mailbox. You MUST run wire bind-relay <url> before any pair / send / dial; until then peers cannot reach you. Useful for offline keypair generation; rare in practice.

§json: bool

Emit JSON.

§

Whoami

Print this agent’s identity (DID, fingerprint, mailbox slot).

Fields

§json: bool

§short: bool

Print just <emoji> <nickname> (e.g. 🦊 foxtrot-meadow). Plain text, no ANSI escapes. Useful for piping into other tools.

§colored: bool

Print <emoji> <nickname> wrapped in ANSI 256-color escapes. Drop into a Claude Code statusline command for live identity display.

§

Peers

List pinned peers with their tiers and capabilities.

Fields

§json: bool

§

Dash

One pane for every wire identity on this box — daemon liveness, pinned peers, relay binding, and sync recency. Read-only; paired sessions float to the top, idle solo daemons collapse into a count.

Fields

§watch: bool

Live-refresh every 2s (Ctrl-C to exit).

§json: bool

Emit the full snapshot as JSON (the wire-dash-v1 surface).

§all: bool

Show idle solo daemons too (hidden by default).

§probe: bool

Probe each distinct relay’s /healthz (one GET per relay).

§retired: bool

List retired identities (otherwise collapsed/hidden).

§retire_idle: bool

Reversibly retire every idle solo daemon (0 peers, not current, idle past the cutoff). Dry-run unless confirmed.

§older_than: Option<u64>

Idle cutoff in days for –retire-idle (default 7).

§dry_run: bool

Preview –retire-idle without retiring anything.

§force: bool

Skip the typed confirmation for –retire-idle (automation). Never bypasses the current/paired/pending/recent guards.

§

Retire

Reversibly decommission an identity you’re done with — stop its daemon and stop the supervisor from respawning it. wire revive undoes it.

Fields

§target: String

Handle, fingerprint, or session key of the identity to retire.

§force: bool

Retire even a paired (mesh-member) identity.

§json: bool

§

Revive

Bring a retired identity back — the supervisor respawns its daemon.

Fields

§target: String

Handle, fingerprint, or session key of the identity to revive.

§json: bool

§

Completions

Emit a shell completion script to stdout.

Pipe to your shell’s completion dir to enable tab-completion of wire verbs + handles + flags.

Example installs: bash: wire completions bash > /etc/bash_completion.d/wire zsh: wire completions zsh > ~/.zsh/completions/_wire fish: wire completions fish > ~/.config/fish/completions/wire.fish pwsh: wire completions powershell > $PROFILE (append) elvish: wire completions elvish > ~/.elvish/lib/wire.elv

Fields

§shell: Shell

Shell to generate completions for.

§

Here

One-screen “you are here” — your character, handle, cwd, and neighbors.

Prints the current session’s character + handle + cwd, plus a short list of neighbors (sister sessions on the local relay, pinned peers). Designed for the operator’s quick “wait which Claude is this, and who’s around?” question — no --json shuffling, no remembering wire whoami vs wire peers vs wire session list-local.

Fields

§json: bool

§

Pending

List pending-inbound pair requests waiting for your consent.

Operators reach for “what’s pending?” not a longer table-dump verb.

Fields

§json: bool

§

Send

Sign and queue an event to a peer.

Forms (P0.S 0.5.11): wire send

# kind defaults to “claim” wire send

# explicit kind (back-compat) wire send - # body from stdin (kind=claim) wire send @/path/to/body.json # body from file

Fields

§peer: String

Peer handle (without did:wire: prefix).

§kind_or_body: String

When <body> is omitted, this is the event body (kind defaults to claim). When both this and <body> are given, this is the event kind (decision, claim, etc., or numeric kind id) and the next positional is the body.

§body: Option<String>

Event body — free-form text, @/path/to/body.json to load from a file, or - to read from stdin. Optional; omit to use <kind_or_body> as the body with kind=claim.

§deadline: Option<String>

Advisory deadline: duration (30m, 2h, 1d) or RFC3339 timestamp.

§no_auto_pair: bool

v0.10: skip the v0.9 auto-pair-on-miss behavior. Send fails loudly if the peer isn’t pinned yet. Use when you want strict “no implicit dialing” semantics — scripts that error vs. performing a side-effecting pair as a fallback.

§queue: bool

v0.14.2: opt back into the legacy outbox→daemon-push pipeline. By default wire send POSTs to the peer’s relay slot synchronously and returns a real delivered / duplicate / failed verdict. With --queue the event is appended to <outbox_dir>/<peer>.jsonl and the daemon’s push loop drains it later (pre-v0.14.2 behavior). Use for offline buffering, batch sends, or pre-pair queueing.

§json: bool

Emit JSON.

§

SendProject

Fan a single signed message out to every org-mate tagged with a project (RFC-001 §6 client-side project routing).

Recipients = every pinned peer at effective tier >= ORG_VERIFIED whose card carries project == <project>. The tier floor is the trust gate; project is unsigned routing metadata (it picks who, never grants trust). Delivery is N synchronous one-to-one pushes — wire has no broadcast primitive. Zero matching peers is a no-op success.

Set your own project tag with wire project <tag>; peers see it on your card once they pin (or re-pull) it.

Fields

§project: String

Project tag to fan out to (must match peers’ card project).

§body: String

Event body — free-form text, @/path/to/body.json, or - for stdin.

§kind: String

Event kind (claim, decision, … or numeric id). Default claim.

§deadline: Option<String>

Advisory deadline: duration (30m, 2h, 1d) or RFC3339 timestamp.

§json: bool

Emit JSON.

§

Project

Show, set, or clear this session’s project routing tag (RFC-001 §6).

wire project prints the current tag; wire project <tag> sets it; wire project --clear removes it. The tag is unsigned metadata on your agent-card — peers who pin your card use it to target wire send-project <tag> fan-outs. Set it before pairing (or re-pair after) so the change reaches peers.

Fields

§tag: Option<String>

New project tag. Omit to print the current tag.

§clear: bool

Clear the project tag instead of setting one.

§json: bool

Emit JSON.

§

Dial

“Go talk to this name.” The one verb operators reach for.

wire dial <name> accepts a character nickname (noble-slate), a session name (slancha-api), a card handle, or a DID — whichever face you happen to know the peer by. Resolution order:

Already-pinned peer? → no-op (or send if a message was passed).
Local sister session? → bilateral pair via the disk-read --local-sister path (no relay round-trip, no .well-known lookup, no SAS digits).
Otherwise → bail with a clear hint pointing at federation syntax (wire dial <handle>@<relay> for cross-machine peers).

With an optional message, wire dial <name> "<msg>" also sends the message synchronously after the pair lands (#187 collapsed the legacy queue→push step into a single direct relay POST; the response carries the actual delivered/duplicate/etc. verdict). Idempotent: re-dialling a known peer just sends.

Fields

§name: String

Peer name. Character nickname (preferred), session name, card handle, or DID — anything that identifies the peer to you.

§message: Option<String>

Optional first message to send after the pair lands. Same semantics as the body argument to wire send. Defaults to kind=claim.

§json: bool

Emit JSON.

§

Tail

Stream signed events from peers.

Defaults to NEWEST-N orientation: with --limit N, prints the most recent N events across all matched peers, sorted chronologically (oldest of the window first, newest last — same orientation as Unix tail). Pass --oldest to flip back to first-N (FIFO) behaviour. --limit 0 returns the full inbox in chronological order.

Fields

§peer: Option<String>

Optional peer filter; if omitted, tails all peers.

§json: bool

Emit JSONL (one event per line).

§limit: usize

Maximum events to print. 0 = print everything (oldest → newest).

§oldest: bool

Return the FIRST --limit events (oldest-N) instead of the default last-N (newest-N). No effect when --limit is 0.

§

Monitor

Live tail of new inbox events across all pinned peers — one line per new event, handshake (pair_drop / pair_drop_ack / heartbeat) filtered by default.

Designed to be left running in an agent harness’s stream-watcher (Claude Code Monitor tool, etc.) so peer messages surface in the session as they arrive, not on next manual wire pull.

See docs/AGENT_INTEGRATION.md for the recommended Monitor invocation template.

Fields

§peer: Option<String>

Only show events from this peer.

§json: bool

Emit JSONL (one InboxEvent per line) for tooling consumption.

§include_handshake: bool

Include handshake events (pair_drop, pair_drop_ack, heartbeat). Default filters them out as noise.

§interval_ms: u64

Poll interval in milliseconds. Lower = lower latency, higher CPU.

§replay: usize

Replay last N events from history before going live (0 = none).

§

Verify

Verify a signed event from a JSON file or stdin (-).

Fields

§path: String

Path to event JSON, or - for stdin.

§json: bool

Emit JSON.

§

Mcp

Run the MCP (Model Context Protocol) server over stdio. This is how Claude Desktop / Claude Code / Cursor / etc. expose wire_send, wire_tail, etc. as native tools.

§

RelayServer

Run a relay server on this host.

Fields

§bind: String

Bind address (e.g. 127.0.0.1:8770).

§local_only: bool

v0.5.17: refuse non-loopback binds, skip phonebook listing, skip .well-known/wire/agent serving. The relay becomes invisible from outside the box — only same-machine processes can pair through it. Right call for within-machine agent coordination where you don’t want metadata leaking to a public relay. Pair this with wire session new which probes 127.0.0.1:8771 and allocates a local slot automatically.

§uds: Option<PathBuf>

v0.7.0-alpha.16: bind to a Unix Domain Socket instead of TCP. When set, –bind is ignored. Implies –local-only semantics (no phonebook, no .well-known). Socket is chmod 0600 (owner- rw only), giving SO_PEERCRED-equivalent same-uid trust for sister sessions. Unix only (Windows refuses).

§

BindRelay

Allocate a slot on a relay; bind it to this agent’s identity.

v0.5.19 (issue #7): if any peers are pinned to this agent’s current slot, this command refuses by default — silent migration silently black-holes their inbound messages. Pass --migrate-pinned to acknowledge the risk and proceed, or use wire rotate-slot (which emits a wire_close event to peers) for safe rotation.

Fields

§url: String

Relay base URL, e.g. http://127.0.0.1:8770.

§scope: Option<String>

Endpoint scope: federation | local | lan | uds. Default inferred from the URL (loopback host -> local, unix:// -> uds, otherwise federation). Pass explicitly when the inference is ambiguous (e.g. a federation relay on a loopback address in tests).

§replace: bool

DESTRUCTIVE: drop all existing self slots and bind only this relay (the pre-v0.12 single-slot behavior). Default is ADDITIVE — the new slot is appended to self.endpoints[], keeping any existing slots so pinned peers are not black-holed.

§migrate_pinned: bool

Acknowledge that pinned peers will black-hole until they re-pin manually. Required for --replace (and same-relay rotation) when state.peers is non-empty; ignored on fresh boxes. Use wire rotate-slot instead for the supported same-relay rotation path.

§json: bool

§

AddPeerSlot

Manually pin a peer’s relay slot from out-of-band coordinates. Plumbing — prefer wire dial (which resolves + pairs for you).

Fields

§handle: String

Peer handle (becomes did:wire:).

§url: String

Peer’s relay base URL.

§slot_id: String

Peer’s slot id.

§slot_token: String

Slot bearer token (shared between paired peers in v0.1).

§json: bool

§

Push

Drain outbox JSONL files to peers’ relay slots.

Fields

§peer: Option<String>

Optional peer filter; default = all peers with outbox entries.

§json: bool

§

Pull

Pull events from our relay slot, verify, write to inbox.

Fields

§json: bool

§

Ping

Liveness probe a paired peer (RFC-004). Sends a probe and waits for the peer’s daemon to auto-respond, reporting the round-trip — no LLM on the responder side. Trust-neutral: never changes any peer’s tier.

Fields

§peer: String

Peer handle (a pinned peer, or nick@relay).

§json: bool

§

Status

Print a summary of identity, relay binding, peers, inbox/outbox queue depth. Useful as a single “where am I” check.

Fields

§peer: Option<String>

Inspect a paired peer’s transport / attention / responder health.

§json: bool

§wait_daemon_running: bool

Block until daemon_running:true, then exit 0. Polls internally every 200ms up to --timeout seconds. Exit 1 on timeout (with the last seen status to stderr). Replaces fragile external until wire status … | grep daemon_running:true shell loops that piled up hundreds of wire status invocations on a never-healthy host (#284.2).

§timeout: u64

Bound for --wait-daemon-running. Default 30s.

§

Responder

Publish or inspect auto-responder health for this slot.

Fields

§command: ResponderCommand

§

Pin

Pin a peer’s signed agent-card from a file. (Manual out-of-band pairing — fallback path; the canonical flow is wire dial <handle>@<relay>.)

Fields

§card_file: String

Path to peer’s signed agent-card JSON.

§json: bool

§

RotateSlot

Allocate a NEW slot on the same relay and abandon the old one. Sends a kind=1201 wire_close event to every paired peer over the OLD slot announcing the new mailbox before swapping. After rotation, peers must re-pair (or operator runs add-peer-slot with the new coords) — auto-update via wire_close is a v0.2 daemon feature.

Use case: a paired peer turned hostile (T11 in THREAT_MODEL.md — abusive bearer-holder spamming your slot). Rotate → old slot is orphaned → attacker’s leverage gone. Operator pairs again with peers they still want.

Fields

§no_announce: bool

Skip the wire_close announcement to peers (faster but they won’t know where you went).

§json: bool

§

ForgetPeer

Remove a peer from trust + relay state. Inbox/outbox files for that peer are NOT deleted (operator can grep history); pass –purge to also wipe the JSONL files.

Fields

§handle: String

Peer handle to forget.

§purge: bool

Also delete inbox/.jsonl and outbox/.jsonl.

§json: bool

§

Supervisor

Multi-session topology: supervisor + every session’s daemon liveness.

Supervisor liveness + per-session daemon liveness + unmanaged wire daemon pids. wire status answers “is THIS session syncing?”; wire supervisor answers “what is the supervisor (and every session’s daemon) doing across the box?”.

Fields

§json: bool

Emit JSON instead of human-readable text. The shape matches the SupervisorState struct in daemon_supervisor.rs.

§

Daemon

Run a long-lived sync loop: every seconds, push outbox to peers’ relay slots and pull inbox from our own slot. Foreground process; background it with systemd / & / tmux as you prefer.

Fields

§interval: u64

Sync interval in seconds. Default 5.

§once: bool

Run a single sync cycle and exit (useful for cron-driven setups).

§all_sessions: bool

v0.14.2 (#162): supervisor mode — read the session registry + fork-exec one child wire daemon per initialized session, each with its own WIRE_HOME pinned. Closes the launchd-blind session-isolation gap honey-pine reported: with no cwd context, a single launchd-spawned daemon resolves the default WIRE_HOME and silently skips every other session. Operator-facing: install this mode via wire service install — the plist now uses --all-sessions so every session syncs at login without the operator running N tmux panes.

§session: Option<String>

v0.14.2 (#162): run the daemon loop pinned to a specific named session by setting WIRE_HOME for the process. The supervisor (--all-sessions) spawns children with this flag; operators can also use it directly for a one-session foreground daemon outside the supervisor.

§json: bool

§

Session(SessionCommand)

Manage isolated wire sessions on this machine (v0.5.16).

Each session = its own DID + handle + relay slot + daemon + inbox/ outbox tree. Use when multiple agents (e.g. Claude Code sessions in different projects) run on the same machine — without sessions they all share one identity and race the inbox cursor.

Names are derived from basename(cwd) and cached in a registry, so re-entering the same project reuses the same identity.

§

Identity

Manage this session’s identity display layer (character override). v0.7.0-alpha.3: agents can rename themselves — operator or Claude itself picks a custom nickname + emoji that overrides the auto-derived hash-based defaults.

Fields

§cmd: IdentityCommand

§

Mesh(MeshCommand)

Orchestration verbs for the sister-session mesh. wire mesh status is the live view of every paired sister (alias for wire session mesh-status); wire mesh broadcast fans one signed event to every pinned peer.

§

Group(GroupCommand)

Group chat (v0.13.3): create a named group, add VERIFIED peers, and send/tail messages across the whole member set. Membership is a signed roster (group-scoped tiers, separate from bilateral peer trust).

§

Enroll(EnrollCommand)

Mint operator / organization identities for the offline org-membership layer (RFC-001): wire enroll op / org-create / org-add-member.

§

Org(OrgCommand)

Trust an organization by its domain (RFC-001 §2 DNS-TXT floor): wire org bind <domain> / wire org list / wire org forget <org_did>.

§

Nostr(NostrCommand)

Speak Nostr (RFC-007): pair with + message a peer over a Nostr relay using this session’s secp transport key (wire enroll nostr). wire nostr pair <npub> --relay wss://… sends an encrypted pair-request; wire nostr fetch --relay wss://… pulls + decrypts events addressed to your npub.

§

Setup

Detect known MCP host config locations (Claude Desktop, Claude Code, Cursor, project-local) and either print or auto-merge the wire MCP server entry. Default prints; pass --apply to actually modify config files. Idempotent — re-running is safe.

Fields

§apply: bool

Actually write the changes (default = print only).

§statusline: bool

Install a Claude Code statusLine showing your wire persona (liveness dot + emoji + nickname in the persona’s accent color + cwd) instead of merging the MCP server. Writes a renderer script and merges a statusLine block into Claude Code’s settings.json (honors $CLAUDE_CONFIG_DIR). Combine with –apply to write.

§remove: bool

With –statusline: uninstall it (drop the statusLine key + remove the renderer script) instead of installing.

§

Whois

Show an agent’s profile. With no arg, prints local self. With a nick@domain arg, resolves via that domain’s .well-known/wire/agent endpoint and verifies the returned signed card before display.

Fields

§handle: Option<String>

Optional handle (nick@domain). Omit to show self.

§json: bool

§relay: Option<String>

Override the relay base URL used for resolution (default: https://<domain> from the handle).

§

Add

Federation backend of wire dial — prefer wire dial.

Zero-paste pair with a known handle: resolves nick@domain via that domain’s .well-known/wire/agent, then delivers a signed pair-intro to the peer’s slot via /v1/handle/intro. Peer’s daemon completes the bilateral pin on its next pull (sends back pair_drop_ack carrying their slot_token so we can wire send to them).

Fields

§handle: String

Peer handle (nick@domain), OR a bare sister-session name when --local-sister is set.

§relay: Option<String>

Override the relay base URL used for resolution.

§local_sister: bool

v0.6.6: pair with a sister session on this machine without touching federation. Looks up handle as a session name in wire session list, reads that session’s agent-card + endpoints from disk, pins directly, then delivers the pair_drop to the sister’s local-relay slot. No .well-known resolution; reserved nicks (wire, slancha, etc.) are addressable because they don’t need a federation claim.

§json: bool

§

Up

Come online in one command — wire up does what used to take five (init + bind-relay + claim your persona + background daemon + restart-on-login). Idempotent: re-run on an already-set-up box prints state without churn.

There is no name to choose: your handle IS your DID-derived persona (one-name rule). The optional argument is just which relay to use.

Examples: wire up # default public relay (wireup.net) wire up @wireup.net # explicit federation relay wire up http://127.0.0.1:8771 # a local / self-hosted relay

Fields

§relay: Option<String>

Relay to bind + claim your persona on: @wireup.net, wireup.net, or a full URL. Omit for the default public relay. No nick — your handle is your DID-derived persona.

§offline: bool

Mint your identity offline — keypair + DID-derived persona, no relay bound and nothing claimed. Bind later with wire up <relay> or wire bind-relay <relay>. For air-gapped keygen / bind-later.

§with_local: Option<String>

Also additively dual-bind a LOCAL relay slot for fast same-box sister-session routing. Defaults to probing http://127.0.0.1:8771; pass a URL to override. Local relays carry no handle directory, so nothing is claimed there.

§no_local: bool

Skip the opportunistic local dual-bind entirely.

§json: bool

§

Demo

See wire work in one command — an ephemeral two-agent round-trip.

Boots a throwaway local relay, mints two temporary identities, pairs them, and sends a signed message end-to-end — then tears it all down. No install of a relay, no second terminal, no copy-pasting a persona. The fastest way to watch two agents talk before setting wire up for real. Nothing it creates outlives the command.

Fields

§json: bool

Emit a JSON result summary instead of the narrated walkthrough.

§

Doctor

Diagnose wire setup health. Single command that surfaces every silent-fail class — daemon down or duplicated, relay unreachable, cursor stuck, pair rejections piling up, trust ↔ directory drift. Replaces today’s 30-minute manual debug.

Exit code non-zero if any FAIL findings.

Fields

§json: bool

Emit JSON.

§recent_rejections: usize

Show last N entries from pair-rejected.jsonl in the report.

§

Upgrade

Update + restart in one step (alias: wire update). ALWAYS checks crates.io for a newer published wire; if one exists it installs it (via cargo install slancha-wire when a Rust toolchain is on PATH, else by downloading + SHA-256-verifying the prebuilt release binary and replacing this one in place), then does the atomic daemon swap — kill every wire daemon, respawn from the (now-current) binary, write a fresh pidfile. No newer version → it skips the install and just restarts the daemon. --check reports what would happen (available update + processes that would be restarted) without doing it; --local skips the crates.io check and only restarts the daemon (offline, or running a local dev build).

Fields

§check: bool

Report current vs latest + drift without taking action.

§local: bool

Skip the crates.io update check; just restart the daemon from the current binary (offline / local dev build).

§restart_mcp: bool

Also kill wire mcp server subprocesses after the daemon swap so their MCP host (Claude Code / Claude.app / Copilot CLI) respawns them on the new binary. Without this, sister sessions keep running pre-upgrade MCP code until each one explicitly /mcp reconnects. Cross-session impact: kills every wire mcp found.

§refresh_stale_children: bool

v0.14.3 (closes the #198 follow-up): kill the daemons reported in wire supervisor’s stale_binary_sessions set — sister-session children alive on an old binary that the supervisor’s existing-pidfile check intentionally protected from respawn. Once each is killed, the --all-sessions supervisor respawns it on the new binary on its next 10s registry poll. Cross-session impact: only sessions flagged stale are touched; in-sync siblings are spared. No-op (silent) when no supervisor is running OR no stale daemons exist.

§json: bool

§

Nuke

Hard-reset this machine to a clean wire state: kill daemons, remove service units, de-register the wire MCP entry from host configs, and wipe all wire dirs. --purge also removes the binary + shell lines. Requires –force or a typed confirmation.

Fields

§force: bool

Skip the typed confirmation (for automation / test harness). --yes is an accepted alias.

§purge: bool

Also remove the wire binary + shell PATH/env lines.

§dry_run: bool

Print what would be removed and exit without changing anything.

§really_this_machine: bool

Confirm nuking a machine with a LIVE operator install (registry-bound sessions). The unit/process/MCP teardown is machine-global even under a temp WIRE_HOME, so a bound default registry refuses without this flag.

§json: bool

§

Service

Install / inspect / remove a launchd plist (macOS) or systemd user unit (linux) that runs wire daemon on login + restarts on crash. Replaces today’s “background it with tmux/&/systemd as you prefer” footgun.

Fields

§action: ServiceAction

§

Diag

Inspect or toggle the structured diagnostic trace ($WIRE_HOME/state/wire/diag.jsonl). Off by default. Enable per process via WIRE_DIAG=1, or per-machine via wire diag enable (writes the file knob a running daemon picks up automatically).

Fields

§action: DiagAction

§

Claim

Claim your persona on a relay’s handle directory. Anyone can then reach this agent by <persona>@<relay-domain> via the relay’s .well-known/wire/agent endpoint. FCFS; same-DID re-claims allowed.

ONE-NAME RULE (v0.13.1): the claimed handle is always your DID-derived persona. The nick arg is vestigial — if it differs it is ignored (like the typed name wire init / wire up already ignore), so your phonebook entry can never drift from your agent-card handle.

v0.13.1: hidden — wire up claims your persona for you. Kept callable (idempotent re-claim) but not a user verb; there is no nick to choose.

Fields

§nick: String

Vestigial: ignored if it differs from your DID-derived persona.

§relay: Option<String>

Relay to claim the nick on. Default = relay our slot is on.

§public_url: Option<String>

Public URL the relay should advertise to resolvers (default = relay).

§hidden: bool

v0.5.19 (#9.1): opt out of the relay’s bulk /v1/handles directory listing. The handle stays claimed (FCFS still applies) and direct .well-known/wire/agent?handle=X lookup still resolves, so peers you share the handle with out-of-band can still pair. Bulk scrapers / phonebook crawlers will not see the nick. Use this for handles meant for known-peer pairing only — see issue #9.

§json: bool

§

Unclaim

Release your claimed persona from a relay’s handle directory (#247.1). Frees the nick so it no longer resolves via .well-known/wire/agent and can be re-claimed (yours is FCFS-permanent otherwise). Owner-gated by your slot token — only the holder can unclaim. Defaults to your own persona on the relay your slot is on.

Fields

§relay: Option<String>

Relay to unclaim on. Default = relay our slot is on.

§json: bool

§

Profile

Edit profile fields (display_name, emoji, motto, vibe, pronouns, avatar_url, handle, now). Re-signs the agent-card atomically.

Examples: wire profile set motto “compiles or dies trying” wire profile set emoji “🦀” wire profile set vibe ‘[“rust”,“late-night”,“no-async-please”]’ wire profile set handle “coffee-ghost@anthropic.dev” wire profile get

Fields

§action: ProfileAction

§

Invite

Mint a one-paste invite URL. Anyone with this URL can pair to us in a single step (no SAS digits, no code typing). Auto-inits + auto-allocates a relay slot on first use. Default TTL 24h, single-use.

Fields

§relay: String

Override the relay URL for first-time auto-allocation.

§ttl: u64

Invite lifetime in seconds (default 86400 = 24h).

§uses: u32

Number of distinct peers that can accept this invite before it’s consumed (default 1).

§share: bool

Register the invite at the relay’s short-URL endpoint and print a curl ... | sh one-liner the peer can run on a fresh machine. Installs wire if missing, then accepts the invite, then pairs.

§json: bool

Emit JSON.

§

Accept

Accept a pending-inbound pair request by character nickname or card handle.

v0.9.4: the URL-vs-name smart-dispatch from v0.9 is gone. To accept a federation invite URL use wire accept-invite <URL> (split out as an explicit verb to eliminate the input-shape ambiguity). wire accept <URL> still works for back-compat but emits a deprecation banner pointing at accept-invite.

Fields

§target: String

Pending peer name (character nickname or card handle).

§json: bool

Emit JSON.

§

AcceptInvite

Accept a federation invite URL minted by wire invite. Pins issuer, sends signed card to issuer’s slot. Auto-inits + auto-allocates as needed.

Split out from wire accept to eliminate the URL-vs-name smart-dispatch ambiguity (peer handles can legitimately collide with URL-shaped strings; the explicit verb removes the inference).

Fields

§url: String

The full invite URL (starts with wire://pair?v=1&inv=...).

§json: bool

Emit JSON.

§

Reject

Refuse a pending-inbound pair request without pairing.

Fields

§peer: String

Peer name (character nickname or handle) from wire pending.

§json: bool

Emit JSON.

§

BlockPeer

Block a peer DID so it can never be org-auto-paired or surface an org-notify prompt (RFC-001 §T16 rogue-admin containment).

Pass a session DID (did:wire:<handle>-<8hex>) to mute one session, or an operator DID (did:wire:op:<handle>-<32hex>) to mute every session that operator runs — the lever for cutting off a single adversary a compromised org admin vouched into the roster, without leaving the org. Local-only; idempotent; survives roster epoch bumps.

A block gates the org-easing path, NOT a deliberate bilateral SAS pair: if you knowingly wire dial + SAS-verify a blocked peer, that explicit gesture wins. Unblock with wire unblock-peer <did>.

Fields

§did: String

The DID to block (session did:wire:… or operator did:wire:op:…).

§note: Option<String>

Optional note recorded alongside the block (why / who).

§json: bool

Emit JSON.

§

UnblockPeer

Remove a DID from the local block-list (undo wire block-peer).

Fields

§did: String

The DID to unblock.

§json: bool

Emit JSON.

§

Blocked

List the DIDs on the local block-list (RFC-001 §T16).

Fields

§json: bool

Emit JSON.

§

Notify

Watch the inbox for new verified events and fire an OS notification per event. Long-running; background under systemd / & / tmux. Cursor is persisted to $WIRE_HOME/state/wire/notify.cursor so restarts don’t re-emit history.

Fields

§interval: u64

Poll interval in seconds.

§peer: Option<String>

Only notify for events from this peer (handle, no did: prefix).

§once: bool

Run a single sweep and exit (useful for cron / tests).

§json: bool

Suppress the OS notification call; print one JSON line per event to stdout instead (for piping into other tooling or smoke-testing without a desktop session).

§

Quiet

Silence (or re-enable) all wire desktop toasts. Persistent across daemon restarts via a file at <config_dir>/quiet. wire quiet on = silence; wire quiet off = restore; wire quiet status = report. Same effect as exporting WIRE_NO_TOASTS=1 (the env-var override is for launchd contexts where the daemon’s env isn’t writable from the operator’s shell).