Enum Command 

pub enum Command {
    Mcp(McpArgs),
    Serve(ServeArgs),
    Capabilities(CapabilitiesArgs),
    Generate(GenerateArgs),
    Bench(BenchArgs),
    Scope(ScopeArgs),
    Web(WebArgs),
    Why(WhyArgs),
    Devtask(DevtaskArgs),
    Distribution(DistributionArgs),
    Env(EnvArgs),
    Commands(CommandsArgs),
    Completion(CompletionArgs),
    Worktree(WorktreeArgs),
    Prs(PrsArgs),
    Offload(OffloadArgs),
    Convergence(ConvergenceArgs),
    Commit(CommitArgs),
    Product(ProductArgs),
    Release(ReleaseArgs),
    Quality(QualityArgs),
    Run(RunArgs),
    Executions(ExecutionsArgs),
    Devcontext(DevcontextArgs),
    Guard(GuardArgs),
    Mesh(MeshArgs),
    Monitor(MonitorArgs),
    Models(ModelsArgs),
    Reasoning(ReasoningArgs),
    Evidence(EvidenceArgs),
    Served(ServedArgs),
    Rules(RulesArgs),
    Intent(IntentArgs),
    Delivery(DeliveryArgs),
    Economics(EconomicsArgs),
    Entity(EntityArgs),
    Shell(ShellArgs),
    Pack(PackArgs),
    Dashboard(DashboardArgs),
    Brief(BriefArgs),
    Skills(SkillsArgs),
    Knowledge(KnowledgeArgs),
    Continuity(ContinuityArgs),
}

The commands. A command listed here is implemented; nothing is advertised ahead of its behaviour.

Variants

Mcp(McpArgs)

Serve the repository’s AI layer to an MCP client over stdio

Serve(ServeArgs)

Serve the same capabilities over HTTP on the loopback interface, with the home page, /openapi.json, /swagger and the documentation under /docs/

Capabilities(CapabilitiesArgs)

Introspect the capability registry: what exists, where it came from, how it is exposed

Generate(GenerateArgs)

Write the committed projections of the registry (docs/generated), or check that they are current

Bench(BenchArgs)

Time every externally callable operation (each capability directly, over MCP and over HTTP, and the transports’ own operations), report coverage, compare with the accepted baseline

Scope(ScopeArgs)

The repository scope: what a worker reads and what it never reads; with paths, whether each is in or out and why

Web(WebArgs)

The repository’s web surfaces: what is exposed, where it is mounted, what produced it, and whether the topology is valid

Why(WhyArgs)

The operational moments this tool answers: the catalogue, one moment, the audiences and areas, a diagnosis of your own week, and the catalogue’s own validation

Devtask(DevtaskArgs)

One issue or one milestone as an executable development scope: what was authored, where the plan graph puts it, what happened to it, whether a worker may start it — with the origin of every value on the value

Distribution(DistributionArgs)

How this project is packaged, published and installed: the platforms, the artifact names, the installer, the releases

Env(EnvArgs)

What this checkout is: the project, version control, the toolchains it declares, what the layer holds, the workflows, the provider projections and the local services

Commands(CommandsArgs)

Every command this repository offers, from whichever program offers it: the graph, one command, where each one is projected, and the workflow bridge derived from it

Completion(CompletionArgs)

Completion for any surface, answered from the command graph: the candidates a shell asks for, and the one-time integration that asks

Worktree(WorktreeArgs)

The branch-to-worktree topology: where every linked worktree belongs (<repo>-wt/<branch>), where each one is, and the lifecycle — create, migrate, repair, guard

Prs(PrsArgs)

Pull-request integration: every open pull request classified against the current master with its evidence, the ranked plan, and the executor that merges the next provably safe one — one at a time, re-planning after each (ADR 0101)

Offload(OffloadArgs)

A branch’s derive run on another machine the repository declares (.ai/repo/offload/), in that machine’s turn: the hosts and their limits, a probe that names the host a derive would take, and the derive itself — bundle in, a FIFO queue on the host, a build directory of its own, bundle back, staged and never committed

Convergence(ConvergenceArgs)

Is any of this repository’s work held where it can be lost? Every holding — a work tree with uncommitted files, a branch with commits, a stash — with the disposition read from git, and one verdict over them

Commit(CommitArgs)

The commit as a value: what the working tree would commit and how it divides, the scope vocabulary this repository’s history yields, and the verdict on one message against the commit policy

Product(ProductArgs)

The product: what this repository’s tool does for a person, as the features under the layer declare it, with every surface, count and moment derived; the matrix of features against interfaces; the providers; and the model’s own validation

Release(ReleaseArgs)

What this project has shipped and what it would ship next: the changelog derived from the layer’s own records, the version authored in one place and projected for the shell tool, and the one command that raises it

Quality(QualityArgs)

What this executable’s own public surface is held to: documentation, executable examples, module coverage, and every command accounted for against the capability registry

Run(RunArgs)

Run a capability as an execution and follow it: its steps, its progress and its output as they happen

Executions(ExecutionsArgs)

The executions of the server serving this repository: what has run, what is running, and what each one said

Devcontext(DevcontextArgs)

The context a development session should be given, compiled from the repository: for an issue, a milestone, an intent or a set of paths, what is selected and why, what was left out and why, what collapsed into what, and the budget

Guard(GuardArgs)

The edit guard: whether a provider’s tool may write a file of this checkout now, judged from the active task’s scope and the writing session’s live mesh claims

Mesh(MeshArgs)

The mesh: the nodes this repository’s running server has discovered on the network, this machine’s node identity, and the self-check that proves the prerequisites on this machine alone

Monitor(MonitorArgs)

Everything that happens around this repository, followed in one stream: mesh sessions, claims, handovers and reviews on every linked machine, the executor’s merges and failures, and GitHub’s pull requests and runs, with what is addressed to you marked

Models(ModelsArgs)

The model catalogue the distribution declares, and the explainable routing over it: vendors, canonical model references, typed capabilities, and which model a stated need selects — with why, for every candidate

Reasoning(ReasoningArgs)

Provider-independent reasoning: the optional advisors and what they can do now, what an uncertainty calls for, the session’s reasoning records, their state and provenance, and the checks that keep reasoning independent of any advisor

Evidence(EvidenceArgs)

What actually ran and what it proves: every claim of the matrix against the runs recorded for it, one claim’s proof, one test’s claims, and the recording of a run that happened

Served(ServedArgs)

Whether a deployment serves the commit it was meant to: observe the build identity it serves, judged by commit containment, and read each deployment’s recorded standing against a commit

Rules(RulesArgs)

Every rule against the proof there is for it: what each one names, whether it is in the tree, whether a runner drives it, whether anything ran, and whether what ran is older than what it is about

Intent(IntentArgs)

What must become true above the milestones: every intent with its stage derived from the plan and its satisfaction from the recorded evidence, one intent, the model’s own validation, and which intent a piece of work serves

Delivery(DeliveryArgs)

Whether each product feature exists: on master, deployed, publicly verified, tested, its evidence published and linked — every dimension computed, unknown never a pass

Economics(EconomicsArgs)

Token economics, measured: matched runs with and without Majordomus, every metric with its measurement class and sample size, the statement the evidence allows, and the check that refuses an unsupported savings claim

Entity(EntityArgs)

Every object of the layer as an addressable node: the kinds and their routes, and one entity with its references, its backlinks, the surfaces that answer for it and the state of what it names

Shell(ShellArgs)

The repository’s shell automation against the tracked migration inventory: every shell unit declared with an exemption, and every exemption naming a unit the tree still has

Pack(PackArgs)

The tracked tree as token-bounded text shards for a language model’s file search: plan what a profile carries and leaves out, build it under tmp/packs/, and verify a written pack against its manifest; never a binary, a worktree, a link or build output

Dashboard(DashboardArgs)

The Dashboard Suite: each page a projection of the capabilities that hold its facts, every card carrying its source capability, the JSON pointer its value was read from, the Cockpit page with the evidence and the command that acts on it

Brief(BriefArgs)

What surrounds this session, in one line and in a few: its episode and task, the peers of every board, the mesh, the integration queue and the derive queue, asked of the server holding this checkout’s lease

Skills(SkillsArgs)

Every skill as a proven capability: the tests that name it and the evidence behind them, its page, the doctrine and gates that hold it, what invokes it, and the orphans

Knowledge(KnowledgeArgs)

What the knowledge deriver left for review and whether it is still writing: the candidate records awaiting promotion, one record by id with every reference it names resolved, and the derivation status of this checkout judged against the policy’s freshness thresholds

Continuity(ContinuityArgs)

Continue work on another machine: publish this checkout’s newest handover as a signed record in refs/majordomus/continuity, exchange records with a git remote, and plan and resume a handover another device published — with its source compatibility, lineage and trust decided before anything is written

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