Design 47, milestone H: the plan to deliver the build-and-delivery system properly #737

Merged
mesh-tools merged 5 commits from plan/47-deliver-properly into main 2026-11-20 00:21:01 +00:00
Showing only changes of commit 44975de2e1 - Show all commits
@@ -47,6 +47,38 @@ per cent of the 527 rows judged (the rest belong to another part's code) (per pa
| bus load | 98 slow consumers, 117 consumers behind; the watchman 39,037 events behind | mesh-config passes every 5 minutes and polls every minute on main (fixed on the held pull requests); the forge module polls every minute |
| hand-placed programs | every delivery module but the indexer, the image registry and the tool runner (on ace and g14) | G's live start of 2026-11-16 and after; 16 drop-in files under `/run/systemd/system` on the four machines (4 of them `.pre-g` copies), lost at a reboot |
**Every node, every module** (the assigner's assignments at revision 339, unchanged since 2026-11-18 02:08 UTC; the
node-engines' haves; read 00:47 to 00:54 CET):
| machine | placed | running | held | failed |
|---|---|---|---|---|
| the control node | 90 | 10 | 53 (entry missing) | 24 |
| the build node | 80 | 12 | 59 (entry asked) | 7 |
| the desktop | 83 | 24 | 33 (entry missing) | 26 |
| the laptop | 76 | 6 | 60 (45 entry asked, 15 entry missing) | 9 |
65 of the 66 failed wants fail for one reason: the want names no digest for the module's files, code or tools (the
A-430 stand-in, a want naming its parts, left half built). The one other is the desktop's node-engine ("operation not
permitted" unpacking a version). No service is failed on any machine; the 25 open conditions are warnings. Every
delivery module's want is held by the assigner's rule 2 (no passed pipeline at the graph's fingerprint); before it,
rule 8 held the 23 bus-state modules because the bus module's have is held although the bus runs. The haves are wrong
about what runs for three modules (the tool runner on two machines, the indexer): `node-engine.process-builds` is the
tool that says it, found only in this second reading.
**The module graph** (the indexer, trunk revision 512, source 1038): 193 modules; 269 package edges (published before
it builds), 178 toolchain edges, 208 provider and requirement edges, 212 served-verb edges (19 verbs served by no
module), 30 await edges; the acting-part and contribution edges are not in the graph's state. The other watched branches
stand at revision 1 since 2026-11-14. No tool answers a build order or a deploy order for a set of modules, the
difference between two revisions, a revision narrowed by module or edge kind, or which source commit a fingerprint was
built from; the whole revision is 1.3 MB, over the bus's message size. Those reads are tools milestone H4 builds in the
indexer and the assigner (one-question-one-tool; section 4, item 12).
**No pull request is checked today.** The checker's verdict verb asks the indexer `indexer_read_candidates`, which no
running indexer answers (503 no responders), so no `mesh/check` status is ever set; the forge calls every pull request
mergeable because main requires no status. Nine open conditions ask `indexer_read_modules` the same way. Tools were
removed or renamed while their callers still name them; by design 47 G the pipeline makes the check and the checker
goes (G-2), which milestone H1 builds for hq too (hq is a registered module whose one step is its Go checks).
**The root of it, in one sentence.** The design settled on one model (a change is a commit on a watched branch of a
registered module; the forge bridge says it, the indexer takes it in per branch, the runner starts exactly the movers,
the gate follows), but the code carries that model and the earlier per-pull-request model side by side, and the live
@@ -283,6 +315,11 @@ at all. Before any code, `hq-design-writer` writes these as design lines in this
(deliveries first, ADR 0525, or the turns the code takes on an operator's yes no record holds).
12. The reads the status view, the watchman and the grants part make of other parts' buckets, each turned into the
event or verb of the part that owns the data (ADR 0596), and the rate read on the seat `mesh-broker`.
13. The read tools the second live reading found missing (one-question-one-tool): in the indexer, one revision
narrowed by module or edge kind, a non-trunk branch's revision, the edges by kind, the difference between two
revisions, a build order for a set of modules, the source commit a fingerprint was built from; in the assigner, a
deploy order per machine; in the node-engine, its own build. Also the checker's and the conditions' calls of
indexer tools no indexer serves (`indexer_read_candidates`, `indexer_read_modules`), removed with their callers.
## 5. The clean state, by hand once (milestone H1's delivery)
@@ -304,10 +341,24 @@ next:
failed wants, through each module's tools where one exists (the surveyor found none for the bucket contents; the
pack carries the one-off deletion and says what it deleted, counted). The drop-ins are removed and the units the
node-engine writes take their place as the wants compose.
5. **Place the programs**, one machine at a time: novox (indexer, runner, gate, bridge, forge module, mesh-config,
watchman, view if it moves there), then shanks (builder, node-engine), ace (assigner, node-engine), g14
(node-engine). After each, read its health, its first views and the bus's consumers.
6. **Start the runner** with `pipelines-at-once` at 1.
5. **Place the programs** in the order the graph gives (derived by the reader of 00:54 CET from the package,
toolchain and provision edges; no tool answers it yet), each step read with the tools before the next:
1. keep the bus, the forge and the image registry running; make the bus module's have `running` (else the
assigner's rule 8 holds the 23 bus-state modules);
2. the packages first: `mesh-sdk`, `mesh-contracts`, `mesh-delivery-sdk` published (every Go module needs them;
`mesh-delivery-sdk` needs its registration first, section 3.4);
3. build with the running Go build module (it is what breaks the cycle "every Go module, the build module itself
included, is built by a running build module"), the builder first, then the indexer, the forge bridge, the
runner, the assigner; then the three build modules (they need the builder's package), the gate (needs the
indexer's and the bridge's packages) and the grants part; then the node-engine;
4. place on the control node: the indexer, the forge bridge, the gate, the forge module, mesh-config; on the build
node the builder; on the desktop the assigner;
5. place the node-engines: the control node, then the build node, the desktop, the laptop;
6. place the watchman, the status view, the teller, the grants part and the hand-act log on the control node;
the checker is not placed (it goes, section 1);
7. after each machine, read its health, its first views, its `process-builds` against its haves, and the bus's
consumers.
6. **Start the runner last**, with `pipelines-at-once` at 1.
7. **Prove it.** One single-module change (a comment in a module with lint, unit and composition steps only), merged
to main, followed from `take-in.taken` through `pipeline-ended` to the node-engine's `running` and the gate's
ended record, with no hand act; then one two-module change along a dependency edge (mesh-sdk and a module that