HTTP API

List the generated artifacts

The manifest `majordomus generate` commits as docs/generated/artifacts.json, reconciled with the working tree: every document with the encodings it is written in, and every file with its format, schema, source, size, hash and whether the file on disk still matches. Optionally narrowed to one document or one encoding. Reads only; `majordomus generate` writes and `majordomus generate --check` is the byte-for-byte verdict.

• query
• behaviorally_verified
• benchmark required
• cache process (max_entries=8, ttl_seconds=5)
• MCP tool majordomus_artifacts
• MCP resource {"name": "artifacts", "uri": "majordomus://artifacts"}

Query parameters

Try it

The port is whatever the server logged; 8741 is the one it asks for first. The values are the operation's first example.

curl -s "http://127.0.0.1:8741/api/v1/artifacts?format=yaml"

Responses

List capabilities

Every capability of this executable and this repository, summarised: kind, module, stability, provenance, the projections it declares, its benchmark and cache policy; the schemas are answered by capabilities.describe.

• query
• behaviorally_verified
• benchmark required
• cache process (max_entries=16)
• MCP tool majordomus_capabilities
• $ capabilities list

Query parameters

Try it

The port is whatever the server logged; 8741 is the one it asks for first. The values are the operation's first example.

curl -s "http://127.0.0.1:8741/api/v1/capabilities?kind=query"

Responses

Where each capability is projected

A row per capability with the command line, HTTP route, MCP tool and MCP resource it reaches, whether every exposure it declares is answered by that surface, and the runnable commands no capability claims. Derived from the registry and the clap declaration; nothing is written down.

• query
• behaviorally_verified
• benchmark required
• cache process (max_entries=8)
• MCP tool majordomus_projections
• $ capabilities projections

Query parameters

Try it

The port is whatever the server logged; 8741 is the one it asks for first. The values are the operation's first example.

curl -s "http://127.0.0.1:8741/api/v1/capabilities/projections?unmet=false"

Responses

Describe one capability

One capability by canonical id: its kind, schemas, provenance, stability, exposures, benchmark and cache policy.

• query
• behaviorally_verified
• benchmark required
• cache disabled
• MCP tool majordomus_capability
• $ capabilities describe

Query parameters

Try it

The port is whatever the server logged; 8741 is the one it asks for first. The values are the operation's first example.

curl -s "http://127.0.0.1:8741/api/v1/capability?id=repository.info"

Responses

One command in full

One command by its canonical identity: its arguments with the source of each one's values, what running it changes, what it needs, where it came from, and every surface that carries it — with the reason a machine surface withholds it when one does.

• query
• implemented
• benchmark required
• cache disabled
• MCP tool majordomus_command

Query parameters

Try it

The port is whatever the server logged; 8741 is the one it asks for first. The values are the operation's first example.

curl -s "http://127.0.0.1:8741/api/v1/command?id=executable.worktree.status"

Responses

Every command, one line each

The commands this repository offers, filtered by the program that runs them, by what running them changes, or by text. A summary rather than the whole graph: enough to choose a command, and never so much that a client has to read every argument of every command to find one.

• query
• implemented
• benchmark required
• cache disabled
• MCP tool majordomus_commands
• MCP resource {"name": "commands", "uri": "majordomus://commands"}

Query parameters

Try it

The port is whatever the server logged; 8741 is the one it asks for first. The values are the operation's first example.

curl -s "http://127.0.0.1:8741/api/v1/commands?origin=executable&effect=read_only"

Responses

The whole command graph

The graph as one document, with its fingerprint and every diagnostic its build found: a duplicate identity, a recipe name two commands would take, an annotation that names a command which no longer exists. Deterministic — two builds over one tree produce the same document — so a client may cache against the fingerprint.

• query
• implemented
• benchmark required
• cache disabled
• MCP tool majordomus_command_graph

No parameters.

Try it

The port is whatever the server logged; 8741 is the one it asks for first. The values are the operation's first example.

curl -s "http://127.0.0.1:8741/api/v1/commands/graph"

Responses

What the lifecycle is holding

The open episode, the active task, the handover and checkpoint that resolve for this worktree and branch, each with its divergence label, the unresolved questions that refuse completion, and the record tallies. Selection is two-tiered and never repository-wide: a record from an unrelated worktree or branch is not offered, because a briefing that is quietly about somebody else is worse than none. Absence is reported as absence.

• query
• behaviorally_verified
• benchmark required
• cache process (max_entries=2, ttl_seconds=2)
• MCP tool majordomus_continuity
• MCP resource {"name": "continuity", "uri": "majordomus://continuity"}

No parameters.

Try it

The port is whatever the server logged; 8741 is the one it asks for first. The values are the operation's first example.

curl -s "http://127.0.0.1:8741/api/v1/continuity"

Responses

One deployment

One deployment by its identity, typed, with the repository-relative file it was read from.

• query
• behaviorally_verified
• benchmark required
• cache disabled
• MCP tool majordomus_deployment

Query parameters

Try it

The port is whatever the server logged; 8741 is the one it asks for first. The values are the operation's first example.

curl -s "http://127.0.0.1:8741/api/v1/deployment?id=majordomus"

Responses

Deployments

Every deployment the layer declares, typed: the application, the package and binary shipped, the address the process listens on, the routes a platform polls, the resources, the machine count, the region, the build inputs, the measured budgets and the provider's own facts. An object of the kind this executable cannot read is reported with the reason rather than skipped.

• query
• behaviorally_verified
• benchmark required
• cache disabled
• MCP tool majordomus_deployments
• MCP resource {"name": "deployments", "uri": "majordomus://deployments"}

No parameters.

Try it

The port is whatever the server logged; 8741 is the one it asks for first. The values are the operation's first example.

curl -s "http://127.0.0.1:8741/api/v1/deployments"

Responses

Would these deployments work

Every refusal the declared deployments earn locally: a health route no capability registers, a package or binary the workspace does not produce, a build input that does not resolve, more machines running than exist, a hosted process that would bind loopback. Each names the file, the key, the value observed and the correction. Nothing here contacts the provider.

• query
• behaviorally_verified
• benchmark required
• cache process (max_entries=2, ttl_seconds=5)
• MCP tool majordomus_deploy_check

No parameters.

Try it

The port is whatever the server logged; 8741 is the one it asks for first. The values are the operation's first example.

curl -s "http://127.0.0.1:8741/api/v1/deployments/check"

Responses

The layer's directory contracts

Every directory of the layer the index knows, with the contract it declares, whether it owes one and which contract decided, and — for a named path, or when asked for everywhere — the effective chain composed from the root down, least specific first.

• query
• behaviorally_verified
• benchmark required
• cache process (max_entries=8, ttl_seconds=5)
• MCP tool majordomus_directories
• MCP resource {"name": "directories", "uri": "majordomus://directories"}

Query parameters

Try it

The port is whatever the server logged; 8741 is the one it asks for first. The values are the operation's first example.

curl -s "http://127.0.0.1:8741/api/v1/directories?path=.ai%2Frepo%2Frules&effective=true&state=owed"

Responses

The distribution model

The one-line install command, where an installation goes, and every declared target with the artifact name it derives. This is what the installation page, the landing page's install block and the cockpit's install card render; none of them holds a platform list of its own.

• query
• behaviorally_verified
• benchmark required
• cache disabled
• MCP tool majordomus_distribution
• $ distribution show

No parameters.

Try it

The port is whatever the server logged; 8741 is the one it asks for first. The values are the operation's first example.

curl -s "http://127.0.0.1:8741/api/v1/distribution"

Responses

The artifact of a target

The archive name a target and a tag derive, the directory it unpacks into, and where a release publishes it. The one naming function answers; the release pipeline asks it rather than composing a name in a workflow file.

• query
• behaviorally_verified
• benchmark required
• cache disabled
• MCP tool majordomus_artifact
• $ distribution artifact

Query parameters

Try it

The port is whatever the server logged; 8741 is the one it asks for first. The values are the operation's first example.

curl -s "http://127.0.0.1:8741/api/v1/distribution/artifact?target=aarch64-apple-darwin&tag=v0.0.0"

Responses

This build

What this executable is: the version of the crate it was built from, the Rust target triple, the profile, and the commit — all compiled in at build time, so an installed binary answers without a repository, a toolchain or git.

• query
• behaviorally_verified
• benchmark required
• cache disabled
• MCP tool majordomus_build
• $ distribution build

No parameters.

Try it

The port is whatever the server logged; 8741 is the one it asks for first. The values are the operation's first example.

curl -s "http://127.0.0.1:8741/api/v1/distribution/build"

Responses

Published releases

Every release this repository recorded, newest first, and the one an unpinned installation resolves to: the highest version among the stable, unwithdrawn records. The pointer is derived here and never authored anywhere.

• query
• behaviorally_verified
• benchmark required
• cache disabled
• MCP tool majordomus_releases
• $ distribution releases

No parameters.

Try it

The port is whatever the server logged; 8741 is the one it asks for first. The values are the operation's first example.

curl -s "http://127.0.0.1:8741/api/v1/distribution/releases"

Responses

Whether the published installation works

Whether a machine that has never seen this project can install it right now with the advertised one-line command, and when it cannot, which link in the chain is missing and what changes it. Derived from the distribution model and the release records alone: it reaches no network, so it is as fast as any other local query and answers offline. The served bytes are proved by the release pipeline's smoke phase, not guessed at here.

• query
• behaviorally_verified
• benchmark required
• cache disabled
• MCP tool majordomus_install_status
• $ distribution status

No parameters.

Try it

The port is whatever the server logged; 8741 is the one it asks for first. The values are the operation's first example.

curl -s "http://127.0.0.1:8741/api/v1/distribution/status"

Responses

The repository environment

One snapshot of this checkout: project identity, repository identity, version control, declared toolchains, what the layer holds counted per kind, the workflows the runner describes, the provider projections against the policy that renders them, and the local services with the address a running server published. Every value carries where it came from.

• query
• behaviorally_verified
• benchmark required
• cache process (max_entries=4, ttl_seconds=3)
• MCP tool majordomus_environment
• MCP resource {"name": "environment", "uri": "majordomus://environment"}

Query parameters

Try it

The port is whatever the server logged; 8741 is the one it asks for first. The values are the operation's first example.

curl -s "http://127.0.0.1:8741/api/v1/environment?probe_services=false"

Responses

Where an environment value came from

The provenance of the snapshot: for each field, what decided it — a compile-time constant, a file, a command, or the cache — which resolver read it, and how far it can be trusted. Narrow it to one field, or to a prefix, by name.

• query
• behaviorally_verified
• benchmark required
• cache disabled
• MCP tool majordomus_environment_explain

Query parameters

Try it

The port is whatever the server logged; 8741 is the one it asks for first. The values are the operation's first example.

curl -s "http://127.0.0.1:8741/api/v1/environment/explain?field=project.version"

Responses

List executions

Every execution this process remembers, newest first, narrowed by state or by capability. The counts beside them — remembered, active, queued, live channels — are what a control plane shows without asking a second question.

• query
• behaviorally_verified
• benchmark required
• cache disabled
• MCP tool majordomus_executions
• MCP resource {"name": "executions", "uri": "majordomus://executions"}
• $ executions list

Query parameters

Try it

The port is whatever the server logged; 8741 is the one it asks for first. The values are the operation's first example.

curl -s "http://127.0.0.1:8741/api/v1/executions?limit=50"

Responses

Ask an execution to stop

Set the execution's cancellation flag and say so on its stream. Cancellation is cooperative: a task looks at its flag and stops, and a capability whose policy says it is not cancellable runs to completion — which the answer says rather than pretending otherwise.

• command
• behaviorally_verified
• benchmark waived: transient_state
• cache disabled
• MCP tool majordomus_execution_cancel
• $ executions cancel

Request body — CancelInput, JSON

Try it

The port is whatever the server logged; 8741 is the one it asks for first. The values are the operation's first example.

curl -s -X POST "http://127.0.0.1:8741/api/v1/executions/cancel" -H "content-type: application/json" -d '{}'

Responses

Demonstrate an execution

Walk a given number of steps, reporting each one, logging a line and advancing progress, then finish — or fail at a step you name. It exists so that an operator, a probe and an end-to-end test can prove the whole path works without waiting for real work: it reads nothing, writes nothing, and its only effect is the events it produces. It looks at its cancellation flag between steps and while it waits, so cancelling it stops it.

• query
• behaviorally_verified
• benchmark required
• cache disabled
• MCP tool majordomus_demonstrate_execution

Query parameters

Try it

The port is whatever the server logged; 8741 is the one it asks for first. The values are the operation's first example.

curl -s "http://127.0.0.1:8741/api/v1/executions/demonstrate?steps=1&delay_ms=0"

Responses

An execution's event history

The retained events of one execution, oldest first, after a sequence number. This is what a browser reads after a reload and what a client reads after a reconnect: the page carries the cursor to open the live channel with, so nothing is missed between the history and the stream.

• query
• behaviorally_verified
• benchmark waived: transient_state
• cache disabled
• MCP tool majordomus_execution_events
• $ executions events

Query parameters

Try it

The port is whatever the server logged; 8741 is the one it asks for first. The values are the operation's first example.

curl -s "http://127.0.0.1:8741/api/v1/executions/events"

Responses

One execution

The whole of what is known about one execution: its state, its input as it was stored, its steps, its progress, its diagnostics, and its output or its error. Taken under one lock, so a snapshot that says it succeeded carries what it produced.

• query
• behaviorally_verified
• benchmark waived: transient_state
• cache disabled
• MCP tool majordomus_execution
• $ executions show

Query parameters

Try it

The port is whatever the server logged; 8741 is the one it asks for first. The values are the operation's first example.

curl -s "http://127.0.0.1:8741/api/v1/executions/get"

Responses

The live channel's contract

Where the WebSocket is, how a subscription and a reconnect are expressed, what the server writes, and the JSON Schema of every message — derived from the Rust types that implement it, so a client validating against this is validating against the implementation. OpenAPI cannot describe a socket; this is where that contract lives.

• query
• behaviorally_verified
• benchmark required
• cache disabled
• MCP tool majordomus_execution_protocol
• MCP resource {"name": "execution-protocol", "uri": "majordomus://executions/protocol"}
• $ executions protocol

No parameters.

Try it

The port is whatever the server logged; 8741 is the one it asks for first. The values are the operation's first example.

curl -s "http://127.0.0.1:8741/api/v1/executions/protocol"

Responses

Start a capability as an execution

Run any executable capability of this registry as an execution: the input is checked against that capability's own input schema, the work is queued, and this answers at once with the execution's id and the links to follow it. Nothing waits for the handler. The capability runs through the same executor every other interface calls, so there is no second implementation of anything.

• command
• behaviorally_verified
• benchmark required
• cache disabled
• MCP tool majordomus_execution_start
• $ run

Request body — StartInput, JSON

example demonstrate

{"capability":"executions.demonstrate","input":{"steps":1,"delay_ms":0}}

Try it

The port is whatever the server logged; 8741 is the one it asks for first. The values are the operation's first example.

curl -s -X POST "http://127.0.0.1:8741/api/v1/executions/start" -H "content-type: application/json" -d '{"capability":"executions.demonstrate","input":{"steps":1,"delay_ms":0}}'

Responses

Derive one graph

One graph by id: its nodes and edges with the vocabularies that say what each kind means, the file every node was derived from, and whether the result is acyclic. Deterministic for a given tree and executable.

• query
• behaviorally_verified
• benchmark required
• cache process (max_entries=16)
• MCP tool majordomus_graph

Query parameters

Try it

The port is whatever the server logged; 8741 is the one it asks for first. The values are the operation's first example.

curl -s "http://127.0.0.1:8741/api/v1/graph?id=adrs"

Responses

List graphs

Every graph this executable derives: its id, what it shows, and what it is derived from.

• query
• behaviorally_verified
• benchmark required
• cache disabled
• MCP tool majordomus_graphs
• MCP resource {"name": "graphs", "uri": "majordomus://graphs"}

No parameters.

Try it

The port is whatever the server logged; 8741 is the one it asks for first. The values are the operation's first example.

curl -s "http://127.0.0.1:8741/api/v1/graphs"

Responses

Health of this process

Every dimension of what this process serves — the layer as it was read, the registry, the scope, version control, benchmark coverage, the committed registry manifest and the attached peers — each decided by the engine that owns it, with the command that reproduces the verdict.

• query
• behaviorally_verified
• benchmark required
• cache process (max_entries=4, ttl_seconds=5)
• MCP tool majordomus_health
• MCP resource {"name": "health", "uri": "majordomus://health"}

No parameters.

Try it

The port is whatever the server logged; 8741 is the one it asks for first. The values are the operation's first example.

curl -s "http://127.0.0.1:8741/api/v1/health"

Responses

Liveness

Is this process alive: the cheapest true statement this executable can make about itself, with the version that answered. No filesystem traversal, no index build, no network — this is what a hosting platform polls, and it must cost nothing to say.

• query
• behaviorally_verified
• benchmark required
• cache disabled

No parameters.

Try it

The port is whatever the server logged; 8741 is the one it asks for first. The values are the operation's first example.

curl -s "http://127.0.0.1:8741/api/v1/live"

Responses

Readiness

Can this process serve traffic: the registry and the index it built at start-up, already resident, and how the layer read. Only local initialisation — never an external provider, a database or another service, because a readiness check that probes a dependency fails a deployment for something that is not this process.

• query
• behaviorally_verified
• benchmark required
• cache disabled

No parameters.

Try it

The port is whatever the server logged; 8741 is the one it asks for first. The values are the operation's first example.

curl -s "http://127.0.0.1:8741/api/v1/ready"

Responses

Get one object

One object by URI (majordomus://<kind>/<identity>): metadata, provenance and content; a URI a query projects (majordomus://repository) answers that query as a JSON document. The same resolution serves the MCP resource read.

• query
• behaviorally_verified
• benchmark required
• cache disabled
• MCP tool majordomus_get

Query parameters

Try it

The port is whatever the server logged; 8741 is the one it asks for first. The values are the operation's first example.

curl -s "http://127.0.0.1:8741/api/v1/object?uri=majordomus%3A%2F%2Fadr%2Fadr-0001"

Responses

List objects

List the declarative objects of the repository's AI layer, optionally by kind or tag.

• query
• behaviorally_verified
• benchmark required
• cache disabled
• MCP tool majordomus_list

Query parameters

Try it

The port is whatever the server logged; 8741 is the one it asks for first. The values are the operation's first example.

curl -s "http://127.0.0.1:8741/api/v1/objects?kind=adr"

Responses

Verify the index against the working tree

Read every file the layer was built from and compare it with what this process is serving. The index is built once at start-up and kept, which is what makes every other request cost nothing and what makes a file edited afterwards be served as it was; this is how a running server says whether that has happened, without being restarted to find out. A file that is one object is compared byte for byte; a collection file, whose objects the index keeps as members rather than as text, is compared by size, and every finding says which comparison was made. It reads every file of the layer, so it reports its progress file by file and stops when it is asked to.

• query
• behaviorally_verified
• benchmark required
• cache disabled
• MCP tool majordomus_verify_objects

Query parameters

Try it

The port is whatever the server logged; 8741 is the one it asks for first. The values are the operation's first example.

curl -s "http://127.0.0.1:8741/api/v1/objects/verify?limit=25"

Responses

Search objects

Case-insensitive substring search over identities, titles, descriptions and content.

• query
• behaviorally_verified
• benchmark required
• cache process (max_entries=64)
• MCP tool majordomus_search

Query parameters

Try it

The port is whatever the server logged; 8741 is the one it asks for first. The values are the operation's first example.

curl -s "http://127.0.0.1:8741/api/v1/search?query=the&limit=5"

Responses

Every obligation there is

The tokens a task may declare in `requires`: what each one asks of a worker, the command that discharges it, the pathspecs its evidence is hashed over, and whether its fact is remote and therefore bound to a commit rather than to a tree. Shipped data, identical in every clone, so this answers in a checkout that has never run the lifecycle.

• query
• behaviorally_verified
• benchmark required
• cache process (max_entries=2)
• MCP tool majordomus_obligations
• MCP resource {"name": "obligations", "uri": "majordomus://obligations"}

No parameters.

Try it

The port is whatever the server logged; 8741 is the one it asks for first. The values are the operation's first example.

curl -s "http://127.0.0.1:8741/api/v1/obligations"

Responses

What this task still owes

Every obligation the active task declared, joined with what the vocabulary says about it and with the evidence that does or does not discharge it: what is owed, what is discharged, and what has gone stale — with the recorded input hash and the tree's current one, or the recorded commit and its label, so a reader can see against what. The judgement is the one `finish` applies, reproduced rather than re-decided, and the staleness words are the repository's only four. A checkout with no task reports that, rather than reporting nothing owed.

• query
• behaviorally_verified
• benchmark required
• cache process (max_entries=2, ttl_seconds=2)
• MCP tool majordomus_obligation_closure
• MCP resource {"name": "obligation-closure", "uri": "majordomus://obligations/closure"}

No parameters.

Try it

The port is whatever the server logged; 8741 is the one it asks for first. The values are the operation's first example.

curl -s "http://127.0.0.1:8741/api/v1/obligations/closure"

Responses

List peers

Every client attached to this shared server: id, the client's own name and version from its initialize, transport, when it attached, when it was last seen, and what it announced. In-memory, gone with the process.

• query
• behaviorally_verified
• benchmark required
• cache disabled
• MCP tool majordomus_peers

No parameters.

Try it

The port is whatever the server logged; 8741 is the one it asks for first. The values are the operation's first example.

curl -s "http://127.0.0.1:8741/api/v1/peers"

Responses

Announce what this peer is working on

Tell the other peers of this shared server what the calling session is doing and which paths it expects to touch. Changes this process's memory only; the repository is never written. Needs an MCP session: over plain HTTP there is no caller.

• command
• behaviorally_verified
• benchmark required
• cache disabled
• MCP tool majordomus_announce

Request body — AnnounceInput, JSON

example default

{"intent":"benchmark: announcing","scope":["apps/majordomus-cli"]}

Try it

The port is whatever the server logged; 8741 is the one it asks for first. The values are the operation's first example.

curl -s -X POST "http://127.0.0.1:8741/api/v1/peers/announce" -H "content-type: application/json" -d '{"intent":"benchmark: announcing","scope":["apps/majordomus-cli"]}'

Responses

Performance counters

The counters of this process: repository scans, index and registry builds, schema generations, projection builds, executions, handler invocations, cache hits, misses and evictions, and the phase timings, as they stand now.

• query
• behaviorally_verified
• benchmark required
• cache disabled
• MCP tool majordomus_perf

No parameters.

Try it

The port is whatever the server logged; 8741 is the one it asks for first. The values are the operation's first example.

curl -s "http://127.0.0.1:8741/api/v1/perf"

Responses

The whole derived plan

Every milestone and issue with its derived status, wave, rank, both directions of its graph and its counts; the execution waves; both dependency graphs as edges; every validation finding; and the plan's header with the active milestone derived. The one value every other capability of this module answers out of. Derived on every call: a transition writes a lifecycle marker into a record between two calls, and a plan answered from a snapshot would send two workers to one issue.

• query
• behaviorally_verified
• benchmark required
• cache disabled
• MCP tool majordomus_plan
• MCP resource {"name": "plan", "uri": "majordomus://plan"}

No parameters.

Try it

The port is whatever the server logged; 8741 is the one it asks for first. The values are the operation's first example.

curl -s "http://127.0.0.1:8741/api/v1/plan"

Responses

The issues, filtered by what the graph derived

One record per issue with its derived status, its wave, the dependencies it declares, the ones that are not DONE (plus `milestone:<id>` when the gate holds the whole outcome back), the issues that depend on it, the paths it touches and its evidence tally. Filtering by `status: READY` is the ready set and by `status: BLOCKED` the blocked set; nothing here is a separate derivation.

• query
• behaviorally_verified
• benchmark required
• cache disabled
• MCP tool majordomus_plan_issues

Query parameters

Try it

The port is whatever the server logged; 8741 is the one it asks for first. The values are the operation's first example.

curl -s "http://127.0.0.1:8741/api/v1/plan/issues?milestone=M000&status=READY"

Responses

The one issue to take now

The lowest-wave READY issue of the active milestone, highest priority first, then id. The active milestone can have nothing ready while another one does — one waiting on its own acceptance evidence, for instance — so the search widens to the whole plan rather than answering `none` and sending a worker away from work that is genuinely executable. This is what an agent asks before it starts.

• query
• behaviorally_verified
• benchmark required
• cache disabled
• MCP tool majordomus_plan_next

Query parameters

Try it

The port is whatever the server logged; 8741 is the one it asks for first. The values are the operation's first example.

curl -s "http://127.0.0.1:8741/api/v1/plan/next?milestone=M000"

Responses

One milestone or issue, with everything derived about it

A milestone with its issues in full, or an issue with the issues it waits on in full. The record's own prose stays where it has always been — `majordomus://issue/<id>` returns the file — and this answers what the file cannot say about itself: what its status is, where it sits in the graph, and what is between it and being executable.

• query
• behaviorally_verified
• benchmark required
• cache disabled
• MCP tool majordomus_plan_record

Query parameters

Try it

The port is whatever the server logged; 8741 is the one it asks for first. The values are the operation's first example.

curl -s "http://127.0.0.1:8741/api/v1/plan/record?id=I0001"

Responses

The milestones in derived order

The milestone graph laid out by rank, with `order` breaking ties inside a rank only, and the first unblocked unfinished milestone as `now` and the one after it as `next`. Nothing in the sequence is authored: a milestone whose prerequisites are not real cannot be nominated, which is what makes `each step is gated by the previous one being real` an invariant rather than a sentence.

• query
• behaviorally_verified
• benchmark required
• cache disabled
• MCP tool majordomus_plan_roadmap

No parameters.

Try it

The port is whatever the server logged; 8741 is the one it asks for first. The values are the operation's first example.

curl -s "http://127.0.0.1:8741/api/v1/plan/roadmap"

Responses

Where the plan stands

Every milestone with its derived status and its issues counted by status, the milestone a worker is executing now, the next ready issue in full, and the plan's own totals. The counts are keyed by the declared vocabulary, which travels with the answer, so a status added to the engine appears here without anything being edited.

• query
• behaviorally_verified
• benchmark required
• cache disabled
• MCP tool majordomus_plan_status

Query parameters

Try it

The port is whatever the server logged; 8741 is the one it asks for first. The values are the operation's first example.

curl -s "http://127.0.0.1:8741/api/v1/plan/status?milestone=M000"

Responses

What the model refuses

Every finding the derivation produced, in the order it produced them: a dependency on something that is not an issue, a cycle, an issue executing ahead of its dependencies or of its milestone's gate, an issue with no acceptance criteria, evidence missing under a completion date, a milestone whose graph contradicts itself, two issues of one wave sharing a path. A failure means the model is invalid; a warning means it is legal and worth reading.

• query
• behaviorally_verified
• benchmark required
• cache disabled
• MCP tool majordomus_plan_validate

No parameters.

Try it

The port is whatever the server logged; 8741 is the one it asks for first. The values are the operation's first example.

curl -s "http://127.0.0.1:8741/api/v1/plan/validate"

Responses

What may run at the same time

The topological layering of the issue graph: an issue enters a wave only once every dependency has left it, so its wave is one past the longest path to it. Sharing a wave is a necessary condition for running two issues at once, not a sufficient one — overlapping scope serialises them, and every such overlap is reported beside the waves rather than left for two workers to discover in a merge conflict.

• query
• behaviorally_verified
• benchmark required
• cache disabled
• MCP tool majordomus_plan_waves

Query parameters

Try it

The port is whatever the server logged; 8741 is the one it asks for first. The values are the operation's first example.

curl -s "http://127.0.0.1:8741/api/v1/plan/waves?milestone=M000"

Responses

One feature

One product feature in full: the record as its file declares it, and everything derived from what it names — the capabilities of its modules with their tools, routes and command-line paths, the commands with their summaries, the objects of its kinds counted, the rules with their class and whether the tool enforces them, the documents, the decisions, the claims with their status, the use cases, the Cockpit areas and web surfaces with their routes, the moments it answers, and the interfaces all of that adds up to.

• query
• behaviorally_verified
• benchmark required
• cache process (max_entries=64)
• MCP tool majordomus_feature
• $ product show

Query parameters

Try it

The port is whatever the server logged; 8741 is the one it asks for first. The values are the operation's first example.

curl -s "http://127.0.0.1:8741/api/v1/product/feature?id=benchmarks"

Responses

The features

Every product feature this repository declares, narrowed by any of the facets the model derives — featured, area, module, command, surface, text — with the interfaces each is exposed through, the counts behind it and what is guaranteed about it, none of which its file states. The default is the stable set; pass status=any for the drafts too.

• query
• behaviorally_verified
• benchmark required
• cache process (max_entries=32)
• MCP tool majordomus_features
• MCP resource {"name": "product", "uri": "majordomus://product"}
• $ product list

Query parameters

Try it

The port is whatever the server logged; 8741 is the one it asks for first. The values are the operation's first example.

curl -s "http://127.0.0.1:8741/api/v1/product/features?featured=true&area=context"

Responses

Features against interfaces

Every feature against the command line, the HTTP API, MCP, the Cockpit and the documentation, each mark derived from what the feature names; then every builtin module of the executable, every public command of the shell tool and every kind of the layer with the stable features that name it. A row with no feature is reported as a gap rather than hidden.

• query
• behaviorally_verified
• benchmark required
• cache process (max_entries=2)
• MCP tool majordomus_product_matrix
• MCP resource {"name": "product-matrix", "uri": "majordomus://product/matrix"}
• $ product matrix

No parameters.

Try it

The port is whatever the server logged; 8741 is the one it asks for first. The values are the operation's first example.

curl -s "http://127.0.0.1:8741/api/v1/product/matrix"

Responses

The providers

Every provider the tool has an adapter for — one per template the distribution ships — with the bootstraps this repository's policy renders through it, the client configuration it carries for the shared MCP server, and the hooks the policy wires. The set is the templates; nothing here is a list of vendors.

• query
• behaviorally_verified
• benchmark required
• cache process (max_entries=2)
• MCP tool majordomus_providers
• MCP resource {"name": "providers", "uri": "majordomus://product/providers"}
• $ product providers

No parameters.

Try it

The port is whatever the server logged; 8741 is the one it asks for first. The values are the operation's first example.

curl -s "http://127.0.0.1:8741/api/v1/product/providers"

Responses

Validate the model

Every finding over the product model: a reference that resolves to nothing, with the nearest candidate; a duplicate identity; a file name that disagrees with its id; a draft that is featured; a stable feature under its floors; and every module, command or kind that no stable feature names. Errors make the model invalid; warnings do not.

• query
• behaviorally_verified
• benchmark required
• cache process (max_entries=2)
• MCP tool majordomus_product_validate
• $ product validate

No parameters.

Try it

The port is whatever the server logged; 8741 is the one it asks for first. The values are the operation's first example.

curl -s "http://127.0.0.1:8741/api/v1/product/validate"

Responses

Public API quality report

The crate's exported surface measured against the repository's rules: how many items are documented and exampled, how many modules are documented, exampled and behaviourally tested, how the canonical operations stand against the command line, HTTP, OpenAPI and MCP, and one finding per violation carrying a stable code, the rule that requires it, its file and line, why it matters and what to do about it.

• query
• behaviorally_verified
• benchmark required
• cache process (max_entries=8, ttl_seconds=10)
• MCP tool majordomus_quality
• MCP resource {"name": "quality", "uri": "majordomus://quality"}
• $ quality report

Query parameters

Try it

The port is whatever the server logged; 8741 is the one it asks for first. The values are the operation's first example.

curl -s "http://127.0.0.1:8741/api/v1/quality?summary_only=false&include_baselined=false"

Responses

The changelog

Every release the layer records, newest first, with the work that has not been released leading. A section's decisions are the ADRs dated inside that release's window, its changes the conventional commits in its range, its artifacts the record's own evidence. Nothing in it is authored, and a section that could not be read says so rather than appearing empty.

• query
• implemented
• benchmark required
• cache disabled
• MCP tool majordomus_changelog
• MCP resource {"name": "changelog", "uri": "majordomus://changelog"}

Query parameters

Try it

The port is whatever the server logged; 8741 is the one it asks for first. The values are the operation's first example.

curl -s "http://127.0.0.1:8741/api/v1/changelog?version=0.3.1"

Responses

The version, and the one the commits imply

The version the crate manifest declares, the version the shell tool prints, and whether they agree — the same question `scripts/release-version --check` gates on. Then the bump the conventional commits since the last release imply, the version it would produce, and the commits themselves as the evidence for it.

• query
• implemented
• benchmark required
• cache disabled
• MCP tool majordomus_release_version

No parameters.

Try it

The port is whatever the server logged; 8741 is the one it asks for first. The values are the operation's first example.

curl -s "http://127.0.0.1:8741/api/v1/release/version"

Responses

Repository and index state

The repository root, layer sections, git state, discovery mode, kinds present, every diagnostic, and the capability registry counted.

• query
• behaviorally_verified
• benchmark required
• cache disabled
• MCP tool majordomus_repository
• MCP resource {"name": "repository", "uri": "majordomus://repository"}

No parameters.

Try it

The port is whatever the server logged; 8741 is the one it asks for first. The values are the operation's first example.

curl -s "http://127.0.0.1:8741/api/v1/repository"

Responses

The repository scope

The scope declaration as read, where it came from (the repository's own or the distribution's default), and every tracked file tallied against it: how many are in, how many are out for each reason, and which.

• query
• behaviorally_verified
• benchmark required
• cache disabled
• MCP tool majordomus_scope
• MCP resource {"name": "scope", "uri": "majordomus://scope"}
• $ scope

No parameters.

Try it

The port is whatever the server logged; 8741 is the one it asks for first. The values are the operation's first example.

curl -s "http://127.0.0.1:8741/api/v1/scope"

Responses

Judge a path against the scope

Whether a repository-relative path is in or out of the scope, the reason when it is out, and the pattern or limit that decided; an existing file is judged by name, then size, then content.

• query
• behaviorally_verified
• benchmark required
• cache disabled
• MCP tool majordomus_scope_classify

Query parameters

Try it

The port is whatever the server logged; 8741 is the one it asks for first. The values are the operation's first example.

curl -s "http://127.0.0.1:8741/api/v1/scope/classify?path=.ai%2Frepo%2Fadrs%2F0001-rust-cli-and-stdio-mcp.md"

Responses

The whole work graph above the branch

Every issue at least one branch names with its branches and commits, every declared issue no branch names, and the newest stretch of the trunk with each commit attributed to the issue whose branches hold it or reported as unattributed. The tallies count both sides, so the proportion of the trunk that no execution contract accounts for is a number rather than an impression. Read from git on every call: the history changes outside this process.

• query
• behaviorally_verified
• benchmark required
• cache disabled
• MCP tool majordomus_traceability
• MCP resource {"name": "traceability", "uri": "majordomus://traceability"}

Query parameters

Try it

The port is whatever the server logged; 8741 is the one it asks for first. The values are the operation's first example.

curl -s "http://127.0.0.1:8741/api/v1/trace?limit=10"

Responses

What contract this commit served

One commit with the issue and milestone it served, or the fact that none can be found. Attributed when exactly one issue's branches hold it, ambiguous when branches naming two issues do, and unattributed when no branch naming an issue holds it at all — which is either work committed without an execution contract or a branch deleted after its merge, and the answer says so rather than guessing between them.

• query
• behaviorally_verified
• benchmark required
• cache disabled
• MCP tool majordomus_trace_commit

Query parameters

Try it

The port is whatever the server logged; 8741 is the one it asks for first. The values are the operation's first example.

curl -s "http://127.0.0.1:8741/api/v1/trace/commit?commit=HEAD"

Responses

What realised this issue

One issue with the branches that name it — local, and remote-tracking where only the remote still has the branch — and, for each, the commits it holds that the trunk did not: measured against the trunk while the branch is open, and against the first parent of the merge commit that brought it in once it is merged. A branch that reached the trunk without a merge commit of its own says so and claims nothing, because its commits cannot be told from the trunk's. The milestone comes from the canonical issue record, which is the one edge here that git does not hold, and `declared` says whether the project model has this id at all — a repository with no plan still gets the branches, and a typo still cannot read as work nobody did.

• query
• behaviorally_verified
• benchmark required
• cache disabled
• MCP tool majordomus_trace_issue

Query parameters

Try it

The port is whatever the server logged; 8741 is the one it asks for first. The values are the operation's first example.

curl -s "http://127.0.0.1:8741/api/v1/trace/issue?issue=I0001"

Responses

Every web surface, resolved

The web topology in route-precedence order, with each surface's mount, category, visibility, kind, producer, artifact, runtime feature and the provenance of every value a reader could be surprised by; and which ids are served, published and offered to a person. Answered from the resolution this process serves from, so it cannot disagree with what the router routes or what the home page lists.

• query
• behaviorally_verified
• benchmark required
• cache process (max_entries=2, ttl_seconds=5)
• MCP tool majordomus_web_surfaces
• MCP resource {"name": "web", "uri": "majordomus://web"}

No parameters.

Try it

The port is whatever the server logged; 8741 is the one it asks for first. The values are the operation's first example.

curl -s "http://127.0.0.1:8741/api/v1/web/surfaces"

Responses

The catalogue

Every operational moment this repository holds, narrowed by any of the facets the catalogue itself reports, with the audiences, the areas, the derived filters and the counts. The default is the public catalogue; pass status=any for the drafts too.

• query
• behaviorally_verified
• benchmark required
• cache process (max_entries=32)
• MCP tool majordomus_why
• MCP resource {"name": "why", "uri": "majordomus://why"}
• $ why list

Query parameters

Try it

The port is whatever the server logged; 8741 is the one it asks for first. The values are the operation's first example.

curl -s "http://127.0.0.1:8741/api/v1/why?audience=agency&q=context"

Responses

Operational areas

Every operational area the catalogue declares, each with the public moments that fall under it. Membership is derived from the moments and is never listed in an area's own file.

• query
• behaviorally_verified
• benchmark required
• cache process (max_entries=4)
• MCP tool majordomus_why_areas
• MCP resource {"name": "why-areas", "uri": "majordomus://why/areas"}
• $ why areas

No parameters.

Try it

The port is whatever the server logged; 8741 is the one it asks for first. The values are the operation's first example.

curl -s "http://127.0.0.1:8741/api/v1/why/areas"

Responses

Audiences

Every audience the catalogue declares, each with the public moments that name it. Membership is derived from the moments and is never listed in an audience's own file.

• query
• behaviorally_verified
• benchmark required
• cache process (max_entries=4)
• MCP tool majordomus_why_audiences
• MCP resource {"name": "why-audiences", "uri": "majordomus://why/audiences"}
• $ why audiences

No parameters.

Try it

The port is whatever the server logged; 8741 is the one it asks for first. The values are the operation's first example.

curl -s "http://127.0.0.1:8741/api/v1/why/audiences"

Responses

Diagnose a selection

What a reader's own symptoms imply: the moments the selection resolves to, the operational areas and audiences they weigh towards, and the capabilities, commands, claims, rules and use cases that answer them — each carrying the moments that produced it. Counting, not inference: there is no weighting and no percentage.

• query
• behaviorally_verified
• benchmark required
• cache process (max_entries=32)
• MCP tool majordomus_why_diagnose
• $ why diagnose

Query parameters

Try it

The port is whatever the server logged; 8741 is the one it asks for first. The values are the operation's first example.

curl -s "http://127.0.0.1:8741/api/v1/why/diagnose?signals=abandoned-worktree%2Capi-changed-contract-did-not%2Ccode-without-an-issue"

Responses

One moment

One operational moment in full: what it looks like, why it happens, what it costs, what this tool does about it, and every relation derived from its metadata — the responsibilities its claims belong to, the moments that name it, and the moments nearest it by shared area, audience and tag.

• query
• behaviorally_verified
• benchmark required
• cache process (max_entries=64)
• MCP tool majordomus_why_moment
• $ why show

Query parameters

Try it

The port is whatever the server logged; 8741 is the one it asks for first. The values are the operation's first example.

curl -s "http://127.0.0.1:8741/api/v1/why/moment?id=abandoned-worktree"

Responses

Validate the catalogue

Every finding over the catalogue: a reference that resolves to nothing, with the nearest candidate; a duplicate identity; a file name that disagrees with its id; and a public record that does not meet the floor its status promises. Errors make the catalogue invalid; warnings do not.

• query
• behaviorally_verified
• benchmark required
• cache process (max_entries=2)
• MCP tool majordomus_why_validate
• $ why validate

No parameters.

Try it

The port is whatever the server logged; 8741 is the one it asks for first. The values are the operation's first example.

curl -s "http://127.0.0.1:8741/api/v1/why/validate"

Responses

The whole topology

The repository, the container, the trunk and how it was decided, every registered worktree with its standing (primary, canonical, misplaced, detached, missing), its uncommitted work, its upstream distance and the issue its branch provably names, every local branch with or without a worktree and whether it is eligible for cleanup, every diagnostic with its code and remedy, and the tallies. Read from git on every call: the topology changes outside this process.

• query
• behaviorally_verified
• benchmark required
• cache disabled
• MCP tool majordomus_worktrees
• MCP resource {"name": "worktrees", "uri": "majordomus://worktrees"}
• $ worktree topology

No parameters.

Try it

The port is whatever the server logged; 8741 is the one it asks for first. The values are the operation's first example.

curl -s "http://127.0.0.1:8741/api/v1/worktrees"

Responses

One branch: where its worktree belongs and what is there

The canonical path of a branch, derived from its name alone, whether the branch exists, whether something occupies that path, the worktree holding the branch when one does, and what stands in the way of creating or migrating it. The answer for a branch that does not exist yet is the path `worktree create` would use.

• query
• behaviorally_verified
• benchmark required
• cache disabled
• MCP tool majordomus_worktree_inspect
• $ worktree inspect

Query parameters

Try it

The port is whatever the server logged; 8741 is the one it asks for first. The values are the operation's first example.

curl -s "http://127.0.0.1:8741/api/v1/worktrees/inspect?branch=feature%2Fexample"

Responses

What it would take to bring every worktree home

One step per misplaced worktree with a branch: where it is, where it belongs, how it would move, the uncommitted work that moves with it, and what blocks it; plus the exceptions the migration cannot address by design — detached worktrees, stale registrations, the primary checkout off the trunk — each with what a person does about it. Planning changes nothing; `majordomus worktree migrate` applies it with a fingerprint taken before and after every move.

• query
• behaviorally_verified
• benchmark required
• cache disabled
• MCP tool majordomus_worktree_migration_plan
• $ worktree migrate

No parameters.

Try it

The port is whatever the server logged; 8741 is the one it asks for first. The values are the operation's first example.

curl -s "http://127.0.0.1:8741/api/v1/worktrees/migration"

Responses

Where this is, and whether that is where it belongs

One worktree — the repository's own, or the one holding the directory the caller names — with its standing, its branch, its canonical path, its uncommitted work counted, whether it is where it belongs, and how many errors the whole topology carries. What an agent reads before it starts, and what the guard decides on.

• query
• behaviorally_verified
• benchmark required
• cache disabled
• MCP tool majordomus_worktree_status
• $ worktree status

Query parameters

Try it

The port is whatever the server logged; 8741 is the one it asks for first. The values are the operation's first example.

curl -s "http://127.0.0.1:8741/api/v1/worktrees/status?path=."

Responses

The active task of this checkout, when there is one.

Used by Closure Continuity

Who asked, and which peer they are when this process knows.

Used by ExecutionView

Who asked for the execution. Not an authorisation decision — this server authenticates nobody — but a fact worth carrying into the audit line and the UI.

• httpAn HTTP client, which includes the Cockpit.
• mcpAn MCP client attached to this process.
• cliThe command line of this process.
• internalThis executable's own tests and benchmarks.

Used by Actor

One architecture decision the feature names.

Used by ResolvedRefs

The input of peers.announce: what the calling peer is working on.

Used by peers.announce

What announce answers: the peer as recorded, and who else is on that ground.

Used by peers.announce

What a peer said it is working on.

Used by Announced Peer

A URI a query projects (majordomus://repository), answered: the same fields a client reads on an [ObjectView] where they apply, the answer itself as data, and the text resources/read returns for the URI.

Used by ResourceView

A processor architecture.

• x86_6464-bit x86, detected as `x86_64` or `amd64`.
• aarch6464-bit ARM, detected as `aarch64` or `arm64`.

Used by TargetView

Every area.

Used by why.areas

One area, with the membership nobody authored.

Used by AreaList CatalogueView

The encoding one generated artifact is written in.

• jsonA JSON document: pretty-printed, one trailing newline, provenance as members.
• yamlThe same document in the layer's YAML, provenance as a comment banner.
• markdownMarkdown for a reader, provenance as an HTML comment.
• textLine-oriented text another program reads: the shell tool's allow-lists, provenance as `#` comments.

Used by artifacts.list ArtifactView DocumentView

The answer of artifacts.list.

Used by artifacts.list

Where one generated file stands against the tree it is committed in.

• currentThe file is there and its bytes hash to what the manifest recorded.
• staleThe file is there and its bytes differ: it was edited, or the generator moved on.
• missingThe manifest names it and the tree does not have it.
• presentThe file is there and the manifest records no hash for it: the manifest's own encodings, which cannot hash themselves. `generate --check` compares them.

Used by ArtifactView

How many of each, so a caller needs no arithmetic of its own.

Used by ArtifactReport

One generated file, as the manifest declares it and as the tree has it.

Used by ArtifactReport

What is known about the contract one commit served.

• attributedExactly one issue's branches contain it.
• unattributedNo branch naming an issue contains it.
• ambiguousBranches naming more than one issue contain it.

Used by CommitAttribution

Every audience.

Used by why.audiences

One audience, with the membership nobody authored.

Used by AudienceList CatalogueView

Whether the capability is a benchmark target. Required is the default and the norm: every executable capability is timed directly and through every transport it is exposed on, with the cases its input type provides.

variant Timed directly and through every exposure; coverage fails without a case.

variant Not timed, for the typed reason; coverage reports it as waived, never as covered.

Used by Capability CapabilitySummary

One local branch, with or without a work tree.

Used by RepositoryTopology

One branch that names an issue, with the commits it holds.

Used by IssueTrace

The measured figures this deployment is held to. Each is written by the run that measured it; an absent one has not been measured yet and is not a licence.

Used by DeploymentView

What is shipped and what it is built from.

Used by DeploymentView

What this executable is: enough to tell two builds apart without asking a repository.

Used by distribution.build

Whether, and how, the executor keeps results of this capability. Cache lives in the executor and nowhere else, so MCP, HTTP and the command line share one; the key is the canonical id, the normalised input and the registry fingerprint, so a changed repository never answers from an old entry.

variant Every call runs the handler.

variant Results are kept in this process's memory, bounded, for equal inputs.

Used by Capability CapabilitySummary

The input of executions.cancel.

Used by executions.cancel

The answer of executions.cancel.

Used by executions.cancel

A JSON Schema with, when the type has one, a stable component name (the type's title).

Used by Capability

The canonical descriptor. Everything a projection may say about a capability is here.

Used by capabilities.describe

Where a capability means anything: the environment a caller must be in for it to answer at all.

The published site and the running server are genuinely different places. Without this on the model, every template grows its own idea of what works where — and the usual shape that takes is a condition on the page's own address, which is a rule hidden where nobody will find it and nothing can test it. This is the only thing a projection may ask.

It is classified rather than declared: the facts that decide it — what kind of thing this is and which transports it is projected through — are already on the descriptor, and asking each declaration to restate them would be the same knowledge written twice. [Availability::classify] is the one place the rule lives.

• alwaysTrue in every environment, a published page with no server included: the layer's own content, which a build renders and a process serves from the same index.
• runtimeA process must be running to answer: everything with a handler, whether it is reached over HTTP, over MCP or from the command line.
• build_timeA value captured when the site was generated, rendered afterwards as the capture it is. Nothing classifies to this yet; the static projection of the graph is what will declare it, and it is on the model so that a captured value can be labelled as captured instead of being shown as current.
• authenticatedA process must be running and the caller must be one it has authenticated. Nothing in this repository authenticates a caller yet; a surface that does will say so here rather than in the template that renders its link.

Used by Capability

A stable, globally meaningful identity: a namespace, a dot, and a local part. repository.info and objects.get for executables; <kind>.<identity> for a declarative object (rule.majordomus.scope-integrity@1, document.docs/CLI.md, policy..ai/repo/policy.yaml).

Grammar: the namespace matches [a-z][a-z0-9_-]*; the local part is non-empty and carries no whitespace or control character, any other Unicode included, because it is opaque: a path, a versioned identity, or a name, as the kind's identity rule produced it.

Used by Capability CapabilitySummary CommandProvenance

What a capability is. Three kinds exist because three semantics exist: something that is executed and changes nothing, something that is executed and changes this process's own memory, and something that is read. Nothing of any kind writes to the repository.

How long a call takes is not a kind. A read that walks every file of the layer is still a read, and the thing that makes it worth watching — that it reports as it goes and stops when it is asked to — is one property of its handler, declared with [crate::capability::Executable::cancellable] and carried on [ExecutionPolicy].

• queryExecutable and read-only: a typed handler, an input schema, an output schema.
• commandExecutable with an effect on this process's in-memory state and nowhere else (a peer announcing itself): a typed handler, bound to `POST` over HTTP, and announced to MCP clients as not read-only.
• resourceDeclarative content the repository holds: read as it is, never executed.

Used by AnswerView Capability CapabilitySummary

The answer of capabilities.list: the matching capabilities, summarised, and the registry counted.

Used by capabilities.list

Where a capability came from. Never an absolute path.

variant Written in Rust, in the named module of this executable. Written in Rust, composed in `builtin.rs`.

variant Read from the repository's layer.

Used by AnswerView Capability CapabilitySummary

One capability of a module the feature names, with the projections the registry declares for it.

Used by ModuleRef

One capability as a listing shows it: everything the descriptor says except its two schemas, which capabilities.describe answers for one capability. A listing of a repository's registry runs to hundreds of entries; their schemas would be megabytes of the same object view repeated.

Used by CapabilityList

Who a capability is for, and whether anything offers it.

Internal is a statement, not an omission: a capability nothing projects is invisible either way, and the difference between deliberate and forgotten is exactly what this records.

• publicOffered to anyone who can reach the process: an HTTP route or an MCP entry.
• developerOffered to whoever runs the executable, and to nobody over a network.
• internalProjected nowhere. It exists, it is listed as existing, and no surface offers it.

Used by Capability

The whole catalogue as a client reads it.

Used by why.list

One category of out: pathspecs and file-name patterns.

Used by Out

Which releases an unpinned installation may resolve to.

• stableResolved by `latest`.
• prereleasePublished, addressable by its exact tag, never resolved by default.

Used by ReleaseView

The state of one check in the installability report. Three states and no more: a check either holds, does not, or could not be made from what this process can see.

• okThe check holds.
• failedThe check does not hold, and the public installation is affected.
• unknownThe check could not be made here; it says nothing either way.

Used by InstallCheck

One claim the feature names, with the status the matrix gives it.

Used by ResolvedRefs

One path, judged.

Used by repository.scope_classify

How a capability appears on the command line: the words after majordomus.

Used by Exposure

What a client said about itself in initialize.

Used by Announced Peer

What this checkout's active task owes, and how much of it is still true.

A clone that has never run the lifecycle answers this too, and answers it as absence: present false, no task, and a finding saying so. "Nothing owed" and "nothing to owe it" are different facts, and a served instance must not report the second as the first.

use majordomus_cli::capability::builtin::obligations::Closure;
let fresh: Closure = serde_json::from_str(
    r#"{"present":false,"worktree":"/srv/clone","branch":"master","closed":false,
        "tallies":{},
        "findings":["no active task in this checkout (.ai/local/state/current.yaml); nothing owes anything here"]}"#,
)
.unwrap();
assert!(!fresh.present && !fresh.closed, "nothing that does not exist is closed");
assert!(fresh.task.is_none() && fresh.obligations.is_empty());
assert_eq!(fresh.findings.len(), 1, "absence is reported, not implied");

Used by obligations.closure

The whole matrix, with the findings and the debt beside it: one value that answers "where does each capability appear, and is any claim unmet".

Used by capabilities.projections

One area of the Cockpit the feature names.

Used by ResolvedRefs

One argument of a command, as the declaration gives it plus what can be inferred.