Skip to content

Features

Every capability of the product as one object of the layer: what it is made of, the interfaces it is exposed through, the rules that hold it and the guarantees behind it. Each card is a file; every mark beside it is derived.

The features, by domain

Each feature names the one domain it belongs to in its own file, and each card is that file. The words are editorial; every mark, count and link on a card is derived from what the file names.

Context

The context domain →

Every worker starts from what the repository already knows: the context that applies to its path, the handover the last session left, and the decisions already made.

Coordination

The coordination domain →

Every worker declares the paths it will touch, sees who else is working and where, and hears about a collision before it is committed.

  • Mesh

    feature status: stable

    Majordomus runtimes of one repository — on one machine or several — discover each other, link through a signed handshake, and share sessions, claims, handovers and reviews through one replicated journal that survives disconnects, crashes and partitions.

    9 claims, 9 naming their test · no use case linked

    Explore Mesh →

  • Models

    feature status: stable

    One declared catalogue of vendors and models — capabilities, context, lifecycle, no fabricated facts — and a routing answer that names why every candidate was chosen or excluded.

    3 claims, 3 naming their test · no use case linked

    Explore Models →

  • Reasoning

    feature status: stable

    Material uncertainty becomes an evidence-backed decision — reviewed by whichever optional advisors are available, decided locally when none are, and carried to the next session as a record.

    7 claims, 7 naming their test · no use case linked

    Explore Reasoning →

  • Planning

    feature status: stable

    An issue records what happened to it and the engine derives whether it is blocked, ready, active, verifying or done from the dependency graph, so the roadmap cannot disagree with the plan.

    15 claims, 14 naming their test · 3 use cases

    Explore Planning →

Governance

The governance domain →

The rules are written once, in the repository, projected into every tool's instructions, and a blocking rule stops the command instead of advising it.

  • Doctrine

    feature status: stable

    A rule is enforced when a validator decides it, a command runs it, a test proves it and CI blocks on it; anything less is documentation, and the tool knows the difference.

    12 claims, 12 naming their test · 4 use cases

    Explore Doctrine →

  • Policy

    feature status: stable

    Every provider the tool declares — an agent, an orchestrator that runs agents, any tool that reads AGENTS.md — gets the same rules from the same place, because their instruction files are generated from one policy and never written by hand; the providers are the table in docs/generated/providers.md.

    14 claims, 10 naming their test · 3 use cases

    Explore Policy →

  • Commits

    feature status: stable

    The commit message has one grammar, one policy and one verdict; the scope it is written under is learned from the repository's own history rather than kept in a table, and a message that does not satisfy the policy is refused while it is still being written.

    3 claims, 3 naming their test · 1 use case

    Explore Commits →

Evidence

The evidence domain →

A claim names the test that settles it, a recorded run is judged against the commit it ran at, and a claim with no recorded run says so.

  • Economics

    feature status: stable

    What a coding session consumes with Majordomus and without it, from matched runs judged by the same hidden tests, with every number labelled by how it was obtained and published only past a declared rule.

    3 claims, 2 naming their test · no use case linked

    Explore Economics →

  • Use cases

    feature status: stable

    What a person does with the tool is one file with a scenario the tool runs against itself; the page shows that execution, and a public command no use case runs is a gap the tool reports.

    4 claims, 4 naming their test · 1 use case

    Explore Use cases →

  • Evidence

    feature status: stable

    Every claim is joined to the execution recorded for its test — the outcome, the commit, the tree, the digest and the command that produces it again — and a run against this commit is never reported as the same thing as a run whose inputs merely have not changed.

    12 claims, 12 naming their test · no use case linked

    Explore Evidence →

  • Benchmarks

    feature status: stable

    Every externally callable operation is timed directly, over MCP and over HTTP, the denominator is generated from the registry, and a regression against the accepted baseline fails the check.

    6 claims, 6 naming their test · 1 use case

    Explore Benchmarks →

Completion

The completion domain →

Done is a contract the repository evaluates line by line. Work is not accepted while any line fails, and a refusal stays on the record.

  • Coverage

    feature status: stable

    One coverage measurement, test code out of the denominator, holds a crate floor, a floor over the session/continuity domain, and — the invariant of #214 — every executable line a change touches.

    1 claim, 1 naming its test · no use case linked

    Explore Coverage →

  • Finish contract

    feature status: stable

    A worker does not get to define its own successful completion: every line of the finish contract is printed pass or fail, the task is not accepted until all of them pass, and every time it was claimed done and was not is on the record.

    9 claims, 9 naming their test · 7 use cases

    Explore Finish contract →

  • CI

    feature status: stable

    A change runs the gates its paths can affect, every gate is the same script a person runs, and the public site is published only from a commit whose derived data proved current.

    6 claims, 6 naming their test · 1 use case

    Explore CI →

Surfaces

The surfaces domain →

One declaration in the repository becomes the command line, the HTTP API, MCP, the UI, the Cockpit, the documentation and this site, and a projection that disagrees with it fails the build.

  • Observatory

    feature status: stable

    One screen of the UI rotates eight scenes on a display nobody is sitting at, and every mark on it is a value a capability answered; a scene with nothing true to draw says why and is never drawn empty.

    1 claim, 1 naming its test · no use case linked

    Explore Observatory →

  • UI

    feature status: stable

    The shared server's primary surface answers how the delivery stands — health, releases, the roadmap, the work and its pull requests, the mesh, the evidence and the rules — and every value on it names the capability it was read from and every other surface that serves it.

    1 claim, 1 naming its test · no use case linked

    Explore UI →

  • Cockpit

    feature status: stable

    The same server that answers agents renders every capability, object, graph, worktree and health check as pages, with a runner generated from each capability's own schema; nothing on it is a second list.

    1 claim, 1 naming its test · no use case linked

    Explore Cockpit →

  • Install

    feature status: stable

    The installer downloads one archive for your machine, verifies its digest against the release metadata before unpacking anything, and installs atomically; no git, no Rust, no Node, no root.

    9 claims, 9 naming their test · 5 use cases

    Explore Install →

  • Why

    feature status: stable

    Every operational moment the tool exists for is one file with the signals that identify it and the mechanisms that answer it, and a reader's own symptoms resolve to a diagnosis by counting, not by inference.

    3 claims, 3 naming their test · 1 use case

    Explore Why →

One registry, every interface

A feature is on an interface because a capability module, a shell command or an object kind it names is projected there. The number under each is counted from that, at build time.

The product, composed

the features of the layer, the capability registry and the command registry

Select a node to see what it is and what it touches.

Every stable feature of the product, the capability modules, shell commands and object kinds it is made of, and the interfaces those project onto: the command line, the HTTP API, MCP, the Cockpit and the documentation. Every edge is derived from a feature's typed references and the registry's exposures; a feature that named something the repository does not have would fail validation rather than draw an edge to nothing.
The same graph as text — 153 nodes, 550 edges

  • majordomus adr command · conclude

    The repository's architecture decisions as objects: list, show, ask for the next free identity, propose one with provenance, and validate the whole set against this tree and every other ref.

    • exposed_through → surface:cli
    • feature:knowledge made_of → this

  • majordomus archive command · inspect

    Take a snapshot of the tracked tree that can be read, or checked, somewhere else.

    • exposed_through → surface:cli
    • feature:install made_of → this

  • majordomus bench command · inspect

    Time every public command of the registry, cold and warm, and compare with the baseline.

    • exposed_through → surface:cli
    • feature:benchmarks made_of → this

  • majordomus capture command · work

    Record the person's raw prompts from a provider hook as a record with its renderings, draw the episode boundary from the provider's own lifecycle hooks, install those hooks, reconcile and prune the archive, and report what each provider actually does here.

    • exposed_through → surface:cli
    • feature:continuity made_of → this
    • feature:provenance made_of → this

  • majordomus check command · verify

    Is the current task still consistent with its policy, its scope and this checkout?

    • exposed_through → surface:cli
    • feature:coordination made_of → this
    • feature:doctrine made_of → this
    • feature:finish-contract made_of → this

  • majordomus checkpoint command · work

    Record compact progress inside the active task, so the next worker does not start over.

    • exposed_through → surface:cli
    • feature:continuity made_of → this

  • majordomus context command · work

    What the next worker needs to know now, in authority order and within a budget.

    • exposed_through → surface:cli
    • feature:context made_of → this
    • feature:continuity made_of → this

  • majordomus decision command · work

    Record a decision that was made between real alternatives, with its reason, and read them back.

    • exposed_through → surface:cli
    • feature:knowledge made_of → this

  • majordomus doctor command · inspect

    It checks governance only: is Majordomus itself healthy, and is every enforcement it declares actually wired here?

    • exposed_through → surface:cli
    • feature:ci made_of → this
    • feature:declare-once made_of → this
    • feature:doctrine made_of → this
    • feature:policy made_of → this

  • majordomus doctrine command · inspect

    What rules are enforced, by what, and whether each one is actually wired.

    • exposed_through → surface:cli
    • feature:doctrine made_of → this

  • majordomus evidence command · work

    Record evidence against the active task: one obligation it declared, discharged, or one validation gate of the CI model that has reported — each as a ledger line carrying the hash of the files it was taken over.

    • exposed_through → surface:cli
    • feature:evidence made_of → this

  • majordomus finish command · conclude

    Evaluate the finish contract and refuse the outcome if any line of it is unmet.

    • exposed_through → surface:cli
    • feature:coordination made_of → this
    • feature:finish-contract made_of → this

  • majordomus handover command · conclude

    Write an append-only continuation record, and resolve the most relevant prior one.

    • exposed_through → surface:cli
    • feature:continuity made_of → this

  • majordomus history command · inspect

    Read the append-only ledger back, filtered by task, event or time.

    • exposed_through → surface:cli
    • feature:knowledge made_of → this
    • feature:provenance made_of → this

  • majordomus init command · setup

    Create the .ai/ layer in this repository, and refuse to overwrite an existing one.

    • exposed_through → surface:cli
    • feature:install made_of → this
    • feature:policy made_of → this

  • majordomus knowledge command · inspect

    The compiled index over what this repository states, and the candidate records it derives from what an episode did.

    • exposed_through → surface:cli
    • feature:knowledge made_of → this

  • majordomus migrate command · setup

    Move pre-.ai project data from .majordomus/ into .ai/, explicitly and backed up.

    • exposed_through → surface:cli
    • feature:install made_of → this

  • majordomus plan command · begin

    The milestone and issue model — validate it, read it, and move one issue through it.

    • exposed_through → surface:cli
    • feature:planning made_of → this

  • majordomus prompt command · work

    List, show and render the repository's own prompt assets, substituting known tokens only.

    • exposed_through → surface:cli
    • feature:continuity made_of → this

  • majordomus question command · work

    Open a question that blocks acceptance, resolve it, and list what is still open.

    • exposed_through → surface:cli
    • feature:finish-contract made_of → this
    • feature:knowledge made_of → this

  • majordomus recover command · setup

    Close episodes nobody ended, fold duplicate records, classify the stores' stray files.

    • exposed_through → surface:cli
    • feature:continuity made_of → this

  • majordomus rules command · inspect

    The effective rule set, vendored baseline plus project rules.

    • exposed_through → surface:cli
    • feature:doctrine made_of → this

  • majordomus search command · inspect

    Find a durable record without reading all of them, in authority order.

    • exposed_through → surface:cli
    • feature:knowledge made_of → this

  • majordomus session command · begin

    Open, inspect and close one execution episode.

    • exposed_through → surface:cli
    • feature:continuity made_of → this
    • feature:provenance made_of → this

  • majordomus skills command · work

    The repository's skills — provider-neutral procedures under the skills section — listed, shown and checked from the one catalogue every surface reads.

    • exposed_through → surface:cli
    • feature:skills made_of → this

  • majordomus start command · begin

    Begin one scoped task under a profile, and refuse while another is active.

    • exposed_through → surface:cli
    • feature:coordination made_of → this
    • feature:finish-contract made_of → this

  • majordomus update command · setup

    Regenerate every provider instruction file from the one policy, deterministically.

    • exposed_through → surface:cli
    • feature:declare-once made_of → this
    • feature:policy made_of → this

  • majordomus usecase command · verify

    The executable use cases: list, show, validate, run against the real tool, coverage, impact, scaffold.

    • exposed_through → surface:cli
    • feature:use-cases made_of → this

  • majordomus version command · inspect

    Print the version, without needing a repository or an installation.

    • exposed_through → surface:cli
    • feature:install made_of → this

  • majordomus watch command · inspect

    What has drifted since the last update — policy, projections, state, retention.

    • exposed_through → surface:cli
    • feature:ci made_of → this
    • feature:doctrine made_of → this
    • feature:provenance made_of → this

  • Benchmarks feature · stable

    The benchmark targets are derived from the registry, so a capability nothing times cannot be merged; runs are compared with a tracked baseline per platform under a regression policy; the shell tool reports where every command's time went; and derived state is computed once per state version rather than per call.

    • made_of → command:bench
    • related_to → feature:ci
    • related_to → feature:declare-once
    • made_of → module:perf
    • exposed_through → surface:docs
    • feature:ci related_to → this
    • feature:evidence related_to → this

  • CI feature · stable

    The gate model names every validation gate and which classes of paths select it; the workflow is a thin adapter over that plan; the publication path proves the committed derived data current by its input hash and renders it; and the tool supervises its own repository with its own hooks.

    • made_of → command:doctor
    • made_of → command:watch
    • related_to → feature:benchmarks
    • related_to → feature:doctrine
    • made_of → kind:derive-offload
    • exposed_through → surface:docs
    • feature:benchmarks related_to → this
    • feature:coverage related_to → this
    • feature:evidence related_to → this

  • Cockpit feature · featured

    At /cockpit the shared server lays out what a capability answered — the registry explorer, every object of the layer, the derived graphs, the directory contracts, the continuity of this checkout, the worktree topology, one health report naming the engine behind every check — and every page is complete HTML before any script runs.

    • related_to → feature:declare-once
    • related_to → feature:interfaces
    • made_of → module:dashboard
    • made_of → module:design
    • made_of → module:health
    • exposed_through → surface:docs
    • feature:declare-once related_to → this
    • feature:observatory related_to → this
    • feature:ui related_to → this

  • Commits feature · featured

    The same parse the changelog reads the history with decides whether a new message passes. The policy is data in the repository's own policy file, its subject width measured from the history rather than taken from the convention. The scope vocabulary is observed from at most 1500 commits of the log, so a subsystem committed today is in it today and a scope nobody uses sinks on its own. A plan over the working tree carries a fingerprint of repository, worktree, HEAD and change set, so a plan acted on after the tree moved is refused rather than applied - and a change set holding generated files is one commit, because only the last of several could carry current derived data.

    • related_to → feature:declare-once
    • related_to → feature:doctrine
    • related_to → feature:provenance
    • made_of → module:commit
    • exposed_through → surface:docs

  • Context feature · stable

    Every README under .ai/ is a context document with an identity, a scope, the providers and audience it addresses and how it composes with its ancestors; the repository scope declares what a worker reads and what it never reads; and the briefing a worker gets is assembled from durable state within a line budget with every exclusion named.

    • made_of → command:context
    • related_to → feature:continuity
    • related_to → feature:policy
    • made_of → kind:context
    • made_of → kind:scope
    • made_of → kind:workspace
    • made_of → module:devcontext
    • made_of → module:directories
    • made_of → module:pack
    • made_of → module:repository
    • exposed_through → surface:docs
    • feature:skills related_to → this

  • Continuity feature · featured

    Task state, checkpoints, handovers, decisions and open questions live in files outside every conversation; a session opens and closes into an immutable record; the person's prompts are captured by the provider's own hooks; and the next episode is briefed from those records, labelled by how far git has moved since.

    • made_of → command:capture
    • made_of → command:checkpoint
    • made_of → command:context
    • made_of → command:handover
    • made_of → command:prompt
    • made_of → command:recover
    • made_of → command:session
    • related_to → feature:coordination
    • related_to → feature:knowledge
    • related_to → feature:provenance
    • made_of → kind:prompt
    • made_of → kind:session
    • made_of → module:brief
    • made_of → module:continuity
    • made_of → module:episodes
    • made_of → module:lifecycle
    • made_of → module:recover
    • made_of → module:session_domain
    • exposed_through → surface:docs
    • feature:context related_to → this
    • feature:coordination related_to → this
    • feature:knowledge related_to → this
    • feature:provenance related_to → this
    • feature:worktrees related_to → this

  • Coordination feature · featured

    A task claims its scope before the first edit; check and finish refuse a file outside it and report another worktree's overlapping claim; every client of the shared server is a peer that can announce its intent and paths; and each branch has exactly one worktree, derived from git.

    • made_of → command:check
    • made_of → command:finish
    • made_of → command:start
    • related_to → feature:continuity
    • related_to → feature:worktrees
    • made_of → module:guard
    • made_of → module:integration
    • made_of → module:monitor
    • made_of → module:peers
    • made_of → module:server
    • made_of → module:worktree
    • exposed_through → surface:docs
    • feature:continuity related_to → this
    • feature:finish-contract related_to → this
    • feature:interfaces related_to → this
    • feature:mesh related_to → this
    • feature:worktrees related_to → this

  • Coverage feature · stable

    scripts/rust-coverage is the one coverage authority: a single cargo-llvm-cov export, test code excluded from both sides of every fraction, one rule for lines, functions and regions. Three questions read that judgment — a crate-wide line floor, a floor over the session/continuity domain, and the changed-code differential gate that refuses new debt while leaving untouched legacy debt alone. The differential intersects the export with the lines git says a change touched against the branch's merge-base, working tree included, and distinguishes PASS, FAIL, UNKNOWN and BLOCKED so a crashed tool or an unresolvable base is never a silent green.

    • related_to → feature:ci
    • related_to → feature:doctrine
    • made_of → module:gates
    • exposed_through → surface:docs

  • Declare once feature · featured

    One typed declaration per capability, one file per object of the layer; every interface, generated document and page is derived from the registry those declarations build, and a stale projection fails the build.

    • made_of → command:doctor
    • made_of → command:update
    • related_to → feature:cockpit
    • related_to → feature:interfaces
    • made_of → kind:claim
    • made_of → kind:command
    • made_of → kind:domain
    • made_of → kind:feature
    • made_of → module:artifacts
    • made_of → module:capabilities
    • made_of → module:product
    • made_of → module:quality
    • exposed_through → surface:docs
    • feature:benchmarks related_to → this
    • feature:cockpit related_to → this
    • feature:commit related_to → this
    • feature:evidence related_to → this
    • feature:interfaces related_to → this
    • feature:policy related_to → this
    • feature:skills related_to → this
    • feature:why related_to → this

  • Doctrine feature · featured

    Every rule is a portable Markdown object with front matter, and it is enforced in one of three declared modes: a validator the dispatcher runs, a gate or case that proves it, or a stated reason why no program can express it. Doctor walks the dispatch chain from the source, refusing a validator nobody declares and a declaration nothing runs; the proof graph walks the other relation, joining each rule to the tree and to the runs recorded against it, so that a rule naming a case which was deleted is reported as reading enforced rather than being it.

    • made_of → command:check
    • made_of → command:doctor
    • made_of → command:doctrine
    • made_of → command:rules
    • made_of → command:watch
    • related_to → feature:finish-contract
    • related_to → feature:policy
    • made_of → kind:rule
    • made_of → module:health
    • made_of → module:rules
    • made_of → module:shell
    • exposed_through → surface:docs
    • feature:ci related_to → this
    • feature:commit related_to → this
    • feature:coverage related_to → this
    • feature:finish-contract related_to → this
    • feature:knowledge related_to → this
    • feature:policy related_to → this
    • feature:use-cases related_to → this

  • Economics feature · stable

    A task corpus runs in a real harness twice — without Majordomus and with it — and the provider's usage, the gate verdicts and the context compiler's counted selection are recorded as raw facts; one calculator derives pairs, distributions, seeded bootstrap intervals and the one statement the methodology's publication rule allows, projected to the CLI, HTTP, OpenAPI, MCP, the Cockpit, a generated report and the site; economics check refuses any savings number typed by hand.

    • related_to → feature:evidence
    • related_to → feature:models
    • made_of → module:economics
    • exposed_through → surface:docs

  • Evidence feature · featured

    The claims matrix binds a claim to a test by path, and a path resolving says a file exists rather than that anything ran. The ledger records the latest execution of every test with its provenance; the join is derived on every read and answers, per claim, whether the repository can honestly call it proven, only-not-invalidated, stale, failing or never run.

    • made_of → command:evidence
    • related_to → feature:benchmarks
    • related_to → feature:ci
    • related_to → feature:declare-once
    • made_of → module:evidence
    • exposed_through → surface:docs
    • feature:economics related_to → this

  • Finish contract feature · featured

    A task starts with a declared scope and a profile; check reports whether the task is consistent with policy, scope and state; finish evaluates the policy's contract — scope respected, verification ran, state updated, no open blockers, a note present — and refuses with the reproducing command when any line fails.

    • made_of → command:check
    • made_of → command:finish
    • made_of → command:question
    • made_of → command:start
    • related_to → feature:coordination
    • related_to → feature:doctrine
    • made_of → module:gates
    • made_of → module:obligations
    • exposed_through → surface:docs
    • feature:doctrine related_to → this
    • feature:planning related_to → this

  • Install feature · stable

    One distribution model owns every platform, artifact name and URL; the installer, the release build matrix, the installation guide, the website's install block and the public release metadata are generated from it, and a release publishes an artifact for every supported target or it is not published.

    • made_of → command:archive
    • made_of → command:init
    • made_of → command:migrate
    • made_of → command:version
    • related_to → feature:policy
    • made_of → kind:distribution-model
    • made_of → kind:release-record
    • made_of → module:distribution
    • made_of → module:release
    • exposed_through → surface:docs

  • Interfaces feature · stable

    The Rust executable serves the layer over stdio MCP, MCP over HTTP, routes under /api/v1/, an OpenAPI document with a Swagger UI, and a command line, all derived from the capability registry, which names what each capability changes; one shared server per repository, and every attached client is a peer the others can see.

    • related_to → feature:coordination
    • related_to → feature:declare-once
    • made_of → module:commands
    • made_of → module:editors
    • made_of → module:entity
    • made_of → module:environment
    • made_of → module:executions
    • made_of → module:mcp
    • made_of → module:objects
    • made_of → module:repository
    • made_of → module:web
    • exposed_through → surface:docs
    • feature:cockpit related_to → this
    • feature:declare-once related_to → this
    • feature:ui related_to → this

  • Knowledge feature · featured

    Decisions are recorded with their reason and their task, open questions block acceptance until resolved, architecture decision records carry typed references to the rules, claims, files and tests they put in force, and the graph of all of it is derived from those references rather than drawn.

    • made_of → command:adr
    • made_of → command:decision
    • made_of → command:history
    • made_of → command:knowledge
    • made_of → command:question
    • made_of → command:search
    • related_to → feature:continuity
    • related_to → feature:doctrine
    • made_of → kind:adr
    • made_of → kind:document
    • made_of → kind:knowledge
    • made_of → module:graph
    • made_of → module:knowledge_base
    • exposed_through → surface:docs
    • feature:continuity related_to → this
    • feature:provenance related_to → this

  • Mesh feature · featured

    Each runtime is a key-authenticated participant; discovery (multicast, broadcast, rendezvous, seeds) only finds candidates, and a signed handshake admits a link only for the same repository, a compatible protocol and a trusted key. Linked runtimes replicate one signed event journal every heartbeat and fold it into the same state everywhere, so an exclusive claim on one machine refuses an overlapping claim on another, a handover published on one is consumed on another, and a runtime that crashes expires everywhere on its own. The CLI, HTTP, OpenAPI, MCP and the Cockpit render the same state, and every guarantee is held by tests over real processes and a container lab on a real network.

    • related_to → feature:coordination
    • made_of → kind:mesh-declaration
    • made_of → module:mesh
    • exposed_through → surface:docs
    • feature:models related_to → this
    • feature:reasoning related_to → this

  • Models feature · featured

    share/models.yaml declares vendors and models in one place, in routing's preference order, with provenance stated and pricing deliberately absent; models.list and models.route project the catalogue and its explainable routing to the CLI, HTTP, OpenAPI, MCP and the Cockpit, credential presence is reported without any value being read, and nothing anywhere calls a model — the crate's no-network boundary stands.

    • related_to → feature:mesh
    • made_of → module:models
    • exposed_through → surface:docs
    • feature:economics related_to → this
    • feature:reasoning related_to → this

  • Observatory feature · featured

    At /ui/observatory, and at /ui/kiosk filling the window unattended, the shared server draws the machines of the mesh and their runtimes, the newest events of its journal, the milestones of the plan, the dimensions of health, the published releases and the sessions cooperating, from the same capabilities the other screens read. The published site carries it as a snapshot that says which commit it was read at.

    • related_to → feature:cockpit
    • related_to → feature:ui
    • made_of → kind:deployment
    • made_of → module:distribution
    • made_of → module:economics
    • made_of → module:health
    • made_of → module:mesh
    • made_of → module:observatory
    • made_of → module:plan
    • made_of → module:release
    • made_of → module:repository
    • made_of → module:served
    • exposed_through → surface:docs

  • Planning feature · stable

    Milestones are outcome specifications and issues are execution contracts, one YAML file each; the dependency graph decides execution waves and the next ready issue; a milestone whose dependencies are not accepted is blocked whatever its own issues say; and the GitHub projection is rendered offline from the same model.

    • made_of → command:plan
    • related_to → feature:finish-contract
    • related_to → feature:worktrees
    • made_of → kind:critique
    • made_of → kind:gap
    • made_of → kind:intent
    • made_of → kind:issue
    • made_of → kind:milestone
    • made_of → module:devtask
    • made_of → module:intent_realization
    • made_of → module:intents
    • made_of → module:plan
    • made_of → module:trace
    • exposed_through → surface:docs

  • Policy feature · stable

    A provider-neutral policy and four execution profiles are the one source; majordomus update renders each provider bootstrap from its template, stamps it with the policy hash and the hash of its own content, and doctor fails a bootstrap that was hand-edited, that carries a rule corpus of its own, or that exceeds the always-loaded budget.

    • made_of → command:doctor
    • made_of → command:init
    • made_of → command:update
    • related_to → feature:declare-once
    • related_to → feature:doctrine
    • made_of → kind:policy
    • made_of → kind:profile
    • exposed_through → surface:docs
    • feature:context related_to → this
    • feature:doctrine related_to → this
    • feature:install related_to → this

  • Provenance feature · featured

    The ledger records every durable event with its task and its head; identity fields on any record are computed from git and refused when authored; a closed session is an immutable record of what one episode produced; the person's prompts are captured by the provider's hooks; and retention is capped by policy rather than by forgetting.

    • made_of → command:capture
    • made_of → command:history
    • made_of → command:session
    • made_of → command:watch
    • related_to → feature:continuity
    • related_to → feature:knowledge
    • made_of → kind:session
    • exposed_through → surface:docs
    • feature:commit related_to → this
    • feature:continuity related_to → this

  • Reasoning feature · featured

    share/advisors.yaml declares advisory roles by reference to the provider table and the model catalogue; availability is derived from presence and recorded outcomes, with no network; a pure policy plans review by capability and treats no advisor as a structured local review; one writer records assessments, consultations, disagreements settled by experiment, conclusions with computed review counts, and validations; and the state reaches the command line, HTTP, MCP, the Cockpit, the environment banner, doctor, the context briefing and the derived handover.

    • related_to → feature:mesh
    • related_to → feature:models
    • made_of → module:reasoning
    • exposed_through → surface:docs

  • Skills feature · stable

    A skill is a provider-neutral procedure for one bounded kind of work, front matter under a schema over a body with a purpose, a procedure and an output contract; the source class discovers it, skills check holds every one to its contract, and nothing loads a skill unless the task is about it.

    • made_of → command:skills
    • related_to → feature:context
    • related_to → feature:declare-once
    • made_of → kind:skill
    • made_of → module:skills
    • exposed_through → surface:docs

  • UI feature · featured

    At /ui the shared server lays out the delivery in the project's own words, composed only of what capabilities answered, asked together so the first screen paints in the time of its slowest source; a panel whose source is slow arrives on its own route, and the Cockpit beneath it is one click away for the source of any value.

    • related_to → feature:cockpit
    • related_to → feature:interfaces
    • made_of → module:capabilities
    • made_of → module:commands
    • made_of → module:delivery
    • made_of → module:deploy
    • made_of → module:distribution
    • made_of → module:evidence
    • made_of → module:executions
    • made_of → module:gates
    • made_of → module:health
    • made_of → module:integration
    • made_of → module:intents
    • made_of → module:mesh
    • made_of → module:objects
    • made_of → module:plan
    • made_of → module:release
    • made_of → module:repository
    • made_of → module:rules
    • made_of → module:web
    • exposed_through → surface:docs
    • feature:observatory related_to → this

  • Use cases feature · stable

    A use case names the commands, rules, claims and applications it relies on and carries a scenario as data; usecase run executes it in a disposable repository and records normalised evidence; maturity is observed from the evidence; coverage of commands, guaranteed claims and MCP tools is tallied and the policy says which gaps fail.

    • made_of → command:usecase
    • related_to → feature:doctrine
    • related_to → feature:why
    • made_of → kind:application
    • made_of → kind:taxonomy
    • made_of → kind:use-case
    • exposed_through → surface:docs
    • feature:why related_to → this

  • Why feature · stable

    Moments, audiences and areas are kinds of the layer; a moment names the commands, capabilities, claims, rules and use cases that answer it, each reference validated; the catalogue, the questionnaire, the diagnosis and every page and filter are derived from those files.

    • related_to → feature:declare-once
    • related_to → feature:use-cases
    • made_of → kind:area
    • made_of → kind:audience
    • made_of → kind:moment
    • made_of → module:why
    • exposed_through → surface:docs
    • feature:use-cases related_to → this

  • Worktrees feature · featured

    The container is the primary checkout's sibling named with -wt, a branch's worktree is the branch name under it with its hierarchy kept, both derived from git identity and registered nowhere; a pre-commit guard refuses a feature branch committed from anywhere else, and migration moves a misplaced worktree with its uncommitted work, fingerprinted before and after.

    • related_to → feature:continuity
    • related_to → feature:coordination
    • made_of → module:convergence
    • made_of → module:worktree
    • exposed_through → surface:docs
    • feature:coordination related_to → this
    • feature:planning related_to → this

  • adr kind

    166 object(s) of the layer

    • exposed_through → surface:cockpit
    • exposed_through → surface:mcp
    • feature:knowledge made_of → this

  • application kind

    5 object(s) of the layer

    • exposed_through → surface:cockpit
    • exposed_through → surface:mcp
    • feature:use-cases made_of → this

  • area kind

    9 object(s) of the layer

    • exposed_through → surface:cockpit
    • exposed_through → surface:mcp
    • feature:why made_of → this

  • audience kind

    8 object(s) of the layer

    • exposed_through → surface:cockpit
    • exposed_through → surface:mcp
    • feature:why made_of → this

  • claim kind

    250 object(s) of the layer

    • exposed_through → surface:cockpit
    • exposed_through → surface:mcp
    • feature:declare-once made_of → this

  • command kind

    31 object(s) of the layer

    • exposed_through → surface:cockpit
    • exposed_through → surface:mcp
    • feature:declare-once made_of → this

  • context kind

    39 object(s) of the layer

    • exposed_through → surface:cockpit
    • exposed_through → surface:mcp
    • feature:context made_of → this

  • critique kind

    37 object(s) of the layer

    • exposed_through → surface:cockpit
    • exposed_through → surface:mcp
    • feature:planning made_of → this

  • deployment kind

    1 object(s) of the layer

    • exposed_through → surface:cockpit
    • exposed_through → surface:mcp
    • feature:observatory made_of → this

  • derive-offload kind

    1 object(s) of the layer

    • exposed_through → surface:cockpit
    • exposed_through → surface:mcp
    • feature:ci made_of → this

  • distribution-model kind

    1 object(s) of the layer

    • exposed_through → surface:cockpit
    • exposed_through → surface:mcp
    • feature:install made_of → this

  • document kind

    353 object(s) of the layer

    • exposed_through → surface:cockpit
    • exposed_through → surface:mcp
    • feature:knowledge made_of → this

  • domain kind

    6 object(s) of the layer

    • exposed_through → surface:cockpit
    • exposed_through → surface:mcp
    • feature:declare-once made_of → this

  • feature kind

    29 object(s) of the layer

    • exposed_through → surface:cockpit
    • exposed_through → surface:mcp
    • feature:declare-once made_of → this

  • gap kind

    5 object(s) of the layer

    • exposed_through → surface:cockpit
    • exposed_through → surface:mcp
    • feature:planning made_of → this

  • intent kind

    43 object(s) of the layer

    • exposed_through → surface:cockpit
    • exposed_through → surface:mcp
    • feature:planning made_of → this

  • issue kind

    1027 object(s) of the layer

    • exposed_through → surface:cockpit
    • exposed_through → surface:mcp
    • feature:planning made_of → this

  • knowledge kind

    58 object(s) of the layer

    • exposed_through → surface:cockpit
    • exposed_through → surface:mcp
    • feature:knowledge made_of → this

  • mesh-declaration kind

    1 object(s) of the layer

    • exposed_through → surface:cockpit
    • exposed_through → surface:mcp
    • feature:mesh made_of → this

  • milestone kind

    111 object(s) of the layer

    • exposed_through → surface:cockpit
    • exposed_through → surface:mcp
    • feature:planning made_of → this

  • moment kind

    38 object(s) of the layer

    • exposed_through → surface:cockpit
    • exposed_through → surface:mcp
    • feature:why made_of → this

  • policy kind

    1 object(s) of the layer

    • exposed_through → surface:cockpit
    • exposed_through → surface:mcp
    • feature:policy made_of → this

  • profile kind

    4 object(s) of the layer

    • exposed_through → surface:cockpit
    • exposed_through → surface:mcp
    • feature:policy made_of → this

  • prompt kind

    5 object(s) of the layer

    • exposed_through → surface:cockpit
    • exposed_through → surface:mcp
    • feature:continuity made_of → this

  • release-record kind

    36 object(s) of the layer

    • exposed_through → surface:cockpit
    • exposed_through → surface:mcp
    • feature:install made_of → this

  • rule kind

    190 object(s) of the layer

    • exposed_through → surface:cockpit
    • exposed_through → surface:mcp
    • feature:doctrine made_of → this

  • scope kind

    1 object(s) of the layer

    • exposed_through → surface:cockpit
    • exposed_through → surface:mcp
    • feature:context made_of → this

  • session kind

    91 object(s) of the layer

    • exposed_through → surface:cockpit
    • exposed_through → surface:mcp
    • feature:continuity made_of → this
    • feature:provenance made_of → this

  • skill kind

    8 object(s) of the layer

    • exposed_through → surface:cockpit
    • exposed_through → surface:mcp
    • feature:skills made_of → this

  • taxonomy kind

    10 object(s) of the layer

    • exposed_through → surface:cockpit
    • exposed_through → surface:mcp
    • feature:use-cases made_of → this

  • use-case kind

    49 object(s) of the layer

    • exposed_through → surface:cockpit
    • exposed_through → surface:mcp
    • feature:use-cases made_of → this

  • workspace kind

    1 object(s) of the layer

    • exposed_through → surface:cockpit
    • exposed_through → surface:mcp
    • feature:context made_of → this

  • artifacts module · behaviorally_verified

    Generated artifacts

    • exposed_through → surface:api
    • exposed_through → surface:cockpit
    • exposed_through → surface:mcp
    • feature:declare-once made_of → this

  • brief module · behaviorally_verified

    The session brief

    • exposed_through → surface:api
    • exposed_through → surface:cli
    • exposed_through → surface:cockpit
    • exposed_through → surface:mcp
    • feature:continuity made_of → this

  • capabilities module · behaviorally_verified

    Capabilities

    • exposed_through → surface:api
    • exposed_through → surface:cli
    • exposed_through → surface:cockpit
    • exposed_through → surface:mcp
    • feature:declare-once made_of → this
    • feature:ui made_of → this

  • commands module · implemented

    Command graph

    • exposed_through → surface:api
    • exposed_through → surface:cockpit
    • exposed_through → surface:mcp
    • feature:interfaces made_of → this
    • feature:ui made_of → this

  • commit module · behaviorally_verified

    Commit

    • exposed_through → surface:api
    • exposed_through → surface:cli
    • exposed_through → surface:cockpit
    • exposed_through → surface:mcp
    • feature:commit made_of → this

  • continuity module · behaviorally_verified

    Continuity

    • exposed_through → surface:api
    • exposed_through → surface:cli
    • exposed_through → surface:cockpit
    • exposed_through → surface:mcp
    • feature:continuity made_of → this

  • convergence module · behaviorally_verified

    Convergence

    • exposed_through → surface:api
    • exposed_through → surface:cli
    • exposed_through → surface:cockpit
    • exposed_through → surface:mcp
    • feature:worktrees made_of → this

  • dashboard module · behaviorally_verified

    Dashboards

    • exposed_through → surface:api
    • exposed_through → surface:cli
    • exposed_through → surface:cockpit
    • exposed_through → surface:mcp
    • feature:cockpit made_of → this

  • delivery module · experimental

    Delivery

    • exposed_through → surface:api
    • exposed_through → surface:cli
    • exposed_through → surface:cockpit
    • exposed_through → surface:mcp
    • feature:ui made_of → this

  • deploy module · behaviorally_verified

    Deployment

    • exposed_through → surface:api
    • exposed_through → surface:cli
    • exposed_through → surface:cockpit
    • exposed_through → surface:mcp
    • feature:ui made_of → this

  • design module · behaviorally_verified

    Design system

    • exposed_through → surface:api
    • exposed_through → surface:cockpit
    • exposed_through → surface:mcp
    • feature:cockpit made_of → this

  • devcontext module · behaviorally_verified

    Development context

    • exposed_through → surface:api
    • exposed_through → surface:cli
    • exposed_through → surface:cockpit
    • exposed_through → surface:mcp
    • feature:context made_of → this

  • devtask module · behaviorally_verified

    Executable development scopes

    • exposed_through → surface:api
    • exposed_through → surface:cli
    • exposed_through → surface:cockpit
    • exposed_through → surface:mcp
    • feature:planning made_of → this

  • directories module · behaviorally_verified

    Directory contracts

    • exposed_through → surface:api
    • exposed_through → surface:cockpit
    • exposed_through → surface:mcp
    • feature:context made_of → this

  • distribution module · behaviorally_verified

    Distribution

    • exposed_through → surface:api
    • exposed_through → surface:cli
    • exposed_through → surface:cockpit
    • exposed_through → surface:mcp
    • feature:install made_of → this
    • feature:observatory made_of → this
    • feature:ui made_of → this

  • economics module · behaviorally_verified

    Token economics

    • exposed_through → surface:api
    • exposed_through → surface:cli
    • exposed_through → surface:cockpit
    • exposed_through → surface:mcp
    • feature:economics made_of → this
    • feature:observatory made_of → this

  • editors module · behaviorally_verified

    Editor and agent projections

    • exposed_through → surface:api
    • exposed_through → surface:cockpit
    • exposed_through → surface:mcp
    • feature:interfaces made_of → this

  • entity module · implemented

    Entities

    • exposed_through → surface:api
    • exposed_through → surface:cli
    • exposed_through → surface:cockpit
    • exposed_through → surface:mcp
    • feature:interfaces made_of → this

  • environment module · behaviorally_verified

    Repository environment

    • exposed_through → surface:api
    • exposed_through → surface:cockpit
    • exposed_through → surface:mcp
    • feature:interfaces made_of → this

  • episodes module · behaviorally_verified

    Episodes

    • exposed_through → surface:api
    • exposed_through → surface:cockpit
    • exposed_through → surface:mcp
    • feature:continuity made_of → this

  • evidence module · behaviorally_verified

    Evidence

    • exposed_through → surface:api
    • exposed_through → surface:cli
    • exposed_through → surface:cockpit
    • exposed_through → surface:mcp
    • feature:evidence made_of → this
    • feature:ui made_of → this

  • executions module · behaviorally_verified

    Executions

    • exposed_through → surface:api
    • exposed_through → surface:cli
    • exposed_through → surface:cockpit
    • exposed_through → surface:mcp
    • feature:interfaces made_of → this
    • feature:ui made_of → this

  • gates module · behaviorally_verified

    Completion gates

    • exposed_through → surface:api
    • exposed_through → surface:cockpit
    • exposed_through → surface:mcp
    • feature:coverage made_of → this
    • feature:finish-contract made_of → this
    • feature:ui made_of → this

  • graph module · behaviorally_verified

    Graphs

    • exposed_through → surface:api
    • exposed_through → surface:cockpit
    • exposed_through → surface:mcp
    • feature:knowledge made_of → this

  • guard module · experimental

    Edit guard

    • exposed_through → surface:api
    • exposed_through → surface:cockpit
    • exposed_through → surface:mcp
    • feature:coordination made_of → this

  • health module · behaviorally_verified

    Health

    • exposed_through → surface:api
    • exposed_through → surface:cockpit
    • exposed_through → surface:mcp
    • feature:cockpit made_of → this
    • feature:doctrine made_of → this
    • feature:observatory made_of → this
    • feature:ui made_of → this

  • integration module · experimental

    Pull-request integration

    • exposed_through → surface:api
    • exposed_through → surface:cli
    • exposed_through → surface:cockpit
    • exposed_through → surface:mcp
    • feature:coordination made_of → this
    • feature:ui made_of → this

  • intent_realization module · behaviorally_verified

    Intent realization

    • exposed_through → surface:api
    • exposed_through → surface:cli
    • exposed_through → surface:cockpit
    • exposed_through → surface:mcp
    • feature:planning made_of → this

  • intents module · behaviorally_verified

    Intent

    • exposed_through → surface:api
    • exposed_through → surface:cli
    • exposed_through → surface:cockpit
    • exposed_through → surface:mcp
    • feature:planning made_of → this
    • feature:ui made_of → this

  • knowledge_base module · behaviorally_verified

    Knowledge base

    • exposed_through → surface:api
    • exposed_through → surface:cli
    • exposed_through → surface:cockpit
    • exposed_through → surface:mcp
    • feature:knowledge made_of → this

  • lifecycle module · behaviorally_verified

    Session lifecycle

    • exposed_through → surface:api
    • exposed_through → surface:cockpit
    • exposed_through → surface:mcp
    • feature:continuity made_of → this

  • mcp module · experimental

    MCP projection

    • exposed_through → surface:api
    • exposed_through → surface:cockpit
    • exposed_through → surface:mcp
    • feature:interfaces made_of → this

  • mesh module · experimental

    Mesh

    • exposed_through → surface:api
    • exposed_through → surface:cli
    • exposed_through → surface:cockpit
    • exposed_through → surface:mcp
    • feature:mesh made_of → this
    • feature:observatory made_of → this
    • feature:ui made_of → this

  • models module · experimental

    Models

    • exposed_through → surface:api
    • exposed_through → surface:cli
    • exposed_through → surface:cockpit
    • exposed_through → surface:mcp
    • feature:models made_of → this

  • monitor module · experimental

    The monitor

    • exposed_through → surface:api
    • exposed_through → surface:cockpit
    • exposed_through → surface:mcp
    • feature:coordination made_of → this

  • objects module · behaviorally_verified

    Objects

    • exposed_through → surface:api
    • exposed_through → surface:cockpit
    • exposed_through → surface:mcp
    • feature:interfaces made_of → this
    • feature:ui made_of → this

  • obligations module · behaviorally_verified

    Obligations

    • exposed_through → surface:api
    • exposed_through → surface:cockpit
    • exposed_through → surface:mcp
    • feature:finish-contract made_of → this

  • observatory module · behaviorally_verified

    Observatory

    • exposed_through → surface:api
    • exposed_through → surface:cockpit
    • exposed_through → surface:mcp
    • feature:observatory made_of → this

  • pack module · behaviorally_verified

    Source pack

    • exposed_through → surface:api
    • exposed_through → surface:cli
    • exposed_through → surface:cockpit
    • exposed_through → surface:mcp
    • feature:context made_of → this

  • peers module · behaviorally_verified

    Peers

    • exposed_through → surface:api
    • exposed_through → surface:cockpit
    • exposed_through → surface:mcp
    • feature:coordination made_of → this

  • perf module · behaviorally_verified

    Performance

    • exposed_through → surface:api
    • exposed_through → surface:cockpit
    • exposed_through → surface:mcp
    • feature:benchmarks made_of → this

  • plan module · behaviorally_verified

    The plan and its derivations

    • exposed_through → surface:api
    • exposed_through → surface:cli
    • exposed_through → surface:cockpit
    • exposed_through → surface:mcp
    • feature:observatory made_of → this
    • feature:planning made_of → this
    • feature:ui made_of → this

  • product module · behaviorally_verified

    Product

    • exposed_through → surface:api
    • exposed_through → surface:cli
    • exposed_through → surface:cockpit
    • exposed_through → surface:mcp
    • feature:declare-once made_of → this

  • quality module · behaviorally_verified

    Public API quality

    • exposed_through → surface:api
    • exposed_through → surface:cli
    • exposed_through → surface:cockpit
    • exposed_through → surface:mcp
    • feature:declare-once made_of → this

  • reasoning module · experimental

    Reasoning

    • exposed_through → surface:api
    • exposed_through → surface:cli
    • exposed_through → surface:cockpit
    • exposed_through → surface:mcp
    • feature:reasoning made_of → this

  • recover module · behaviorally_verified

    Recovery of the record stores

    • exposed_through → surface:api
    • exposed_through → surface:cockpit
    • exposed_through → surface:mcp
    • feature:continuity made_of → this

  • release module · implemented

    Release

    • exposed_through → surface:api
    • exposed_through → surface:cockpit
    • exposed_through → surface:mcp
    • feature:install made_of → this
    • feature:observatory made_of → this
    • feature:ui made_of → this

  • repository module · behaviorally_verified

    Repository

    • exposed_through → surface:api
    • exposed_through → surface:cli
    • exposed_through → surface:cockpit
    • exposed_through → surface:mcp
    • feature:context made_of → this
    • feature:interfaces made_of → this
    • feature:observatory made_of → this
    • feature:ui made_of → this

  • rules module · behaviorally_verified

    Rules

    • exposed_through → surface:api
    • exposed_through → surface:cli
    • exposed_through → surface:cockpit
    • exposed_through → surface:mcp
    • feature:doctrine made_of → this
    • feature:ui made_of → this

  • served module · behaviorally_verified

    Served deployments

    • exposed_through → surface:api
    • exposed_through → surface:cli
    • exposed_through → surface:cockpit
    • exposed_through → surface:mcp
    • feature:observatory made_of → this

  • server module · behaviorally_verified

    Server

    • exposed_through → surface:api
    • exposed_through → surface:cli
    • exposed_through → surface:cockpit
    • exposed_through → surface:mcp
    • feature:coordination made_of → this

  • session_domain module · behaviorally_verified

    The session domain

    • exposed_through → surface:api
    • exposed_through → surface:cockpit
    • exposed_through → surface:mcp
    • feature:continuity made_of → this

  • shell module · behaviorally_verified

    Shell automation

    • exposed_through → surface:api
    • exposed_through → surface:cli
    • exposed_through → surface:cockpit
    • exposed_through → surface:mcp
    • feature:doctrine made_of → this

  • skills module · behaviorally_verified

    Skills

    • exposed_through → surface:api
    • exposed_through → surface:cli
    • exposed_through → surface:cockpit
    • exposed_through → surface:mcp
    • feature:skills made_of → this

  • trace module · behaviorally_verified

    Traceability

    • exposed_through → surface:api
    • exposed_through → surface:cockpit
    • exposed_through → surface:mcp
    • feature:planning made_of → this

  • web module · behaviorally_verified

    Web surfaces

    • exposed_through → surface:api
    • exposed_through → surface:cockpit
    • exposed_through → surface:mcp
    • feature:interfaces made_of → this
    • feature:ui made_of → this

  • why module · behaviorally_verified

    Why

    • exposed_through → surface:api
    • exposed_through → surface:cli
    • exposed_through → surface:cockpit
    • exposed_through → surface:mcp
    • feature:why made_of → this

  • worktree module · behaviorally_verified

    Worktree topology

    • exposed_through → surface:api
    • exposed_through → surface:cli
    • exposed_through → surface:cockpit
    • exposed_through → surface:mcp
    • feature:coordination made_of → this
    • feature:worktrees made_of → this

  • HTTP API surface

    • module:artifacts exposed_through → this
    • module:brief exposed_through → this
    • module:capabilities exposed_through → this
    • module:commands exposed_through → this
    • module:commit exposed_through → this
    • module:continuity exposed_through → this
    • module:convergence exposed_through → this
    • module:dashboard exposed_through → this
    • module:delivery exposed_through → this
    • module:deploy exposed_through → this
    • module:design exposed_through → this
    • module:devcontext exposed_through → this
    • module:devtask exposed_through → this
    • module:directories exposed_through → this
    • module:distribution exposed_through → this
    • module:economics exposed_through → this
    • module:editors exposed_through → this
    • module:entity exposed_through → this
    • module:environment exposed_through → this
    • module:episodes exposed_through → this
    • module:evidence exposed_through → this
    • module:executions exposed_through → this
    • module:gates exposed_through → this
    • module:graph exposed_through → this
    • module:guard exposed_through → this
    • module:health exposed_through → this
    • module:integration exposed_through → this
    • module:intent_realization exposed_through → this
    • module:intents exposed_through → this
    • module:knowledge_base exposed_through → this
    • module:lifecycle exposed_through → this
    • module:mcp exposed_through → this
    • module:mesh exposed_through → this
    • module:models exposed_through → this
    • module:monitor exposed_through → this
    • module:objects exposed_through → this
    • module:obligations exposed_through → this
    • module:observatory exposed_through → this
    • module:pack exposed_through → this
    • module:peers exposed_through → this
    • module:perf exposed_through → this
    • module:plan exposed_through → this
    • module:product exposed_through → this
    • module:quality exposed_through → this
    • module:reasoning exposed_through → this
    • module:recover exposed_through → this
    • module:release exposed_through → this
    • module:repository exposed_through → this
    • module:rules exposed_through → this
    • module:served exposed_through → this
    • module:server exposed_through → this
    • module:session_domain exposed_through → this
    • module:shell exposed_through → this
    • module:skills exposed_through → this
    • module:trace exposed_through → this
    • module:web exposed_through → this
    • module:why exposed_through → this
    • module:worktree exposed_through → this

  • Command line surface

    • command:adr exposed_through → this
    • command:archive exposed_through → this
    • command:bench exposed_through → this
    • command:capture exposed_through → this
    • command:check exposed_through → this
    • command:checkpoint exposed_through → this
    • command:context exposed_through → this
    • command:decision exposed_through → this
    • command:doctor exposed_through → this
    • command:doctrine exposed_through → this
    • command:evidence exposed_through → this
    • command:finish exposed_through → this
    • command:handover exposed_through → this
    • command:history exposed_through → this
    • command:init exposed_through → this
    • command:knowledge exposed_through → this
    • command:migrate exposed_through → this
    • command:plan exposed_through → this
    • command:prompt exposed_through → this
    • command:question exposed_through → this
    • command:recover exposed_through → this
    • command:rules exposed_through → this
    • command:search exposed_through → this
    • command:session exposed_through → this
    • command:skills exposed_through → this
    • command:start exposed_through → this
    • command:update exposed_through → this
    • command:usecase exposed_through → this
    • command:version exposed_through → this
    • command:watch exposed_through → this
    • module:brief exposed_through → this
    • module:capabilities exposed_through → this
    • module:commit exposed_through → this
    • module:continuity exposed_through → this
    • module:convergence exposed_through → this
    • module:dashboard exposed_through → this
    • module:delivery exposed_through → this
    • module:deploy exposed_through → this
    • module:devcontext exposed_through → this
    • module:devtask exposed_through → this
    • module:distribution exposed_through → this
    • module:economics exposed_through → this
    • module:entity exposed_through → this
    • module:evidence exposed_through → this
    • module:executions exposed_through → this
    • module:integration exposed_through → this
    • module:intent_realization exposed_through → this
    • module:intents exposed_through → this
    • module:knowledge_base exposed_through → this
    • module:mesh exposed_through → this
    • module:models exposed_through → this
    • module:pack exposed_through → this
    • module:plan exposed_through → this
    • module:product exposed_through → this
    • module:quality exposed_through → this
    • module:reasoning exposed_through → this
    • module:repository exposed_through → this
    • module:rules exposed_through → this
    • module:served exposed_through → this
    • module:server exposed_through → this
    • module:shell exposed_through → this
    • module:skills exposed_through → this
    • module:why exposed_through → this
    • module:worktree exposed_through → this

  • Cockpit surface

    • kind:adr exposed_through → this
    • kind:application exposed_through → this
    • kind:area exposed_through → this
    • kind:audience exposed_through → this
    • kind:claim exposed_through → this
    • kind:command exposed_through → this
    • kind:context exposed_through → this
    • kind:critique exposed_through → this
    • kind:deployment exposed_through → this
    • kind:derive-offload exposed_through → this
    • kind:distribution-model exposed_through → this
    • kind:document exposed_through → this
    • kind:domain exposed_through → this
    • kind:feature exposed_through → this
    • kind:gap exposed_through → this
    • kind:intent exposed_through → this
    • kind:issue exposed_through → this
    • kind:knowledge exposed_through → this
    • kind:mesh-declaration exposed_through → this
    • kind:milestone exposed_through → this
    • kind:moment exposed_through → this
    • kind:policy exposed_through → this
    • kind:profile exposed_through → this
    • kind:prompt exposed_through → this
    • kind:release-record exposed_through → this
    • kind:rule exposed_through → this
    • kind:scope exposed_through → this
    • kind:session exposed_through → this
    • kind:skill exposed_through → this
    • kind:taxonomy exposed_through → this
    • kind:use-case exposed_through → this
    • kind:workspace exposed_through → this
    • module:artifacts exposed_through → this
    • module:brief exposed_through → this
    • module:capabilities exposed_through → this
    • module:commands exposed_through → this
    • module:commit exposed_through → this
    • module:continuity exposed_through → this
    • module:convergence exposed_through → this
    • module:dashboard exposed_through → this
    • module:delivery exposed_through → this
    • module:deploy exposed_through → this
    • module:design exposed_through → this
    • module:devcontext exposed_through → this
    • module:devtask exposed_through → this
    • module:directories exposed_through → this
    • module:distribution exposed_through → this
    • module:economics exposed_through → this
    • module:editors exposed_through → this
    • module:entity exposed_through → this
    • module:environment exposed_through → this
    • module:episodes exposed_through → this
    • module:evidence exposed_through → this
    • module:executions exposed_through → this
    • module:gates exposed_through → this
    • module:graph exposed_through → this
    • module:guard exposed_through → this
    • module:health exposed_through → this
    • module:integration exposed_through → this
    • module:intent_realization exposed_through → this
    • module:intents exposed_through → this
    • module:knowledge_base exposed_through → this
    • module:lifecycle exposed_through → this
    • module:mcp exposed_through → this
    • module:mesh exposed_through → this
    • module:models exposed_through → this
    • module:monitor exposed_through → this
    • module:objects exposed_through → this
    • module:obligations exposed_through → this
    • module:observatory exposed_through → this
    • module:pack exposed_through → this
    • module:peers exposed_through → this
    • module:perf exposed_through → this
    • module:plan exposed_through → this
    • module:product exposed_through → this
    • module:quality exposed_through → this
    • module:reasoning exposed_through → this
    • module:recover exposed_through → this
    • module:release exposed_through → this
    • module:repository exposed_through → this
    • module:rules exposed_through → this
    • module:served exposed_through → this
    • module:server exposed_through → this
    • module:session_domain exposed_through → this
    • module:shell exposed_through → this
    • module:skills exposed_through → this
    • module:trace exposed_through → this
    • module:web exposed_through → this
    • module:why exposed_through → this
    • module:worktree exposed_through → this

  • Documentation surface

    • feature:benchmarks exposed_through → this
    • feature:ci exposed_through → this
    • feature:cockpit exposed_through → this
    • feature:commit exposed_through → this
    • feature:context exposed_through → this
    • feature:continuity exposed_through → this
    • feature:coordination exposed_through → this
    • feature:coverage exposed_through → this
    • feature:declare-once exposed_through → this
    • feature:doctrine exposed_through → this
    • feature:economics exposed_through → this
    • feature:evidence exposed_through → this
    • feature:finish-contract exposed_through → this
    • feature:install exposed_through → this
    • feature:interfaces exposed_through → this
    • feature:knowledge exposed_through → this
    • feature:mesh exposed_through → this
    • feature:models exposed_through → this
    • feature:observatory exposed_through → this
    • feature:planning exposed_through → this
    • feature:policy exposed_through → this
    • feature:provenance exposed_through → this
    • feature:reasoning exposed_through → this
    • feature:skills exposed_through → this
    • feature:ui exposed_through → this
    • feature:use-cases exposed_through → this
    • feature:why exposed_through → this
    • feature:worktrees exposed_through → this

  • MCP surface

    • kind:adr exposed_through → this
    • kind:application exposed_through → this
    • kind:area exposed_through → this
    • kind:audience exposed_through → this
    • kind:claim exposed_through → this
    • kind:command exposed_through → this
    • kind:context exposed_through → this
    • kind:critique exposed_through → this
    • kind:deployment exposed_through → this
    • kind:derive-offload exposed_through → this
    • kind:distribution-model exposed_through → this
    • kind:document exposed_through → this
    • kind:domain exposed_through → this
    • kind:feature exposed_through → this
    • kind:gap exposed_through → this
    • kind:intent exposed_through → this
    • kind:issue exposed_through → this
    • kind:knowledge exposed_through → this
    • kind:mesh-declaration exposed_through → this
    • kind:milestone exposed_through → this
    • kind:moment exposed_through → this
    • kind:policy exposed_through → this
    • kind:profile exposed_through → this
    • kind:prompt exposed_through → this
    • kind:release-record exposed_through → this
    • kind:rule exposed_through → this
    • kind:scope exposed_through → this
    • kind:session exposed_through → this
    • kind:skill exposed_through → this
    • kind:taxonomy exposed_through → this
    • kind:use-case exposed_through → this
    • kind:workspace exposed_through → this
    • module:artifacts exposed_through → this
    • module:brief exposed_through → this
    • module:capabilities exposed_through → this
    • module:commands exposed_through → this
    • module:commit exposed_through → this
    • module:continuity exposed_through → this
    • module:convergence exposed_through → this
    • module:dashboard exposed_through → this
    • module:delivery exposed_through → this
    • module:deploy exposed_through → this
    • module:design exposed_through → this
    • module:devcontext exposed_through → this
    • module:devtask exposed_through → this
    • module:directories exposed_through → this
    • module:distribution exposed_through → this
    • module:economics exposed_through → this
    • module:editors exposed_through → this
    • module:entity exposed_through → this
    • module:environment exposed_through → this
    • module:episodes exposed_through → this
    • module:evidence exposed_through → this
    • module:executions exposed_through → this
    • module:gates exposed_through → this
    • module:graph exposed_through → this
    • module:guard exposed_through → this
    • module:health exposed_through → this
    • module:integration exposed_through → this
    • module:intent_realization exposed_through → this
    • module:intents exposed_through → this
    • module:knowledge_base exposed_through → this
    • module:lifecycle exposed_through → this
    • module:mcp exposed_through → this
    • module:mesh exposed_through → this
    • module:models exposed_through → this
    • module:monitor exposed_through → this
    • module:objects exposed_through → this
    • module:obligations exposed_through → this
    • module:observatory exposed_through → this
    • module:pack exposed_through → this
    • module:peers exposed_through → this
    • module:perf exposed_through → this
    • module:plan exposed_through → this
    • module:product exposed_through → this
    • module:quality exposed_through → this
    • module:reasoning exposed_through → this
    • module:recover exposed_through → this
    • module:release exposed_through → this
    • module:repository exposed_through → this
    • module:rules exposed_through → this
    • module:served exposed_through → this
    • module:server exposed_through → this
    • module:session_domain exposed_through → this
    • module:shell exposed_through → this
    • module:skills exposed_through → this
    • module:trace exposed_through → this
    • module:web exposed_through → this
    • module:why exposed_through → this
    • module:worktree exposed_through → this

The tools this answers

The set is the adapters the distribution ships, agents and orchestrators alike. What this repository does with each — the instruction files its policy renders, the client configuration at its root — is read from the policy and the tree, never listed here; what the tool declares about each — its name, the configuration it reads, the scratch roots it creates checkouts under — is read from one declaration beside the templates.

  • Any tool that reads AGENTS.md agents
    • AGENTS.md · always loaded
  • bb bb
    • .bb/AGENTS.md

    scratch: ${BB_DATA_DIR:-~/.bb}/plugins/environment-git-worktree/host-data/worktrees

  • Claude Code claude-code
    • CLAUDE.md

    .mcp.json

    2 hook(s) wired

    scratch: <primary>/.claude/worktrees

  • Codex codex

    .codex/config.toml

  • Gemini CLI gemini
    • GEMINI.md

    .gemini/settings.json

  • A worker with no convention of its own generic

Every fact on this page came from majordomus product list, majordomus product matrix and majordomus product providers — the same answers this repository serves over HTTP and over MCP. How that derivation works →

Searches the titles and descriptions of every page this site publishes.