Enum Command 

pub enum Command {
    Status,
    Entity(Args),
    Relations(Args),
    Search(Args),
    List(Args),
    Context(Args),
    Overview(Args),
    Type(Args),
    Health(Args),
    Export(Args),
    Init(InitArgs),
    Quickstart(Args),
    Install(Args),
    Link(LinkArgs),
    Publish(Args),
    Unpublish(Args),
    Domain {
        action: DomainAction,
    },
    Admin {
        action: AdminAction,
    },
    Login(Args),
    Logout(Args),
    Create(Args),
    Update(Args),
    Relate(Args),
    Delete(Args),
    Rename(Args),
    BatchUpdate(Args),
    Recover(Args),
    Anchors(Args),
    Changes(Args),
    Reload(Args),
    Fetch(FetchArgs),
    Pull(PullArgs),
    Push(PushArgs),
    BranchReset(BranchResetArgs),
    Mem {
        action: MemAction,
    },
    MemRepo {
        action: MemRepoAction,
    },
    Workspace {
        action: WorkspaceAction,
    },
    Schema(Args),
    Projection(Args),
}

Variants

Status

Node / edge counts, schema distribution, and per-binding projection state.

Entity(Args)

Read one entity as markdown.

Relations(Args)

List typed edges for an entity.

Search(Args)

Find entities by text or graph proximity.

List(Args)

Filter entities by metadata (no text match — use search for that).

Context(Args)

Read an entity’s community cluster.

Overview(Args)

All clusters with summaries and member lists. The full build renders the same rich content the MCP memstead_overview tool emits — both surfaces share the engine composer in memstead-engine.

Type(Args)

Describe one type, or list all types when no name given.

Health(Args)

Health summary (orphans, stubs, stale entities, missing fields).

Export(Args)

Export the write mem as markdown (in place) or as a portable .mem archive.

Init(InitArgs)

Initialise a filesystem mem in the current (or named) folder. Strict: errors out when the target is not empty.

Quickstart(Args)

One-command cold start: workspace + default-schema mem + seed entity + MCP wiring for your agent(s), in the current (or named) folder. Tolerates dotfiles and README-grade files; derives the mem name from the folder. For the strict, script-safe variant use memstead init.

Install(Args)

Install a sealed .mem mem — either a local file, or <scope>/<name> from the memstead.io registry.

Link(LinkArgs)

Link a filesystem mem to a registry-published dependency. memstead link <scope/name> fetches the archive into the workspace and records the dependency in the workspace config.

Publish(Args)

Publish a .mem archive to the registry. Triggers GitHub Device Flow on first use; subsequent runs are silent.

Unpublish(Args)

Unpublish (hard-delete) <scope>/<name> from the registry. Permitted to the original uploader and to admins. The same <scope>/<name> becomes immediately re-publishable.

Domain

Domain-authority publishing: generate the signing key for a domain you control and print the .well-known manifest to host. publish --scope <domain>:<handle> then signs with that key — no GitHub account needed.

Fields

action: DomainAction

Admin

Admin-only registry moderation: take a mem down or deny-list bytes. Gated server-side by the MEMSTEAD_ADMINS allowlist; every action is recorded in the registry’s append-only audit log.

Fields

action: AdminAction

Login(Args)

Authenticate with a registry via GitHub Device Flow. Optional — publish auto-triggers the same flow on first use.

Logout(Args)

Remove stored credentials for a registry.

Create(Args)

Create a new entity. Provide --title, --type, and the required section fields, or pass --from <file.json> with the full payload.

Update(Args)

Modify an existing entity. --expected-hash is required unless --auto-hash (refetch before write) or --force (skip check) is given.

Relate(Args)

Add or remove a typed relationship between two entities.

Delete(Args)

Delete an entity. Use --dry-run to preview impact first. Delete is hashless by design (no post-state to race on); race protection comes from HAS_INCOMING_REFS — and RESIDUAL_STUB_FOR_READONLY_REFERRERS for read-only-referrer cases.

Rename(Args)

Rename an entity (changes ID, file path, and every incoming wiki-link).

BatchUpdate(Args)

Update many entities in one atomic call. Input is a JSON file with a top-level updates: [...] array (one entry per entity, each with its own hash mode and mutation fields). All-or-nothing: if any entry fails (validation, hash mismatch, missing entity) the whole batch is refused and NOTHING is committed — fix the named entry and resubmit. On success the batch lands as one commit. Mirrors memstead update per entry.

Recover(Args)

Apply parse-time-drift recovery across writable mems. Walks PARSED_RELATION_INVALID warnings, re-renders affected source entities to drop the stale rows, and reports per-entry outcomes. Read-only-origin drops surface as skipped.

Anchors(Args)

Read provenance anchors (E3a): memstead anchors <id> lists an entity’s anchors + composition; memstead anchors --artifact <path> reverse-looks-up every entity whose anchor references that path (the query the check-realization hook consumes).

Changes(Args)

Diff a mem’s HEAD against a commit SHA. Pass --since = a prior commit_sha from a mutation, or the canonical empty-tree hash 4b825dc642cb6eb9a060e54bf8d69288fbee4904 for a first sync.

Reload(Args)

Reload one writable mem’s slice of the in-memory store from its on-disk branch tip — or every writable mem when --mem is omitted. CLI parity with the MCP memstead_reload tool.

Fetch(FetchArgs)

Fetch a mem’s branch refs from a git remote into the mem-repo (no local branch moves — inspect first, then pull). Requires a git-branch-backed mem (INVALID_INPUT on folder mounts); refuses UNKNOWN_REMOTE when the remote is not configured.

Pull(PullArgs)

Fast-forward a mem’s branch to its fetched remote counterpart and reload the in-memory store. Refuses LOCAL_DIVERGENCE when the local branch is not an ancestor of the remote — reconcile via branch-reset, or resolve on another clone and push.

Push(PushArgs)

Push a mem’s branch to a git remote. --force uses force-with-lease semantics; without it, non-fast-forward pushes refuse (NON_FAST_FORWARD). Refuses UNKNOWN_REMOTE when the remote is not configured.

BranchReset(BranchResetArgs)

Reset a mem’s branch pointer to a target ref/SHA. Refuses to discard commits reachable from any remote ref (PUSHED_COMMITS_PROTECTED).

Mem

Mem lifecycle commands.

Fields

action: MemAction

MemRepo

Mem-repo-git lifecycle commands.

Fields

action: MemRepoAction

Workspace

Introspect and configure workspace policy — dump reads the effective config; allow-create/revoke-create/allow-delete/ revoke-delete/grant-cross-link/revoke-cross-link/set-mutations write the mem-lifecycle allowlist, cross-mem link grants, and mutation policy.

Fields

action: WorkspaceAction

Schema(Args)

Author-time schema tooling. memstead schema validate <path> checks a schema package directory against the engine’s loader without touching a workspace.

Projection(Args)

Binding (projection-promotion) tooling — the projection is the unit, one versioned binding per source→mem obligation. memstead projection brief <binding> renders a binding’s run-brief (the Markdown prompt an agent consumes); memstead projection init scaffolds a fresh v1 binding non-interactively; memstead projection migrate promotes both legacy generations (root-folder scopes|projections|ingests/ and the gen-2 four-primitive store) into v1 bindings; memstead projection advance records disposition-gated sync-baseline advances; memstead projection enable <build|sync|verify> <binding> adds a missing operation block.

Trait Implementations

impl Debug for Command

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl FromArgMatches for Command

fn from_arg_matches(__clap_arg_matches: &ArgMatches) -> Result<Self, Error>

Instantiate Self from ArgMatches, parsing the arguments as needed.

fn from_arg_matches_mut( __clap_arg_matches: &mut ArgMatches, ) -> Result<Self, Error>

Instantiate Self from ArgMatches, parsing the arguments as needed.

fn update_from_arg_matches( &mut self, __clap_arg_matches: &ArgMatches, ) -> Result<(), Error>

Assign values from ArgMatches to self.

fn update_from_arg_matches_mut<'b>( &mut self, __clap_arg_matches: &mut ArgMatches, ) -> Result<(), Error>

Assign values from ArgMatches to self.

impl Subcommand for Command

fn augment_subcommands<'b>(__clap_app: Command) -> Command

Append to Command so it can instantiate Self via FromArgMatches::from_arg_matches_mut

fn augment_subcommands_for_update<'b>(__clap_app: Command) -> Command

Append to Command so it can instantiate self via FromArgMatches::update_from_arg_matches_mut

fn has_subcommand(__clap_name: &str) -> bool

Test whether Self can parse a specific subcommand