mesh-config sent about 262 requests a second and received about 1,540 since its start: every sources() call (a resolution pass, and a `delivered`, `manifest-reads-changed` or `manifest-accepted` event, each of which read the sources whether or not a window or a retirement was open) read every key of its own states by one get each (pulls 1,176 keys, resolved 447, declared 168, values 101...: about 1,200 requests for an event, 2,800 for a pass), serialised by one lock, so a delivery's burst of events kept it asking the bus back to back. - The module's own states are read from mesh-sdk's WatchedStates (one watch per state, its own writes taken into the copy) instead of a get per key (ownstates.go, main.go runtimeStore). - An event judges what it names: `delivered` and `manifest-reads-changed` read no source when no rename window is open, `manifest-accepted` reads none when every row is already marked or read again (renames.go windowOpen, retiring.go). - Open windows and retirements are judged again after each pass, since an entry that answers after the judgement was made moves the pass, not the event; the slow reads had hidden that race. - No timer polls: the five-minute resolution and sweep of every pull request on the forge, and the minute's read of the router's record, are gone. The sweep and Decide run once at start (an event said while the module was down is not said again), then on git.pull-merged/-closed and operator-channel.decided.mesh-config; an ask ended with no choice also takes the retirements from the router's record. One timer is left, a deadline: for the earliest waiting proposal (ProposalLasts + 1 h) or unanswered retirement (HeldFinding), set again when either is written (NextDeadline). Wake-ups kept, each by its record: `delivered` and `manifest-reads-changed` close a rename window (design 32 *A config value renamed*, ADR 0609 §4); `manifest-accepted` judges one module's retirements (design 32 *A value no longer read*); `git.pull-merged` and `-closed` settle one pull request's held values (ADR 0502 §7); `decided.mesh-config` takes one ask's warrant (ADR 0259); a changed view (assignment, want, predefined list, config candidate, catalog revision, entry) moves a resolution that writes only what moved (ADR 0565 §3). Builds: ADR 0681 §1 (no polling of the forge: the five-minute look ends); ADR 0580 §1; ADR 0426 §3; design 32 (*A config value renamed*, *A value no longer read*); lead answer A-490l (hq main, 03-DESIGN/01-to-be/47-milestones/G-22-lead-answers-2.md) for the wake-ups and the one deadline timer. Claude-Session: https://claude.ai/code/session_01JG73KHUnBze48rdua8u2sy
mesh-catalog
The Novox Mesh catalogue. The modules the mesh builds, provisions and runs — as manifests, one
per module under modules/.
This is data, not a control-plane concern. The manifests describe what a module is: what it
provides, what it requires, the seats it claims, the resources the host applies for it. The
engine that reads them — parsing, eligibility resolution, sealing, declaration emission — lives
in the control plane (novox/mesh-controller, internal/catalogue), which consumes this repository
as a build source. The host (novox/mesh-host) applies the declarations the control plane emits.
Neither is here.
What a module is, and is not
A module is one thing the mesh can run, named once, described completely by its manifest. A
manifest names its image (pinned by digest), the resources the host owns for it (directories,
files, the container, the private network it joins), what it requires from a provider and what
it provides to consumers, and the sealed secrets it needs filled on the machine.
- Core mesh components are not modules. The node host, the foundation, the control-plane
contexts and the surfaces are the mesh itself; they ship as their own repositories
(
mesh-host,mesh-foundation,mesh-controller,mesh-surfaces,mesh-sdk), not from here. - Standalone applications are not here either. A larger application lives in its own repository with its manifest at the root, registered with the mesh as a build source (novox/hq ADR 0010). This repository holds the modules the mesh maintains as its shared catalogue; an application the mesh merely hosts keeps its manifest beside its own code.
So there is one home for the catalogue the mesh owns, and every application that runs on the mesh rather than being of it carries its own — both reach the pipeline the same way, as a registered source.
Layout
modules/<name>.json one manifest per module
Flat, because the catalogue's shape carries no meaning: a module is found by its name and described by its manifest, and what relates two modules — a shared seat, a claim, a provider/consumer edge — is data inside the manifests, not a directory the tree encodes (novox/hq, the domain-grouping question closed in favour of seats, claims and tags).
The manifest contract
The shape a manifest must satisfy is owned by the control plane's catalogue engine and is what
validates a manifest before a machine ever sees it — a stray key, a consumer contributing the
wrong provision field, an image that nothing builds. That validation belongs with this
repository and is being re-homed here from mesh-controller; until it is, the pipeline is the
gate — it builds each module and refuses a manifest it cannot resolve.
Where the reasoning lives
Design and decisions are in novox/hq:
02-DECISIONS/0002-everything-is-a-module.md— one unit, no second mechanism02-DECISIONS/0010-applications-live-in-their-own-repository.md— why applications are not here02-DECISIONS/0030-the-repository-structure.md— the repositories, and the open tier-4 question this repository answers03-DESIGN/00-as-is/10-module-catalogue.md— the catalogue's shape, and what it records