CLI reference

Every command below is verified against the release binary — nexa 0.1.3 — and this page is generated from that verification rather than written by hand. Where a command's output is shown, it was captured by running it. Where it is described in prose instead, the output has not been captured and none is invented.

Start with fourteen commands

The everyday commands below are the whole of ordinary use. Everything under advanced commands is real and supported, but you can do a full day's work without any of it — so read the first section, and treat the rest as something to look up when you need it.

Options accepted by every command

Option	Value	Meaning
`--format`	FORMAT	Output format for commands that support structured output. `text` is human-readable prose; `json` is stable, structured JSON on stdout. Not every command has been converted yet -- an unconverted command still prints prose regardless of this flag rather than silently emitting nothing. Default: `text`.
`--help`/`-h`	—	Print help.
`--version`/`-V`	—	Print version.

--format json is not universal yet

Not every command has been converted to structured output. Asking an unconverted command for JSON returns prose — not an error, and not empty output. A script that assumes the flag works everywhere will parse a human sentence as JSON.

Everyday commands

These fourteen cover installation through daily work. Each entry gives its purpose, syntax, arguments and options, an example, what to expect, and where to go next.

Command	Arguments	Purpose
`nexa root`	`[PATH]`	Make this directory your Development Root.
`nexa login`	`[PROFILE]`	Sign in to Rinko Hub, in a browser.
`nexa get`	`<TARGET> [CONTEXT]`	Bring a repository into your Development Root.
`nexa record`	`[FILES...]`	Record the working tree as a version.
`nexa sync`	`[REPOSITORY]`	Reconcile with another repository, locally or over the network.
`nexa contexts`	`—`	List the working contexts in your Development Root.
`nexa drop`	`<NAME>`	Remove a working context.
`nexa init`	`[PATH]`	Make a folder a project in your Development Root.
`nexa status`	`[PROJECT]`	Show a workspace's current state.
`nexa history`	`[PROJECT]`	Show a workspace's history.
`nexa publish`	`[NAME]`	Create a Rinko Hub repository for the work in this directory and publish the recorded version to it.
`nexa link`	`<REPOSITORY> [PATH]`	Associate the work in this directory with a hosted repository.
`nexa repos`	`—`	List the repositories your account can reach.
`nexa logout`	`[PROFILE]`	Sign out of Rinko Hub. Local work is untouched.
`nexa install`	`—`	Install this Nexa binary so `nexa` works from anywhere.
`nexa update`	`—`	Install a newer Nexa, or report that one exists.

nexa root

Make this directory your Development Root.

Deliberately not `init`: that has always meant "create a repository here", and quietly changing what it does would be a trap for anyone with the habit -- or a script -- that predates this vocabulary. The root's `.nexa/` holds control state for many independent projects; it is not itself a repository, and a project beneath it is managed only once `nexa init` (or `nexa get`) has chosen it. Idempotent: running it again on an existing root succeeds and changes nothing.

Syntax

$ nexa root [OPTIONS] [PATH]

Argument	Required	Meaning
`PATH`	No	The directory to use. Defaults to the current one. Default: `.`.

Option	Value	Meaning
`--profile`	PROFILE	The Rinko Hub profile this root works under.

Command

$ nexa root .

Expected output

Development Root: /Users/you/Development

Confirmed present in the release binary and recorded in VERIFIED-OUTPUT.md.

Syntax

$ nexa login [OPTIONS] [PROFILE]

Argument	Required	Meaning
`PROFILE`	No	Local profile name. Default: `default`.

Option	Value	Meaning
`--origin`	ORIGIN	Rinko Hub origin. Intended for self-hosted/staging control planes. Default: `https://rinkohub.com`.
`--no-browser`	—	Print the sign-in link instead of opening a browser. For a machine with no browser to open -- an SSH session, a container, a CI job -- where the link is completed from another device.

Command

$ nexa login

Expected behaviour. Requires a live control plane and an interactive browser flow; not exercised.

nexa get

Bring a repository into your Development Root.

Give it a repository, and optionally `branch/workspace`. What it cannot work out from the repository itself, it asks for rather than guesses.

Syntax

$ nexa get [OPTIONS] <TARGET> [CONTEXT]

Argument	Required	Meaning
`TARGET`	Yes	A local repository path, or `owner/repository` on Rinko Hub.
`CONTEXT`	No	The branch and workspace to work in, as `branch/workspace`. Omit it to take the repository's default. Naming only a branch takes that branch's one workspace, or the branch itself if it has none.

Option	Value	Meaning
`--as`	DIRECTORY	The directory to create. Defaults to the repository's own name.
`--project`/`-p`	FOLDER	The folder to bring it into, relative to your Development Root. Works from anywhere in the root without changing directory, and may be nested (`-p group/api`). A folder that does not exist is created; an existing empty folder is used as it is; a folder with contents is refused, so nothing is ever written over your files.
`--profile`	PROFILE	Which local profile's authorization to present, for a hosted target.
`--origin`	ORIGIN	The Rinko Hub origin, for a hosted target. Needed because a session is only ever presented back to the origin that issued it.

Command

$ nexa get ./demo --as demo-context

Expected output

Ready: demo-context
  repository: ./demo
  branch:     main
  workspace:  main
  path:       /Users/you/Development/demo-context

Local-path target, run in a Development Root. The hosted `owner/repo` form needs a control plane.

Command

$ nexa get acme/website

Expected behaviour. Hosted target; requires a live control plane.

nexa record

Record the working tree as a version.

Syntax

$ nexa record [OPTIONS] --message <MESSAGE> [FILES]...

Argument	Required	Meaning
`FILES...`	No	Files to include. Empty records the whole working tree.

Option	Value	Meaning
`--project`	NAME	The project to act on, by its folder in your Development Root. Short form `-p`, as in `nexa record -p my-project -m "…"`. Defaults to the project you are standing in; at the root with nothing named, you are asked which one. `nexa <project> <command>` is an accepted shorthand, except for a project that shares a command name.
`--message`/`-m`	MESSAGE	What changed, and why.
`--workspace`	WORKSPACE	The workspace to record into. Defaults to the current context.
`--parent`	PARENT	Base the version on a specific parent rather than the selection.
`--author`	AUTHOR	Who is recording it.
`--candidate`	—	Record it as a candidate without selecting it.

Command

$ nexa record -m "Add a readme"

Expected output

Created version 135369ca4b6b
  workspace: main
  files:     1

Selected on branch main.

nexa sync

Reconcile with another repository, locally or over the network.

Inside a hosted working context the no-argument form synchronizes every later recorded change with Rinko Hub, in both directions, and prints `Synchronized with Rinko Hub.` It synchronizes with every hosted replica; Rinko Hub converges the replicas itself, so no manual re-sync is needed after an outage. A temporarily unavailable replica does not fail the command: it succeeds and prints `Repository redundancy is temporarily degraded; Rinko Hub will retry.` on stderr. First publication does not need it -- `nexa publish` performs the initial synchronization.

Syntax

$ nexa sync [OPTIONS] [REPOSITORY]

Argument	Required	Meaning
`REPOSITORY`	No	Path to a local repository, or an address when `--device` is given. Omit it inside a working context obtained from Rinko Hub: the context already knows which repository it is, where it is hosted, and which profile to present, so there is nothing for a developer to name.

Option	Value	Meaning
`--project`	NAME	The project to act on, by its folder in your Development Root. Short form `-p`, as in `nexa record -p my-project -m "…"`. Defaults to the project you are standing in; at the root with nothing named, you are asked which one. `nexa <project> <command>` is an accepted shorthand, except for a project that shares a command name.
`--device`	DEVICE_ID	The peer's device identifier, as 128 hex characters. Supplying it selects the network path: `repository` is then an address, and the connection is authenticated against this identity. It is required rather than optional because the handshake pattern needs the responder's static key in advance -- which is also what prevents a man in the middle from substituting its own. There is deliberately no "connect and trust whatever answers" mode.
`--objects-only`	—	Exchange objects without reconciling workspace references. Holding an object never implies selecting it, so the two are separable.

Command

$ nexa sync

Expected output

Synchronized with Rinko Hub.

The success line, inside a hosted working context. No place name and no per-replica detail: set NEXA_DIAGNOSTICS=1 to print per-replica lines, and `nexa repo route` to see routing. Recorded in VERIFIED-OUTPUT.md.

nexa contexts

List the working contexts in your Development Root.

Syntax

$ nexa contexts [OPTIONS]

Command

$ nexa contexts

Expected output

LOCAL	REPOSITORY	BRANCH	WORKSPACE
demo-context	local:/Users/you/Development/demo	main	main

Tab-separated. Must be run inside a Development Root.

nexa drop

Remove a working context.

Local only: the hosted repository, its history and every other context of the same repository are untouched.

Syntax

$ nexa drop [OPTIONS] <NAME>

Argument	Required	Meaning
`NAME`	Yes	The working context's directory name.

Option	Value	Meaning
`--force`	—	Discard unrecorded changes in that context.

Command

$ nexa drop demo-context

Expected output

Removed demo-context from this Development Root.
The repository, its history and its workspaces were not touched.

nexa init

Make a folder a project in your Development Root.

Inside a Development Root, chooses this one project directory to manage: the root records it as a working context, the project gets no `.nexa/` of its own, and sibling directories stay unmanaged until they are initialised too. Outside a root it creates a standalone repository with its own `.nexa/`. Either way nothing is recorded yet; `nexa record` is the next step, and `nexa publish` after that.

Syntax

$ nexa init [OPTIONS] [PATH]

Argument	Required	Meaning
`PATH`	No	Where to create the repository, relative to the current directory. At the root, `nexa init my-project` is equivalent to `nexa init -p my-project`. Default: `.`.

Option	Value	Meaning
`--project`/`-p`	FOLDER	The folder to make a project, relative to your Development Root. Works from anywhere in the root without changing directory: `nexa init -p my-project` adopts `<root>/my-project` as it is, creating it if it does not exist, and `nexa init -p group/nested` adopts exactly that folder. The folder's path is how every later command names it.
`--workspace`	WORKSPACE	The name of the initial workspace. Default: `main`.
`--author`	AUTHOR	Who is creating the repository.

Command

$ nexa init my-project

Expected output

Initialised Nexa repository `my-project` in Development Root ~/Development
Created workspace `main`

Run at the Development Root: the project directory is created if it does not exist, and gets no `.nexa/` of its own. Recorded in VERIFIED-OUTPUT.md.

Command

$ nexa init

Expected output

Initialised empty Nexa repository in .
Created workspace `main`

The "Nexaji" spelling -- the company name where the product was meant -- has been corrected in the binary, which now prints "Initialised empty Nexa repository in {}". Recorded in VERIFIED-OUTPUT.md.

nexa status

Show a workspace's current state.

Syntax

$ nexa status [OPTIONS] [PROJECT]

Argument	Required	Meaning
`PROJECT`	No	The project to inspect, by its name in your Development Root. Defaults to the project you are standing in. `--project` means the same thing and is the spelling every other command takes; `status` and `history` accept the bare name as well because neither has a positional of its own.

Option	Value	Meaning
`--project`	NAME	The project to act on, by its folder in your Development Root. Short form `-p`, as in `nexa record -p my-project -m "…"`. Defaults to the project you are standing in; at the root with nothing named, you are asked which one. `nexa <project> <command>` is an accepted shorthand, except for a project that shares a command name.
`--workspace`	WORKSPACE	The branch to inspect. Defaults to the current branch.
`--json`	—	Emit machine-readable JSON instead of human-readable text.
`--all`	—	Show unchanged files too.

Command

$ nexa status

Expected output

On branch main
Version   135369ca4b6b  device:78e3-343d-655a-27c5

Working tree clean.

Command

$ nexa --format json status

Expected output

{"branch":"main","version":"135369ca4b6b…","merging":null,"clean":true,"changes":[],"sealed":[],"tracked":1}

One of the commands already converted to structured output. The JSON carries the full 64-byte version id; it is elided here.

nexa history

Show a workspace's history.

Syntax

$ nexa history [OPTIONS] [PROJECT]

Argument	Required	Meaning
`PROJECT`	No	The project to inspect, by its name in your Development Root. Defaults to the project you are standing in. `--project` means the same thing and is the spelling every other command takes.

Option	Value	Meaning
`--project`	NAME	The project to act on, by its folder in your Development Root. Short form `-p`, as in `nexa record -p my-project -m "…"`. Defaults to the project you are standing in; at the root with nothing named, you are asked which one. `nexa <project> <command>` is an accepted shorthand, except for a project that shares a command name.
`--workspace`	WORKSPACE	The workspace to inspect. Defaults to the current working context.
`--limit`	LIMIT	Maximum number of versions to show. Default: `20`.

Command

$ nexa history

Expected output

135369ca4b6b  Add a readme
  author:  device:78e3-343d-655a-27c5
  status:  selected

nexa publish

Create a Rinko Hub repository for the work in this directory and publish the recorded version to it. Requires an authorized Rinko Hub account.

First publication is this one command. It creates the hosted repository, waits for Rinko Hub to prepare it (up to about two minutes), and then performs the initial synchronization, so the code is live when it prints `Published to Rinko Hub.` -- no follow-up `nexa sync` is needed. It publishes recorded state: with nothing recorded it refuses with `No recorded version to publish. Run nexa record -m "Initial version" first.`, and unrecorded working-tree changes are never recorded on your behalf -- if present it warns `Warning: unrecorded working-tree changes were not included.` Safe to re-run: a second `nexa publish` in the same directory never creates a second hosted repository; it synchronizes the existing one. If the readiness wait runs out it stops with `Rinko Hub is still preparing this repository. Run nexa publish again in a moment; nothing needs to be recreated.`

Syntax

$ nexa publish [OPTIONS] [NAME]

Argument	Required	Meaning
`NAME`	No	The repository's name on Rinko Hub. Defaults to this directory's name.

Option	Value	Meaning
`--project`	NAME	The project to act on, by its folder in your Development Root. Short form `-p`, as in `nexa record -p my-project -m "…"`. Defaults to the project you are standing in; at the root with nothing named, you are asked which one. `nexa <project> <command>` is an accepted shorthand, except for a project that shares a command name.
`--org`	ORG	Create it under an organization rather than your own account.
`--public`	—	Make it publicly visible. Private by default.
`--profile`	PROFILE	Which local profile's authorization to present. Default: `default`.
`--origin`	ORIGIN	The Rinko Hub origin. For self-hosted or development control planes. Default: `https://rinkohub.com`.

Command

$ nexa publish

Expected output

Published to Rinko Hub.

The final line of the output, once the hosted repository is ready and the recorded version has been synchronized. Recorded in VERIFIED-OUTPUT.md.

nexa link

Associate the work in this directory with a hosted repository. Requires an authorized Rinko Hub account.

Syntax

$ nexa link [OPTIONS] <REPOSITORY> [PATH]

Argument	Required	Meaning
`REPOSITORY`	Yes	The hosted repository to associate this work with.
`PATH`	No	The local repository. Defaults to the current directory. Default: `.`.

Option	Value	Meaning
`--profile`	PROFILE	Which local profile's authorization to present. Default: `default`.
`--origin`	ORIGIN	The Rinko Hub origin. For self-hosted or development control planes. Default: `https://rinkohub.com`.

Command

$ nexa link acme/website

Expected behaviour. Requires a live control plane.

nexa repos

List the repositories your account can reach. Requires an authorized Rinko Hub account.

Syntax

$ nexa repos [OPTIONS]

Option	Value	Meaning
`--profile`	PROFILE	Which local profile's authorization to present. Default: `default`.
`--origin`	ORIGIN	The Rinko Hub origin. For self-hosted or development control planes. Default: `https://rinkohub.com`.

Command

$ nexa repos

Expected behaviour. Requires an authenticated profile and a live control plane. With no profile it fails with "this machine is not signed in to Rinko Hub with that profile; run `nexa login`".

nexa logout

Sign out of Rinko Hub. Local work is untouched. Requires an authorized Rinko Hub account.

Syntax

$ nexa logout [OPTIONS] [PROFILE]

Argument	Required	Meaning
`PROFILE`	No	Local profile name. Default: `default`.

Option	Value	Meaning
`--origin`	ORIGIN	Rinko Hub origin. Intended for self-hosted/staging control planes. Default: `https://rinkohub.com`.

Command

$ nexa logout

Expected behaviour. Needs a signed-in profile to be meaningful. With none, it fails with "this machine is not signed in to Rinko Hub with that profile; run `nexa login`".

nexa install

Install this Nexa binary so `nexa` works from anywhere.

Run it once, from the directory you extracted the download into. It places this binary under your home directory and links it onto your `PATH`; afterwards `nexa update` maintains it.

Syntax

$ nexa install [OPTIONS]

nexa update

Install a newer Nexa, or report that one exists.

Distinct from `version`, which manages a repository's versions rather than this binary's. The name collision is the reason the two are documented side by side: `nexa version` never touches the installed binary, and `nexa update` never touches a repository.

Syntax

$ nexa update [OPTIONS]

Option	Value	Meaning
`--check`	—	Report whether a newer version is available without installing it.
`--version`	VERSION	Install a specific published version rather than the newest. Positional context distinguishes this from the global `-V`/`--version`, which prints the running binary's own version and exits.
`--rollback`	—	Return to the previously installed version.
`--list`	—	List the versions installed on this machine.

Commands a reader may look for and not find

Two different things are grouped here, and the difference matters. nexa clone was a real command that was removed outright, so it needs redirecting rather than explaining. The Git verbs never existed, and the honest reason is that the model differs — not that a feature is missing.

Typed	Status	What to do instead
`nexa clone`	Removed	Removed outright, not renamed. Use `nexa get <owner>/<repo>` to bring a repository into your Development Root. (`nexa repo clone` still exists as a low-level hosted operation addressed by repository id.)
`nexa add`	Never existed	There is no staging area and no index. `nexa record` captures the whole working tree; name paths to record a subset.
`nexa commit`	Never existed	The operation is `nexa record`, and the noun is a version, never a commit.
`nexa rebase`	Never existed	History is append-only and versions are immutable, so history cannot be rewritten. Use `nexa merge`.
`nexa stash`	Never existed	Record a candidate instead: `nexa record --candidate` keeps work without selecting it, and nothing is superseded until you select.
`nexa reset`	Never existed	Use `nexa version select` to change which candidate is selected, or `nexa restore` to restore files from a version. Neither destroys anything.
`nexa blame`	Never existed	Not implemented. `nexa history` shows a workspace’s versions and their authors.
`nexa clean`	Never existed	Not implemented. `nexa status` reports untracked working-tree entries; remove them with ordinary filesystem tools.
`nexa grant`	Never existed	Access is managed on Rinko Hub, and path-level protection locally via `nexa label` and `nexa policy`.

Each of these produces an unrecognized-subcommand error rather than a hint. For the errors themselves and what to do about them, see Troubleshooting.

Advanced commands

Real, supported, and deliberately not part of the onboarding path. Reach for these when you have a specific reason to: direct peer-to-peer synchronisation, per-path encryption, merge resolution, or scripting against hosted metadata. Subcommands are listed beneath their parent.

One exception to "not part of onboarding": label create, label grants, policy validate and policy explain belong before a project's first record. Protect private files before hosting uses them in order; labels are repository-specific, so under a Development Root each one names its project.

Local repository work

Command	Syntax	Purpose
`nexa workspace`	`nexa workspace [OPTIONS] <COMMAND>`	Manage workspaces.
`nexa workspace create`	`nexa workspace create [OPTIONS] <NAME>`	Create a new workspace in a branch.
`nexa workspace derive`	`nexa workspace derive [OPTIONS] --from <FROM> <NAME>`	Derive an independent sibling from a workspace's selected state.
`nexa workspace visibility`	`nexa workspace visibility [OPTIONS] <NAME> [VISIBILITY]`	Show or change who a workspace is visible to.
`nexa workspace list`	`nexa workspace list [OPTIONS]`	List the repository's workspaces.
`nexa workspace archive`	`nexa workspace archive [OPTIONS] <NAME>`	Retire a workspace.
`nexa version`	`nexa version [OPTIONS] <COMMAND>`	Manage versions.
`nexa version create`	`nexa version create [OPTIONS] --message <MESSAGE> [FILES]...`	Record the working tree as a new candidate version.
`nexa version list`	`nexa version list [OPTIONS]`	List a workspace's candidate versions.
`nexa version select`	`nexa version select [OPTIONS] <VERSION>`	Select a candidate as the workspace's current version.
`nexa branch`	`nexa branch [OPTIONS] <COMMAND>`	Manage top-level branches.
`nexa branch list`	`nexa branch list [OPTIONS]`	List branches, with their selected version and candidate count.
`nexa branch create`	`nexa branch create [OPTIONS] <NAME>`	Create a branch.
`nexa branch switch`	`nexa branch switch [OPTIONS] <NAME>`	Switch to a branch, updating the working tree.
`nexa branch delete`	`nexa branch delete [OPTIONS] <NAME>`	Delete a branch's reference.
`nexa restore`	`nexa restore [OPTIONS] <PATHS>...`	Restore files from a version.
`nexa compare`	`nexa compare [OPTIONS] <FROM> <TO>`	Compare two versions.
`nexa merge`	`nexa merge [OPTIONS] [BRANCH]`	Merge another branch's version into the current one.
`nexa verify`	`nexa verify [OPTIONS]`	Verify the integrity of every stored object.
`nexa show`	`nexa show [OPTIONS] <ID>`	Read an object by identifier.

Peer-to-peer synchronisation

Command	Syntax	Purpose
`nexa remote`	`nexa remote [OPTIONS] <COMMAND>`	Manage remote peers.
`nexa remote list`	`nexa remote list [OPTIONS]`	List configured remotes.
`nexa remote add`	`nexa remote add [OPTIONS] --identity <IDENTITY> <NAME> <ADDRESS>`	Add a remote.
`nexa remote add-hosted`	`nexa remote add-hosted [OPTIONS] <NAME> <REPOSITORY_ID>`	Add a Rinko Hub repository as a remote. Hosted.
`nexa remote remove`	`nexa remote remove [OPTIONS] <NAME>`	Remove a remote.
`nexa remote show`	`nexa remote show [OPTIONS] <NAME>`	Show a remote's address and identity.
`nexa fetch`	`nexa fetch [OPTIONS] <REMOTE>`	Obtain a remote's objects and reference state.
`nexa push`	`nexa push [OPTIONS] <REMOTE> [BRANCH]`	Make a branch's state available to a remote.
`nexa pull`	`nexa pull [OPTIONS] <REMOTE> [BRANCH]`	Reconcile with a remote and advance a branch when it is safe.
`nexa serve`	`nexa serve [OPTIONS]`	Offer this repository to network peers.

Privacy and device identity

Command	Syntax	Purpose
`nexa label`	`nexa label [OPTIONS] <COMMAND>`	Manage labels: which paths are protected.
`nexa label list`	`nexa label list [OPTIONS]`	List configured labels and whether this device can read them.
`nexa label grants`	`nexa label grants [OPTIONS] <NAME>`	List which devices hold a grant for a label, and for which epoch.
`nexa label grant`	`nexa label grant [OPTIONS] --device <IDENTITY> <NAME>`	Grant a label's key to another device.
`nexa label rotate`	`nexa label rotate [OPTIONS] <NAME>`	Rotate a label to a new epoch, keeping only the devices named.
`nexa label create`	`nexa label create [OPTIONS] <KEY> [PATHS]...`	Create a label protecting the given paths.
`nexa label describe`	`nexa label describe [OPTIONS] <KEY>`	Rename a label, or restate what it is for.
`nexa label archive`	`nexa label archive [OPTIONS] <KEY>`	Retire a label so no policy may reference it from now on.
`nexa label inspect`	`nexa label inspect [OPTIONS] <NAME>`	Show a label's identifier, paths, and key availability.
`nexa policy`	`nexa policy [OPTIONS] <COMMAND>`	Inspect the repository's file policy.
`nexa policy show`	`nexa policy show [OPTIONS]`	Show the policy in force, and which of its labels this device can read.
`nexa policy validate`	`nexa policy validate [OPTIONS]`	Check the authoring file, and whether this project’s rules match files.
`nexa policy sync`	`nexa policy sync [OPTIONS] <WORKSPACE>`	Which labels may not reach a workspace, and where each rule came from.
`nexa policy upgrade`	`nexa policy upgrade [OPTIONS]`	Rewrite a version 0 authoring file in the version 1 grammar.
`nexa policy check`	`nexa policy check [OPTIONS] [PATH]`	Check a policy document for errors.
`nexa policy explain`	`nexa policy explain [OPTIONS] <PATH>`	Explain whether a path is protected, and whether this device can read it.
`nexa policy migrate`	`nexa policy migrate [OPTIONS]`	Move a project-local `.nexapolicy` into the Development Root's file.
`nexa device`	`nexa device [OPTIONS] <COMMAND>`	Manage this repository's device identity, including key protection at rest.
`nexa device status`	`nexa device status [OPTIONS]`	Show this repository's device identity and key-protection state.
`nexa device identity`	`nexa device identity [OPTIONS]`	Print this device's full public identity, for giving to another device.
`nexa device protect`	`nexa device protect [OPTIONS]`	Protect this repository's device private key at rest with a passphrase, migrating an existing unprotected key in place if one exists.
`nexa profile`	`nexa profile [OPTIONS] <COMMAND>`	Inspect the Rinko Hub sign-in profiles on this machine.
`nexa profile list`	`nexa profile list [OPTIONS]`	List local public profile metadata.

Hosted operations

Command	Syntax	Purpose
`nexa repo`	`nexa repo [OPTIONS] <COMMAND>`	Manage repositories hosted by Rinko Hub. Hosted.
`nexa repo list`	`nexa repo list [OPTIONS]`	List repositories your signed-in profile can reach. Hosted.
`nexa repo create`	`nexa repo create [OPTIONS] <SLUG>`	Create and provision a hosted repository. Hosted.
`nexa repo inspect`	`nexa repo inspect [OPTIONS] <REPOSITORY_ID>`	Inspect hosted repository metadata and provisioning state. Hosted.
`nexa repo route`	`nexa repo route [OPTIONS] <REPOSITORY_ID>`	Obtain short-lived native routes and a device-bound grant. Hosted.
`nexa repo clone`	`nexa repo clone [OPTIONS] <REPOSITORY_ID> <PATH>`	Copy a hosted repository into a standalone local repository. Advanced: to work on a repository in your Development Root, use `nexa get <owner>/<repository>`. Hosted.
`nexa repo sync`	`nexa repo sync [OPTIONS] <REPOSITORY_ID> <PATH>`	Synchronize a repository copied with `nexa repo clone`. Hosted.
`nexa repo attach`	`nexa repo attach [OPTIONS] <REPOSITORY_ID> [PATH]`	Associate an existing local repository with a hosted one. Advanced: `nexa link` is the everyday form. Hosted.
`nexa hub`	`nexa hub [OPTIONS] <COMMAND>`	Rinko Hub control centre: status, scopes, favourites, recent. Hosted.
`nexa hub home`	`nexa hub home [OPTIONS]`	Print the Control Centre URL. Hosted.
`nexa hub status`	`nexa hub status [OPTIONS]`	Summarise scope, repositories, favourites, recent and anything needing attention. Hosted.
`nexa hub repos`	`nexa hub repos [OPTIONS]`	List repositories accessible to this profile. Hosted.
`nexa hub orgs`	`nexa hub orgs [OPTIONS]`	List organizations this profile belongs to. Hosted.
`nexa hub favourites`	`nexa hub favourites [OPTIONS]`	List this profile's favourite (bookmarked) repositories. Hosted.
`nexa hub recent`	`nexa hub recent [OPTIONS]`	List repositories viewed most recently. Hosted.
`nexa hub scope`	`nexa hub scope [OPTIONS] [COMMAND]`	Show, list, or select the scope hosted commands operate in. Hosted.
`nexa hub scope list`	`nexa hub scope list [OPTIONS]`	List the scopes this profile can operate in.
`nexa hub scope use`	`nexa hub scope use [OPTIONS] <SCOPE>`	Select the scope subsequent hosted commands default to.
`nexa hub open`	`nexa hub open [OPTIONS] <TARGET>`	Print the URL of a hosted repository. Hosted.
`nexa task`	`nexa task [OPTIONS] <COMMAND>`	Associate local Nexa work with a Rinko Hub task. Hosted.
`nexa task start`	`nexa task start [OPTIONS] <REFERENCE>`	Begin work on a Rinko Hub task in a Nexa workspace. Hosted.
`nexa task show`	`nexa task show [OPTIONS] <REFERENCE>`	Show which Nexa workspaces are linked to a task. Hosted.

Command	Syntax	Purpose
`nexa where`	`nexa where [OPTIONS]`	Show where you are: Development Root, project, branch and workspace.
`nexa goto`	`nexa goto [OPTIONS] <ALIAS>`	Make a project your current one and print its path.
`nexa list`	`nexa list [OPTIONS]`	List the projects at the root, or the files in the current directory.
`nexa read`	`nexa read [OPTIONS] <PATH>`	Print a file from the current project, if you can read it.
`nexa find`	`nexa find [OPTIONS] <PATTERN>`	Find files in the current project by name.
`nexa disconnect`	`nexa disconnect [OPTIONS]`	Stop using this directory as a Development Root.

Synchronisation, in one place

Three different surfaces reconcile work, and choosing the wrong one is the most common orientation mistake:

nexa sync with no argument — inside a working context obtained from Rinko Hub. The context already knows which repository it is and where it is hosted, so no remote is ever named. This is the everyday command.
nexa sync with a repository — reconciles with a local path, or with a network peer when --device supplies that peer's identity. The identity is required rather than optional: the handshake needs the responder's static key in advance, which is what prevents anything substituting itself in the middle.
nexa fetch, push and pull — vocabulary over the same engine, for named remotes. Not part of hosted work.

Read access and syncing

An account with read access to a repository can sync and fetch — the exchange succeeds and reports that nothing was contributed. Contributing work is what requires write access. Sync is not refused for a reader.

Migration from older spellings

The command set was redesigned. The spellings below are hidden compatibility shims kept so that scripts predating the redesign keep working. They are absent from nexa --help, they are not the documentation's vocabulary, and they appear on this page only so that a reader who inherits an old script can translate it.

Do not learn these

If you are writing something new, use the replacement in the right-hand column. Each shim is named here once and nowhere else in the documentation.

Deprecated	Use instead	Note
`nexa connect`	`nexa root`	Deprecated: use `nexa root`.
`nexa mount`	`nexa get`	The shape this replaced: `--branch`, `--workspace` and `--as` were all required flags. `nexa get` takes the repository and an optional `branch/workspace` positional instead, and `--as` is optional.
`nexa mounts`	`nexa contexts`	Deprecated: use `nexa contexts`.
`nexa unmount`	`nexa drop`	Deprecated: use `nexa drop`.
`nexa attach`	`nexa login`	Deprecated: use `nexa login`.
`nexa detach`	`nexa logout`	Deprecated: use `nexa logout`.

One older spelling is not a shim and is not deprecated: nexa repo attach still exists, and is the only form that addresses a hosted repository by its raw identifier. For everyday use it is superseded by nexa link, which takes owner/repo instead.

Options accepted by every command

Everyday commands

nexa root

nexa login

nexa get

nexa record

nexa sync

nexa contexts

nexa drop

nexa init

nexa status

nexa history

nexa publish

nexa link

nexa repos

nexa logout

nexa install

nexa update

Commands a reader may look for and not find

Advanced commands

Local repository work

Peer-to-peer synchronisation

Privacy and device identity

Hosted operations

Navigation and inspection

Synchronisation, in one place

Migration from older spellings