Compare commits

..
1 Commits
15 changed files with 31 additions and 1882 deletions
-4
View File
@@ -26,10 +26,6 @@ questions are.
- an interaction the design does not place that is not a mesh path: one module naming another, reading another's - an interaction the design does not place that is not a mesh path: one module naming another, reading another's
internals or being special-cased in another part; a module's name in shared code; state only in memory; a poll or internals or being special-cased in another part; a module's name in shared code; state only in memory; a poll or
a timer where an event exists; a timer where an event exists;
- a value written into the code that can differ between machines, modules or over time (a port, a path, a bound, a
cap, a name, a time) and is not a setting with a default (principle 11); name the setting it should be, eagerly;
- a module that writes another module's file or state, or anything in another module's place, instead of giving it
through a provision or a contribution that module declares (principle 12);
- an effect or a reader of the build map's `What exists today` whose fate the diff does not carry out (run its - an effect or a reader of the build map's `What exists today` whose fate the diff does not carry out (run its
searches again on the reviewed tree), or one the search finds and the answer omits; searches again on the reviewed tree), or one the search finds and the answer omits;
- a test that does not fail without its change (check it by taking the change out in a copy), an acceptance - a test that does not fail without its change (check it by taking the change out in a copy), an acceptance
+1 -3
View File
@@ -25,9 +25,7 @@ write.
What you judge: What you judge:
- Seams: where each piece of state lives on the bus (key-value bucket, stream, object store) and which module owns it; which seat, verb or event joins two parts; any link that is not NATS-native (a poll, a timer, HTTP between modules, a shared file, state only in memory); whether a form the manifest lacks is named with its cost (a mesh-sdk change rebuilds every module). - Seams: where each piece of state lives on the bus (key-value bucket, stream, object store) and which module owns it; which seat, verb or event joins two parts; any link that is not NATS-native (a poll, a timer, HTTP between modules, a shared file, state only in memory); whether a form the manifest lacks is named with its cost (a mesh-sdk change rebuilds every module).
- Settings and ownership: every value that can differ between machines, modules or over time is a setting with a - Seams inside a module, at run time: for every event, queue and piece of state the subject adds or changes, which processes read it on each node (a module's program, its tool runner, any other process its manifest names, the same module on several nodes), and whether each gets every item it needs. A NATS durable consumer or a queue group hands each message to one reader only: two processes reading under one name split the messages silently, and the bus refuses nothing. A design line that names one reading place per module where more than one process reads is a **must**; only a work queue, where one reader per item is the point, is shared. (The operator, 2026-11-14: on ace the assigner's program and its tool runner read one durable consumer, and the runner took all 178 first registrations the program acts on; lead answer A-397.)
default, never hard-coded (principle 11), and the design names it; no module writes another module's file or state:
what one module needs from another goes through a provision or a contribution that module declares (principle 12).
- Tools: for every new piece of state a tool that reads it, and for every new behaviour a tool that steers it (do by hand, ask again, drop, repair, re-check), as the instruction tools-are-how-a-module-is-spoken-to says. - Tools: for every new piece of state a tool that reads it, and for every new behaviour a tool that steers it (do by hand, ask again, drop, repair, re-check), as the instruction tools-are-how-a-module-is-spoken-to says.
Judge only whether the settled direction or design is complete and sound in your two architectural domains, Judge only whether the settled direction or design is complete and sound in your two architectural domains,
-9
View File
@@ -620,15 +620,6 @@ controller (the planner, the rollout) until release 6 of ADR 0429; from each rel
- **composition step** — the pipeline step that composes each machine's declaration with a change, by the composer built - **composition step** — the pipeline step that composes each machine's declaration with a change, by the composer built
from its heads in the sandbox, refusing a change in which two modules own one path; served by the seat `mesh-wants` from its heads in the sandbox, refusing a change in which two modules own one path; served by the seat `mesh-wants`
(ADR 0666 §17). From milestone G's delivery it replaces the **composition check**. (ADR 0666 §17). From milestone G's delivery it replaces the **composition check**.
- **composition run** — the one run of the composer for one candidate on one machine, started by the first
composition step of that candidate that needs the machine and kept by the assigner in its state `composition-runs`;
every composition step of the candidate whose module is placed on the machine reads its verdict (design 47 G §718).
Not a **composition**, one module's resources composed for one node; nor the **composition step**, the pipeline
step that reads one composition run per machine.
- **test run** — the one run of a lint, unit test or integration test pipeline step for one candidate, one level and
one set of tested packages at their digests, kept by the runner in its state `test-runs`; every artifact's pipeline step of that candidate
naming the same packages reads its result (design 47 G §724). Not a **pipeline step**, each artifact's own, nor a **run
on request**, a whole pipeline that delivers nothing.
- **merge check** — what a pull request carries before it may merge, judging the merge of its head into a - **merge check** — what a pull request carries before it may merge, judging the merge of its head into a
named **trunk commit**, made in a clone of its own on a build node and never pushed (ADR 0323). One status, named **trunk commit**, made in a clone of its own on a build node and never pushed (ADR 0323). One status,
`mesh/check`, written by the checker: the change's tests, run by the language's build module, and the `mesh/check`, written by the checker: the change's tests, run by the language's build module, and the
+3 -12
View File
@@ -1,6 +1,6 @@
--- ---
status: canonical status: canonical
updated: 2026-11-16 updated: 2026-11-11
--- ---
# The principles # The principles
@@ -22,18 +22,9 @@ add, sharpen or drop a principle in a pull request to this file.
6. **Nothing is exposed publicly.** No data leaves the mesh unasked: no secret in a record, a log or a public 6. **Nothing is exposed publicly.** No data leaves the mesh unasked: no secret in a record, a log or a public
repository, no service reachable from outside unless it is meant to be. Inside the mesh, every agent and module repository, no service reachable from outside unless it is meant to be. Inside the mesh, every agent and module
is trusted; who may do what is not a question to ask. is trusted; who may do what is not a question to ask.
7. **No part without a need.** Every mechanism, field, seat and step exists because something needs it; prefer what 7. **The simplest thing that works.** Prefer what already exists. No new mechanism unless it is needed, and fewer
exists over a new one, and remove what no longer serves. Never a shortcut instead of the right shape. parts over more.
8. **One word per thing**, from the [glossary](glossary.md). 8. **One word per thing**, from the [glossary](glossary.md).
9. **Depend on the contract, at the level it is interchangeable.** A module depends on a seat where the mesh means
more than one module to be able to fill the need, and on a module where only that module does; never on another
module's internals.
10. **The module is the unit.** Everything is done per module, never per repository. A repository is only where a
module's files are kept; a merge moves only the modules it changes.
11. **Configurable, never hard-coded.** A value that can differ between machines, modules or over time (a port, a
path, a bound, a cap, a name, a time) is a setting with a default, never written into the code.
12. **A module writes only its own.** A module writes its own files and state alone; what another module needs from it
goes through a provision or a contribution that module declares, never a file written in its place.
How it is checked: the one code review of a milestone checks the code against these principles and the design's How it is checked: the one code review of a milestone checks the code against these principles and the design's
shape; an answer to a develop question names the principle that settles it. shape; an answer to a develop question names the principle that settles it.
+4 -1
View File
@@ -112,7 +112,10 @@ the four reviewer agents in `.claude/agents/` (`review-security-and-upgrade`, `r
link that is not NATS-native. Each piece of state is kept in the bus storage form that fits it (a key-value link that is not NATS-native. Each piece of state is kept in the bus storage form that fits it (a key-value
bucket, a stream, an object store); a form the manifest lacks is added to mesh-sdk, and the review names that change bucket, a stream, an object store); a form the manifest lacks is added to mesh-sdk, and the review names that change
and its cost (a mesh-sdk change rebuilds every module) to the operator, never folds it in silently (the and its cost (a mesh-sdk change rebuilds every module) to the operator, never folds it in silently (the
operator, 2026-11-02); operator, 2026-11-02). Inside a module too: which of its processes (its program, its tool runner, another process
its manifest names) read each event, queue and piece of state at run time, and whether each gets every item it
needs: a durable consumer or a queue group hands each message to one reader only, so a reading place shared by two
processes splits the messages silently (the operator, 2026-11-14; lead answer A-397);
- **running qualities**: build capacity, speed, storage growth, and what happens while a part, the bus or the - **running qualities**: build capacity, speed, storage growth, and what happens while a part, the bus or the
control-node is down; control-node is down;
- **health**: what each part's health check says, which conditions are raised and cleared, and whether any - **health**: what each part's health check says, which conditions are raised and cleared, and whether any
+2 -36
View File
@@ -8,9 +8,8 @@ code:
- mesh-sdk go/catalogue (the manifest's shapes) - mesh-sdk go/catalogue (the manifest's shapes)
- mesh-sdk go/declaration (the node-engine's resource vocabulary) - mesh-sdk go/declaration (the node-engine's resource vocabulary)
- mesh-contracts - mesh-contracts
updated: 2026-11-18 updated: 2026-11-12
decisions: decisions:
- "ADR 0680"
- "ADR 0578" - "ADR 0578"
- "ADR 0595" - "ADR 0595"
- "ADR 0619" - "ADR 0619"
@@ -170,7 +169,7 @@ since a package is a build input and runs nowhere.
|---|---|---| |---|---|---|
| **tools** | a `bundle` with `loads` naming what the runtime loads (for a Go bundle its `binary`), and the module's `tools` listing every tool it serves; `replaces` for the shell commands a tool replaces | the node's tool runner (ADR 0175); with `runs-as`, a **runtime of its own** under the module's account (below) | | **tools** | a `bundle` with `loads` naming what the runtime loads (for a Go bundle its `binary`), and the module's `tools` listing every tool it serves; `replaces` for the shell commands a tool replaces | the node's tool runner (ADR 0175); with `runs-as`, a **runtime of its own** under the module's account (below) |
| **a long-running service of its own code** | a `process` resource: `artifact` (a bundle), `name` (what the unit is called), `run` (the command, relative to the unpacked bundle), `user`, `env` and `env-file`, `restart-on`, `health`, `yields`, `replaces` (the ids it takes over from) | the node-engine, as a unit that stays up | | **a long-running service of its own code** | a `process` resource: `artifact` (a bundle), `name` (what the unit is called), `run` (the command, relative to the unpacked bundle), `user`, `env` and `env-file`, `restart-on`, `health`, `yields`, `replaces` (the ids it takes over from) | the node-engine, as a unit that stays up |
| **its own bus account for a process** | the process's `bus`: the `emits`, `state`, `queues`, `invokes` and `asks` it is granted, a subset of what the manifest declares; an own secret holding the account, owned by the account the process runs as, whatever that account (ADR 0680 §1; *Whose a process's own secrets are*, below) | the grants part composes the account from it | | **its own bus account for a process** | the process's `bus`: the `emits`, `state`, `queues`, `invokes` and `asks` it is granted, a subset of what the manifest declares; an own secret holding the account, owned by the process's `user` (ADR 0436 §1) | the grants part composes the account from it |
| **a scheduled job** | a `process` or `container` resource with `schedule`, a five-field cron; never with `run-once`; a process with no `restart-on`, `replaces` or `witness`; a scheduled container may name `while-stopped` (below) | the node-engine, again on each fire (ADR 0053) | | **a scheduled job** | a `process` or `container` resource with `schedule`, a five-field cron; never with `run-once`; a process with no `restart-on`, `replaces` or `witness`; a scheduled container may name `while-stopped` (below) | the node-engine, again on each fire (ADR 0053) |
| **a one-time step** (a seed, a first-start step, a validator of a file) | a `process` or `container` resource with `run-once` true: a **run-once step**, which gates every resource after it; `restart-on` makes it run again when what it names changes (ADR 0052, ADR 0099) | the node-engine, to completion | | **a one-time step** (a seed, a first-start step, a validator of a file) | a `process` or `container` resource with `run-once` true: a **run-once step**, which gates every resource after it; `restart-on` makes it run again when what it names changes (ADR 0052, ADR 0099) | the node-engine, to completion |
| **a migration of its own state before a new version runs** | `prepares` true, and a `container` or `process` that stays up running an artifact the module built: the mesh runs that program in its preparation mode (ADR 0135); never a run-once step written by hand for it | the node-engine, before the new version starts | | **a migration of its own state before a new version runs** | `prepares` true, and a `container` or `process` that stays up running an artifact the module built: the mesh runs that program in its preparation mode (ADR 0135); never a run-once step written by hand for it | the node-engine, before the new version starts |
@@ -179,39 +178,6 @@ since a package is a build input and runs nowhere.
| **a host program from the operating system** | a `package` resource (`package`, `absent`) and a `service` resource per unit it ships (`unit`, `state`, `boot`, `scope`, `restart-on`, `reload-on`, `health`); never an `action` | the node's package manager and service manager | | **a host program from the operating system** | a `package` resource (`package`, `absent`) and a `service` resource per unit it ships (`unit`, `state`, `boot`, `scope`, `restart-on`, `reload-on`, `health`); never an `action` | the node's package manager and service manager |
| **files** | `file` and `directory` resources (a directory by `place` or `path`), an `archive` resource unpacking an `archive` artifact, template files in the module's `templates` directory | the node-engine and the provisioner client | | **files** | `file` and `directory` resources (a directory by `place` or `path`), an `archive` resource unpacking an `archive` artifact, template files in the module's `templates` directory | the node-engine and the provisioner client |
**Whose a process's own secrets are** (ADR 0680). *Amended 2026-11-18.* Every own secret a process reads, its bus
credential first, is owned by the account that process runs as, whatever that account is: an account the module
makes (a `user` resource of that name), the operator account (`${machine:account}`), or root (ADR 0680 §1). The
manifest names it, as the secret's `owner` or the module's `secrets-owner`, and the process runs as it (its `user`)
or as root, as the second rule below holds; the node-engine writes the secret owned by it at mode 0600 (ADR 0680 §1). An account the module makes stays
the usual case, not a rule; a process that declares `bus` still names the account it runs as. ADR 0436 §1's "never
root and never the operator account" no longer holds for a process that declares `bus`, and the manifest validator's
two rules that refused them (as an own secret's owner and as a `bus` process's account) are gone (ADR 0680 §2). The
manifest validator holds two rules instead:
- **Every account named is one the mesh knows.** An own secret's `owner`, a `secrets-owner` and the account of a
process that declares `bus` are each the operator account, root or an account the module makes; any other is
refused, and so is a `bus` process naming no account (ADR 0680 §2).
- **A process can read every own secret it names.** A process resource that names an own secret (its path in the
process's `run` or `env`) and runs as neither that secret's resolved owner (its `owner`, else `secrets-owner`) nor
root is refused (ADR 0680 §3). A container module is excepted, since a container reads its secrets as its own
account, and a process account's secret needs no such rule, since it is delivered owned by the process's account
(ADR 0436 §2).
A secret owned by the operator account is as private as what runs as that account on its node: the node's tool
runner, and through it every agent session there (ADR 0436 §9). That exposure is accepted (ADR 0680 §1); what bounds
a process account's credential is its grants, which answer no tool and no seat's verb (ADR 0436 §3). A module's
`runs-as` is unchanged: it names an account the module makes (ADR 0259 §8, below).
*How it is checked:* the node-engine's tests write an own secret owned by the account its manifest names, at mode
0600, for an account the module makes, for the operator account and for root; the manifest validator's tests, run on
every change of the validator and over every manifest a change of mesh-catalog touches, accept an own secret owned by
`${machine:account}` or root, a `bus` process running as either, a process running as the resolved owner of the own
secret it names (also through `secrets-owner`), a process running as root, and a container module naming another
account's own secret, and refuse a `bus` process naming no account or one the module does not make, and a process
naming another account's own secret; the controller's grant test still finds no process account able to answer a
call (ADR 0680 §4).
**A runtime of its own.** A module that says `runs-as` names an account it makes (a `user` resource of that name, **A runtime of its own.** A module that says `runs-as` names an account it makes (a `user` resource of that name,
never root nor the operator's); its tools bundle is then served by a runtime of its own, as that account, on a bus never root nor the operator's); its tools bundle is then served by a runtime of its own, as that account, on a bus
account of its own (ADR 0259 §8), whose readiness is the manifest's `runtime-health` (ADR 0366). Its secrets belong to account of its own (ADR 0259 §8), whose readiness is the manifest's `runtime-health` (ADR 0366). Its secrets belong to
@@ -3,10 +3,9 @@ layer: to-be
status: in-progress status: in-progress
design: 42 design: 42
milestone: zfs-owns-zfs milestone: zfs-owns-zfs
updated: 2026-11-18 updated: 2026-11-13
decisions: decisions:
- "ADR 0679" - "ADR 0679"
- "ADR 0680"
--- ---
# 42, milestone zfs-owns-zfs — the lead's answers to the prepare's questions # 42, milestone zfs-owns-zfs — the lead's answers to the prepare's questions
@@ -137,8 +136,6 @@ settles it (`00-META/principles.md`), cited as "design 42 zfs-owns-zfs A-n". The
calls: emit an event, put or delete a key of those states, and invoke one of those three. The root processes say calls: emit an event, put or delete a key of those states, and invoke one of those three. The root processes say
everything they say on the bus through it; with the keeper not answering they act as with the bus down (A-8), and everything they say on the bus through it; with the keeper not answering they act as with the bus down (A-8), and
warn. The module's tools keep their own account as today. warn. The module's tools keep their own account as today.
*Amended 2026-11-18:* ADR 0680 §1 ends ADR 0436 §1's "never root" for a process that declares `bus`, so this
answer's premise no longer holds; the keeper stands as the milestone builds it, a choice the records no longer force.
- **A-38** (A-37, §25, §26, met in develop; ADR 0436 §1, ADR 0595 §1, §2; the operator's "a case the delivery cannot - **A-38** (A-37, §25, §26, met in develop; ADR 0436 §1, ADR 0595 §1, §2; the operator's "a case the delivery cannot
handle is a gap in the build and delivery system") A process's `bus` today is judged and granted only against the handle is a gap in the build and delivery system") A process's `bus` today is judged and granted only against the
module-level `emits` and `state`, which ADR 0595 replaced by what a module asks for in `requires`. In this module-level `emits` and `state`, which ADR 0595 replaced by what a module asks for in `requires`. In this
@@ -2,7 +2,7 @@
layer: to-be layer: to-be
status: in-progress status: in-progress
code: [mesh-controller, mesh-catalog modules/mesh-delivery-gate, mesh-catalog modules/gitea, mesh-delivery, mesh-host, mesh-sdk, mesh-vault, mesh-contracts, mesh-tools, mesh-networking, hq 00-META/checks] code: [mesh-controller, mesh-catalog modules/mesh-delivery-gate, mesh-catalog modules/gitea, mesh-delivery, mesh-host, mesh-sdk, mesh-vault, mesh-contracts, mesh-tools, mesh-networking, hq 00-META/checks]
updated: 2026-11-17 updated: 2026-11-11
decisions: decisions:
- "ADR 0673" - "ADR 0673"
- "ADR 0672" - "ADR 0672"
@@ -1972,27 +1972,6 @@ ADR 0667's checks, of milestone G itself:
`condition-raised` (whole, condition keeper and a fixture observer, mesh-catalog and mesh-sdk). Live: after G's `condition-raised` (whole, condition keeper and a fixture observer, mesh-catalog and mesh-sdk). Live: after G's
delivery, a node-engine restarted with the full seat list clears its `seat-list-unread`, read with delivery, a node-engine restarted with the full seat list clears its `seat-list-unread`, read with
`mesh-conditions.conditions`. `mesh-conditions.conditions`.
108. **One composition run per candidate and machine** (design 47 G §718 to §723, §727 to §733). Two composition
steps of one candidate started at once make one key, one request and one run ask; three steps of one revision on
two machines start two runs, each step reading both verdicts. A machine whose verdict blames one module fails that
module's composition step alone and says it as a warning in the others; a verdict with no `blamed` is judged as
today, naming no culprits. A run with no `step-ended` within its bound ends `could not run` with its readers; steps
asked again together start one run per machine that did not pass and move every former reader, a reopened
pipeline saying `pipeline-ended` again; a run that keeps saying its progress past 30 minutes is not ended, and a
taken ask silent for 30 minutes ends `could not run`. Both drop tools end
the readers, and a reader-only account calling one is refused (whole, assigner and the node-engine's composer,
mesh-delivery and `mesh-host`). Live: in the first publish after G's delivery, the composition run asks of a
revision number at most its machines, read with `assigner_compositions` and `assigner_inputs`.
109. **One test run per level and tested packages** (design 47 G §724 to §733). A module whose program and tools
bundle test one directory runs its unit and integration tests once per level, both artifacts' pipeline steps
ending with that result and naming it in `shared`, a failing test failing once, and `pipeline-ended` counting the
module's tests once. A rerun that passes moves both artifacts' steps and the pipeline ends again; a runner
restarted during a run takes it up again; a replaced reader leaves the ask to the others; at the cap a step ends
`could not run` naming the fill; a second revision with the same digests runs a failed test again; a test run queued past five minutes with a
holder present is not failed (design 47 G A-466y) (whole, runner
and Go build module, mesh-delivery and mesh-catalog). Live: each module's test steps run once per level, read with
`runner_test_runs`. A reader no part ends raises `pipeline-stands` within five minutes of its last sign of life
(whole, watchman; design 47 G §732).
## What retires ## What retires
@@ -384,15 +384,12 @@ that round are written into the lines they name, here. Questions that an earlier
- §535 **A missing build seat and a seat with no holder, each read where it shows.** The runner reads that no build - §535 **A missing build seat and a seat with no holder, each read where it shows.** The runner reads that no build
seat serves an artifact's language from the catalog half of its revision view: no entry whose `acts`, the acting seat serves an artifact's language from the catalog half of its revision view: no entry whose `acts`, the acting
rules of the seats it claims, hold a rule `build` with `on` naming that language (§323); the pipeline then ends rules of the seats it claims, hold a rule `build` with `on` naming that language (§323); the pipeline then ends
failed at once, naming the language and the missing build seat. *Amended by A-466y and A-466z (2026-11-17):* it reads that failed at once, naming the language and the missing build seat. It reads that a seat has no holder from the step
a seat has no holder only when the seat `mesh-module-assigner`'s view `seat-holders` names none for it (G-21 §717's itself: an ask on that seat's work queue whose `step-started` is not heard within five minutes ends the pipeline
follower; never the seat list, which answers definitions alone, §527), and a seat with none ends the pipeline failed failed, naming the seat (§32). It reads neither from the seat list, which answers definitions alone (§527), nor
at once, naming it; an ask waiting for an existing holder is timed by §86's `build-capacity-waits` and A-466s's from any holding. Why: §32 already ends a pipeline whose step nothing starts, and the catalog half is the runner's
`run-untaken-bound` (G-24 §720, §725), never by five minutes from the ask. Why: §32 already ends a pipeline whose one view (develop question Q-RN7). How it is checked: whole (runner), a fixture language with no build seat ends at
step nothing starts, and the catalog half is the runner's one view (develop question Q-RN7); a queued step ended once, naming it; a seat whose holder is stopped ends within five minutes, naming the seat.
failed for "no holder" while its holder is present would say what is not true (principle 3). How it is checked:
whole (runner), a fixture language with no build seat ends at once, naming it; a seat the seat-holders view names
no holder for ends at once, naming the seat; a step queued past five minutes with a holder present is not failed.
- §539 **The runner's tools are named `runner_`.** The runner's module, `mesh-delivery-pipeline`, names its tools with - §539 **The runner's tools are named `runner_`.** The runner's module, `mesh-delivery-pipeline`, names its tools with
the prefix `runner_`, so the design's `runner_catch_up`, `runner_waits`, `runner_release` and `runner_health` the prefix `runner_`, so the design's `runner_catch_up`, `runner_waits`, `runner_release` and `runner_health`
stand, and its first-view tool is `runner_first_views`; `<module>_first_views` (§205) carries the prefix the stand, and its first-view tool is `runner_first_views`; `<module>_first_views` (§205) carries the prefix the
@@ -378,17 +378,9 @@ for several build maps is answered once, and the maps' names for it are given in
- §646 **The runner's bodies name `fingerprint`.** (§585) The runner's `step-ended`, pipeline and wait bodies name the - §646 **The runner's bodies name `fingerprint`.** (§585) The runner's `step-ended`, pipeline and wait bodies name the
build-input fingerprint `fingerprint`, not `fp`, as §585 reads it. [mesh-delivery DQ-2.] How it is checked: unit build-input fingerprint `fingerprint`, not `fp`, as §585 reads it. [mesh-delivery DQ-2.] How it is checked: unit
(runner's contract). (runner's contract).
- §647 **The runner times an ask from `ask-taken`.** (§535, §602; A-466y) The runner consumes the build seat holder's - §647 **The runner times an ask from `ask-taken`.** (§535, §602) §535's five minutes run from the ask until the build
`ask-taken` (§602); `step-started` is the runner's own. *Amended by A-466y and A-466z (2026-11-17):* §535's five seat holder's `ask-taken` (§602), which the runner consumes; `step-started` is the runner's own. [mesh-delivery
minutes from the ask until `ask-taken` go. A seat for which the seat `mesh-module-assigner`'s view `seat-holders` DQ-3.] How it is checked: whole (runner), an ask no holder takes ends its pipeline after the setting.
names no holder ends the pipeline failed at once, naming it, judged only once that view's first view is read, never
from the not-ready picture `FollowSeat` answers before it (principle 3). The runner's manifest gains the `consumes`
entry `seat:mesh-module-assigner.views.seat-holders` (on main it has none: its `invokes` names only
`seat:mesh-module-assigner.assignments`); an
ask waiting for an existing holder is timed by §86's `build-capacity-waits` and by A-466s's `run-untaken-bound`
(G-24 §720, §725), and from its `ask-taken` by its step's bound (A-466p). [mesh-delivery DQ-3.] How it is checked:
whole (runner), a seat with no holder ends the pipeline at once, naming it; an ask a present holder has not taken
past five minutes is not failed (test 109).
- §648 **A `take-in.taken` entry carries the pull request.** (§476, §542) An entry is `{module, commit, fingerprint, - §648 **A `take-in.taken` entry carries the pull request.** (§476, §542) An entry is `{module, commit, fingerprint,
repository, pull}`, the last two from a `merged` message and absent for a `pushed` one. [mesh-delivery DQ-5.] How it repository, pull}`, the last two from a `merged` message and absent for a `pushed` one. [mesh-delivery DQ-5.] How it
is checked: unit (indexer's contract). is checked: unit (indexer's contract).
@@ -3,7 +3,7 @@ layer: to-be
status: in-progress status: in-progress
design: 47 design: 47
milestone: G milestone: G
updated: 2026-11-17 updated: 2026-11-11
decisions: decisions:
- "ADR 0667" - "ADR 0667"
- "ADR 0666" - "ADR 0666"
@@ -149,7 +149,7 @@ One file of milestone G's part of [design 47](../47-delivery-from-commit-to-deli
| `pipeline-started`, `pipeline-ended` | a pipeline's start, and its end with every step's result, its test counts, the source revision and `widens` | | `pipeline-started`, `pipeline-ended` | a pipeline's start, and its end with every step's result, its test counts, the source revision and `widens` |
| `group-ended` | a group's one pipeline's end, on which alone its wants are written | | `group-ended` | a group's one pipeline's end, on which alone its wants are written |
| `run-started` | a run on request's start, with its members at their commits | | `run-started` | a run on request's start, with its members at their commits |
| `step-started`, `step-ended` | each step's start and end: the step, its status in the policy, its outcome, its build-input fingerprint, its test counts, for a carried result what it was carried from, and for a rerun that it is one and the caller the runtime proved, for a step that read a test run or a composition run another step asked its `shared` (G-24 §729); a bypassed step too | | `step-started`, `step-ended` | each step's start and end: the step, its status in the policy, its outcome, its build-input fingerprint, its test counts, for a carried result what it was carried from, and for a rerun that it is one and the caller the runtime proved; a bypassed step too |
| `wait-held`, `wait-ended` | a step's wait: on a person (approval, code review), on a build node, on the revision view | | `wait-held`, `wait-ended` | a step's wait: on a person (approval, code review), on a build node, on the revision view |
- §74 **What a session hears after its merge.** Between its `merge-pull` and the delivery, a session waits with `mesh_wait` - §74 **What a session hears after its merge.** Between its `merge-pull` and the delivery, a session waits with `mesh_wait`
@@ -195,14 +195,14 @@ four lines a module's tools answer; every read tool of a store also answers its
| Part (seat) | Read everything it holds | Do by hand what it does itself | Recover without help | | Part (seat) | Read everything it holds | Do by hand what it does itself | Recover without help |
|---|---|---|---| |---|---|---|---|
| the runner (`mesh-pipeline-runner`) | `show` (one pipeline whole, its steps, step log and outputs), `list` (the pipelines of a module, a branch or a commit), `stands` (what stands still, since when), `why-carried` (where a step's result was carried from), `kept` (the kept results by digest), `runner_test_runs` (each test run, G-24 §728) | `start` (a delivering pipeline for a watched branch's head), `run` (the run on request), `rerun` (one step again) | `accept` (a failed `optional` step, with why), `cancel` (a pipeline, dropping its asks), `ask-again` (a declined `approval`), `runner_test_runs_drop` | | the runner (`mesh-pipeline-runner`) | `show` (one pipeline whole, its steps, step log and outputs), `list` (the pipelines of a module, a branch or a commit), `stands` (what stands still, since when), `why-carried` (where a step's result was carried from), `kept` (the kept results by digest) | `start` (a delivering pipeline for a watched branch's head), `run` (the run on request), `rerun` (one step again) | `accept` (a failed `optional` step, with why), `cancel` (a pipeline, dropping its asks), `ask-again` (a declined `approval`) |
| the indexer (`mesh-catalog`) | `registrations` (with each one's history); `indexer_edges` (an artifact's edges per watched branch), `indexer_order` (the order of a change, its cycles named), `indexer_catalog_difference` (two revisions); `indexer_pending` (a group with its missing members) | `register`, `policy`, `watch`, `unwatch` (each on the operator's Approve) | `indexer_seed_again` (the first registrations' ask raised again), `indexer_take_in_pending` (a group taken in as gathered), `indexer_drop_pending` (dropped) | | the indexer (`mesh-catalog`) | `registrations` (with each one's history); `indexer_edges` (an artifact's edges per watched branch), `indexer_order` (the order of a change, its cycles named), `indexer_catalog_difference` (two revisions); `indexer_pending` (a group with its missing members) | `register`, `policy`, `watch`, `unwatch` (each on the operator's Approve) | `indexer_seed_again` (the first registrations' ask raised again), `indexer_take_in_pending` (a group taken in as gathered), `indexer_drop_pending` (dropped) |
| the gate (`mesh-delivery`) | `source` with a branch (`gate_source`: every branch's source revision) | — | `gate_source_again` (say `source-moved` again for a branch) | | the gate (`mesh-delivery`) | `source` with a branch (`gate_source`: every branch's source revision) | — | `gate_source_again` (say `source-moved` again for a branch) |
| the forge module (`git`) | `git_failed_steps` (the failed `required` steps it holds, by module and fingerprint, with the run that failed each) | — | `git_failed_steps_drop` (drop one, with why) | | the forge module (`git`) | `git_failed_steps` (the failed `required` steps it holds, by module and fingerprint, with the run that failed each) | — | `git_failed_steps_drop` (drop one, with why) |
| the grants part (`mesh-grants`) | `grants_callers` (the callers each verb admits, read from the seat definitions) | — | `grants_why_refused` (for an account and a verb, the grant it lacks and the definition's line that leaves it out) | | the grants part (`mesh-grants`) | `grants_callers` (the callers each verb admits, read from the seat definitions) | — | `grants_why_refused` (for an account and a verb, the grant it lacks and the definition's line that leaves it out) |
| the build seats | `steps` (the steps detected for an artifact) | `steps` with `again` (detect again) | `drop` (ADR 0664 §4) | | the build seats | `steps` (the steps detected for an artifact) | `steps` with `again` (detect again) | `drop` (ADR 0664 §4) |
| the builder (`mesh-builds`) | `builder_reserved` (each module's reserved version, §369); the released versions are the catalog's `versions` | `builder_publish_again` (publish the missing artifacts under the reserved version) | — | | the builder (`mesh-builds`) | `builder_reserved` (each module's reserved version, §369); the released versions are the catalog's `versions` | `builder_publish_again` (publish the missing artifacts under the reserved version) | — |
| the assigner (`mesh-wants`) | `assigner_why_not` (why a module is not on a machine yet: the pipeline it waits for, its hold, the placement, the node's last `running`), `assigner_compositions` (each composition run, G-24 §728) | — | `assigner_release`, `assigner_compositions_drop` | | the assigner (`mesh-wants`) | `assigner_why_not` (why a module is not on a machine yet: the pipeline it waits for, its hold, the placement, the node's last `running`) | — | `assigner_release` |
| the watchman | `watchman_views` (how far behind each part's view is, from each part's `view-waits` and first-view tools) | — | each part's `<module>_first_view_again` | | the watchman | `watchman_views` (how far behind each part's view is, from each part's `view-waits` and first-view tools) | — | each part's `<module>_first_view_again` |
| the operator-channel | `asks` (with each asker's asks held back) | — | `ask-again` (offer a held-back ask now) | | the operator-channel | `asks` (with each asker's asks held back) | — | `ask-again` (offer a held-back ask now) |
| every module that imports mesh-sdk's small object store package | `<module>_state_objects`, `<module>_sent_objects` | — | `<module>_state_objects_drop`, `<module>_sent_objects_drop` | | every module that imports mesh-sdk's small object store package | `<module>_state_objects`, `<module>_sent_objects` | — | `<module>_state_objects_drop`, `<module>_sent_objects_drop` |
@@ -230,8 +230,6 @@ and an estimated 2 mesh-sdk publishes a day, each rebuilding about 120 artifacts
| the builder | `reserved`: one key per module and `MAJOR.MINOR` (§369) | old `state` section | until its `version-released`, a release of another `MAJOR.MINOR` of the module, or `builder_reserved_drop` | a few KiB; at the cap the builder reserves nothing and says why | | the builder | `reserved`: one key per module and `MAJOR.MINOR` (§369) | old `state` section | until its `version-released`, a release of another `MAJOR.MINOR` of the module, or `builder_reserved_drop` | a few KiB; at the cap the builder reserves nothing and says why |
| the assigner | `written`: the last source revision and end count per module and watched branch (§352) | old `state` section | until the branch is unwatched | a few KiB | | the assigner | `written`: the last source revision and end count per module and watched branch (§352) | old `state` section | until the branch is unwatched | a few KiB |
| the indexer and the assigner | `inputs`: a `run` ask's input by write time and sha256 (§354) | old `state` section | until the ask's `step-ended`, at most a day | 64 MiB; an estimated 300 asks a day of under 100 KiB each is under 30 MiB; at the cap the asker refuses the ask loudly, naming the store | | the indexer and the assigner | `inputs`: a `run` ask's input by write time and sha256 (§354) | old `state` section | until the ask's `step-ended`, at most a day | 64 MiB; an estimated 300 asks a day of under 100 KiB each is under 30 MiB; at the cap the asker refuses the ask loudly, naming the store |
| the assigner | `composition-runs`: one key per candidate and machine, its program, input, ask, readers and verdict (G-24 §719) | old `state` section, `max-mib` the setting `composition-runs-cap-mib` | the setting `composition-runs-kept` (default 24 hours) after its end; deleted by the assigner (§719) | default 16 MiB; an estimated 30 candidates a day on four machines, 120 keys of at most 8 KiB, is under 1 MiB a day |
| the runner | `test-runs`: one key per candidate, level and tested packages, its ask, readers, outcome and counts (G-24 §725) | old `state` section, `max-mib` the setting `test-runs-cap-mib` | the setting `test-runs-kept` (default 7 days) after its end, deleted by the runner in the step log's order with its output object in `test-runs-objects` (§330) | default 16 MiB; an estimated 1,000 test runs a day of about 1 KiB is about 7 MiB at 7 days |
| the runner and the assigner | `findings` (§355), read by their own read tools alone; the keeper hears the findings as events (§383) | old `state` section | an entry deleted when its finding clears | a few KiB | | the runner and the assigner | `findings` (§355), read by their own read tools alone; the keeper hears the findings as events (§383) | old `state` section | an entry deleted when its finding clears | a few KiB |
| every observer (§387) | the stream `<module>-findings`: `finding-written`, `finding-cleared`, `findings-stated` (§383) | old `streams` section for a foundation part, the module's `streams` otherwise | 7 days, its oldest dropped when full; the next statement covers a lost one (§384) | 16 MiB; an estimate of a few hundred findings a day of about 1 KiB is under 2 MiB a week | | every observer (§387) | the stream `<module>-findings`: `finding-written`, `finding-cleared`, `findings-stated` (§383) | old `streams` section for a foundation part, the module's `streams` otherwise | 7 days, its oldest dropped when full; the next statement covers a lost one (§384) | 16 MiB; an estimate of a few hundred findings a day of about 1 KiB is under 2 MiB a week |
| the condition keeper | `findings-views`: one key per observer and node, its last stated set, pending keys and open asks (§388) | the form of its `conditions` | deleted when the module leaves the catalog or the node (§365) | under 1 MiB; about 30 observers on four machines | | the condition keeper | `findings-views`: one key per observer and node, its last stated set, pending keys and open asks (§388) | the form of its `conditions` | deleted when the module leaves the catalog or the node (§365) | under 1 MiB; about 30 observers on four machines |
File diff suppressed because it is too large Load Diff
@@ -1,209 +0,0 @@
---
layer: to-be
status: in-progress
design: 47
milestone: G
updated: 2026-11-17
decisions:
- "ADR 0667"
---
# 47, milestone G — what is owed once G is delivered
The list of what waits for G's delivery: the operator's remarks deferred while G was brought up, the stand-ins the
lead's answers mark to go after G, the hand state of G's live start, and the faults met on the way. It is checked when
G is delivered: each item is then removed, taken into a design or a record through its playbook, or noted on the issue
that covers it (asking the operator before a new issue). An item is struck from this list in the same pull request that
deals with it, which is how the list is kept true.
## The operator's remarks (2026-11-14, deferred until G is live)
1. **Two graphs only:** the catalog graph and the assignment graph. Each node's modules publish the state they own and
the version they run on the bus; a gap between the assignments and what a node says is closed by the node-engine.
2. **What a node can run is checked only on assignment and un-assignment** (for the modules that depend on it), never
as an input to every computation. The glossary's *assignment graph* and ADR 0656 say the assigner computes from the
catalog graph, the placements and the nodes' capabilities: check the record and the code against this.
3. **Assignments enter as commands** (the seat `mesh-module-assigner`'s `propose`: place, take off, ...); the assigner
computes no placement, it only derives each placed module's version from the catalog graph into the wants. Check the
glossary's wording against this.
4. **A pin** ("use this provider for this provision") may not belong in the assignments at all: question it, and what
the provision wiring should be instead.
5. **Who says a node's running versions:** the node-engine (its haves) or each module itself. The operator's picture
is each module; check which the design means.
6. **One address for a seat's view.** A reader's manifest names the assigner's view by its seat, the reader's code asks
the holder module's tool by its module name, and the grants part translates one into the other (and gave only the
events, not the right to ask: the indexer's first view was refused at G's live start). One address, the same in
manifest, code and rights.
7. **A registration is part of the module graph, not a list beside it.** After G's start the module graph held 178
modules while the registrations held none, with a seed ask to copy them from the old registry. Check the design
against one graph whose entries are the registrations and what each registered repository says.
8. **One bookmark (durable consumer) per process, never shared** (A-397). A module's program and its tool runner read
events under one durable name; the runner took all 178 first registrations and the program heard none, silently.
Share a durable name only for shared work (a queue). Owed: amend design 19's "one durable consumer per module"
(written when a module was one process) and the lines of designs 25, 32 §3, 57, G-5 and G-8 that follow it; build
per-process names in the grants part, mesh-sdk's process hub and the tool runner, with a start refusal and a log
line; the test of two processes of one module both hearing one event on a real bus; a check that a durable has one
reader; and a design-review playbook question: "what if two processes of one module do this?"
9. **The same mistake elsewhere.** A survey at G's start found it live in three modules (the assigner, the indexer and
the grants part: the runner acks and drops what no tool view wants) and possible in every module whose tool runner
arrives later (builder, checker, forge bridge, pipeline runner, teller, view, watchman, distribution, recovery).
Already avoided: the bus and zfs keepers (A-340), the node-engine, work queues. Also: a seat verb served by both a
program and its runner in one queue group splits the answers between them; durables nothing reads keep pending
messages.
10. **`registration-changed` is said for a first registration too:** check the event's name against what it says.
11. **Silent waits met during G's start:** the indexer's first versions fill returns without a word while another fill
runs, so a hung fill held every later one silently for two hours; `grants_membership` and `grants_assert` time out
after 30 seconds with no log line; the tool runner says a dropped event once per key.
12. **The module graph's edges are dependencies, never verbs or bus subjects** (2026-11-16; principle 9): a manifest
says what its module depends on, a seat where the need is meant to be interchangeable and otherwise a module (a
build dependency on a package module, a program needing another module), and the graph's edges come from that
alone. The verb edges of ADR 0614 §2 and §3, and the cycle exceptions they needed (A-361, A-428, A-437), go; whether
`invokes`, `uses` and the `views` forms stay in a manifest at all is asked with the research on the mesh's
accounts, and "each fact is declared in one place".
13. **A full delivery cycle by hand** (the operator, 2026-11-17 about 09:00: "make sure that every part of the
build-and-delivery system is also doable by hand via mcp tools", "so you can fully take control of a full cycle";
asked when, "after G"; principle 4). A survey of 2026-11-17 found, along the cycle merge, the gate's source,
take-in, entries, pipeline, steps, release, wants, grants, put and running: about 52 acts a module does by itself
with no hand tool, about 110 bus states with no per-key clear and 26 with no read tool, all but one of about 25 capped
states with no fill against their cap, and 14 recoveries with no tool. One milestone: the SDK's state tools for
every declared state (read, fill against cap, clear a key, drop key-gone objects), the missing hand acts per module,
a summary of the pipeline runner's pipelines by outcome, `source-moved` and the runner's `ended` declared so they
can be waited on, and the catalog check that refuses a module whose state or act has no tool. Also a consumer
composed from the union of the want's and the trunk's manifests, as grants already are (a bundle's new `consumes`
is unbound until a want names its build).
14. **No pass waits on a call** (principle 1; from the node-engine's #233 (`mesh-host`), A-461b): the node-engine's composer asks the seat
mesh-catalog's `module` for a trunk build at the top of every pass and waits up to the call's bound, so a seat that
answers slowly stalls every pass. The ask goes beside the pass, which composes with what it holds and takes the
answer at the next pass.
## Met during G's start (2026-11-14)
- **The seed of registrations** left out modules whose manifest lives in the application's own repository on its
watched branch, so they were assigned but unheld and the assigner refused every proposal (ADR 0567 §2). The seed
should register every assigned module from where its manifest is.
- **The indexer's catch-up and take-in** say nothing in the indexer program's journal.
- **The provisioner** drops a published composition with neither plan nor refusal silently and then removes the
node's plans; no read tool shows a node's composition.
- **The node-engine** is refused the builder's `build.ended` by the bus every five minutes: the grants part does not
give it; to fix before builds matter.
- **The register verb refuses an unprotected watched branch:** the operator approved removing the check (from the
seat `mesh-catalog`'s definition and the indexer that serves `register`).
## Stand-ins the lead's answers mark to go after G (2026-11-16)
- **A-436 with A-430b:** a want carries parts beside its version for a node-engine that reads parts, and a module
wanted with no passed pipeline names the parts its `build.ended` made until its release is heard.
- **A-438:** for an acting wait, a running have whose node-engine states no health counts as healthy, and an online
node runs its node-engine; goes when every node-engine states health.
- **A-439:** `assigner_written` with `why` answering for `assigner_why`.
- **A-434:** every account may do everything, and every seat verb admits every caller, until the research on the
mesh's accounts replaces it (the operator, 2026-11-15: three accounts, mesh, agent and operator; approval only as a
per-tool mark for agent calls).
## Hand state of G's live start (2026-11-16)
- **Runtime drop-ins on the control-node** that pin a hand-made fingerprint (and the tool runner's environment) for
the grants part, the teller, the forge bridge and the tool runner. A delivery does not remove them: each goes before
its module restarts on the delivered build, or the module believes it runs the old one.
- **Hand-placed builds** (the indexer and its tools, the tool runner, the control-node's node-engine, the assigner) are
replaced only by their deliveries; check each is.
- **About 80 hand-built modules on the control-node have no catalog entry:** their first move is held for a backup
(the kept-form hold).
## Faults met on the way (2026-11-16; note each on the issue that covers it)
- `node-files.delete` cannot move a root-owned file to the trash; `node-service-manager` has no daemon-reload.
- The indexer does not stop on SIGTERM: it keeps draining build-log entries until systemd kills it.
- The backup ask's headline says "backup failed" for a kept-form hold.
- The assigner logs a line naming about 140 modules every one to three seconds, and did not raise the backup ask
again after a restart.
- `mesh_wait` refuses the operator channel's events: `operator-channel` is neither a seat nor a module of the catalog
half.
- Four tests of mesh-delivery fail on main, reading files that do not exist there: `sdk`'s
`TestThePackageArtifactNamesNoPathForTheWholeDirectory`, `sdk/buildstep`'s two fixture tests and
`meshdeliveryclient`'s `TestTheRemovedVerbsAreTheDefinitionsRemovedRows`.
- The node-engine's repository holds about 1721 unit tests against the budget of 500.
- The live indexer was seen refusing the assigner's manifest for claiming `mesh-placement`, which neither main nor
G's branch claims: confirm the verdict after G's take-in.
## Tests run against what runs (the operator, 2026-11-16 about 13:00 CET)
- **A test runs against the bus as the mesh composes it.** The pipeline runner's integration test made its own
shared event stream catching every seat event, so a step's end reached the runner there; on the live bus a step's
end is a kept event on a stream of its own, which the runner never bound, and no pipeline could pass (fixed in the
runner at G's start, 2026-11-16). Wanted: a principle ("a test runs against what the module runs against: the bus as
the mesh composes it from the manifest, never a layout written in the test"); the shared library gives an
integration test the streams, kept streams and consumers the composition makes for the module's manifest; every
integration test that creates its own streams moves onto it (count them first); the runner's test publishes a step's
end on the kept stream.
- **A handler of a kept event is heard or fails loudly.** Starting a program's events binds only the shared stream;
kept seat events need a second call, and a program that registers a handler for one and never makes it hears
nothing and says nothing. The shared library binds the kept streams of every registered handler itself, or refuses
to start.
## One way of asking work (2026-11-16)
- The builder, the pipeline runner, the indexer (its validation before a take-in) and the checker each ask the build
seats in a shape of their own; the validation rides the check queue behind pipeline steps (a 6-second validation
waited over 20 minutes). Parked by the operator for research right after G: one generic pipeline for work and gates.
- An ask given again after a fix keeps its old form (a step asked with no module directory came back without one).
- The builder asks a failing build again every two to three minutes, reserving a new version each time.
- The builder's queue tool lists only the oldest 50 waiting entries (left over from 2026-11-14), so it cannot show
what waits now.
- The pipeline runner serves no tools on the control-node and logs nothing per step; the build seat's step events say
no pipeline before a step ends; `mesh_wait` refuses the build seats' and the runner's events; the bus's stream reader
cuts a body at 4 KiB; a running test step logs nothing.
- `TestTheBuildModulesKeepNoCopyOfTheDeliverySDKsStepCode` fails on mesh-catalog's main (the empty
`modules/mesh-build-go/buildstep` directory); the seven `checks/` tests, nats-tools and distribution fail in a run over
the whole of mesh-catalog.
- The glossary's **pipeline** and **pipeline step** entries leave out the build, which the runner asks as the step
`build` of the seat `mesh-builds`: correct them.
- A pipeline the runner set aside before A-446 with steps already written (`main.940.mesh-delivery-sdk`) is started
again by neither of the runner's start paths.
- The node-engine's journal and the have's phases say a module is "held" and that the node "keeps running what it
runs" for one thing: a module left on the build it runs, its new build not applied. The operator, 2026-11-17, wants
those words gone: retire "held" and "kept" in that sense from the node-engine's lines and the glossary, with one
glossary word in their place.
- A composition that passes on every machine as "not judged: the composer was handed no seat list" is reported as
passed: a composition step that judged nothing must fail or say so (principle 3).
## From the composition runs of 2026-11-17
- **The node-engine answers `compose-candidate` with different bytes for one candidate.** Within 30 seconds the
assigner kept twelve inputs of exactly 1,491,623 bytes with different digests for the same revision. The bytes differ
in the node-engine's answer, not in the assigner's request; a guess, not checked: a slice whose order changes between
asks, perhaps `ComposedHow.Running`. Under design 47 G §718 one composition run per candidate and machine asks each
node once, so this no longer multiplies anything and stays out of G (principle 7; the coordinator, 2026-11-17). After
G: find it by comparing two kept inputs of one node, read by digest through `mesh-wants`' `input`, and decide whether
the answer must be the same bytes while the node is unchanged.
- **Design 47's main file and G-22 are split** (playbook 02, *The shape of a design*). The main file is about 250 KB
against its 80 KB bound, and G-22 about 165 KB against a milestone file's 60 KB. The operator decided at 10:31 CET on
2026-11-17 that the split comes after G, as a separate amendment.
## Faults met on the way (2026-11-17; note each on the issue that covers it)
- **The assigner's long line, met a second time.** On 2026-11-17 from 11:02 CET the assigner on the stable node logs,
several times a minute, that "the manifest of the running build of" about 100 modules "cannot be read, so what the
module graph says they serve is counted as served". Cause not yet known: nearly every module is named, so the
assigner reads the running builds' manifests where none is kept. Being the second meeting, its fix is folded into
G-24's assigner change once A1 to A7 are built. Cause found the same day: the assigner reads a running build's
manifest only from the builder's end in its stream, which the builder has said only since 2026-11-11, so no build
made before then has one. G-24 says the list once per change of the set; after G, the builder says the end of each
build it keeps into its stream once (principle 1; the alternative, reading the catalog entry at that fingerprint,
reads another module's data).
- **The Node build modules disagree on their toolchain.** On 2026-11-17 shanks's recipe differed from the other three
nodes', and g14 ran Node v26.13.1 against v26.13.0, so no version and recipe held a majority, and lidarr, radarr and
gitea had no fingerprint at revision 449 (A-470j keeps that from leaving whole machines not judged). After G: one
version and one recipe declared through the mesh on every build node.
- **The catalog had not taken in the node-engine's merge #234** by revision 450 (2026-11-17 about 11:50 CET), and the
indexer's module reads answered "no responders": read why after G-24's delivery.
- **The builder's and teller's integration tests fail only the 30 s setup bound under load**, and pass idle: the bound's
kind (a setup bound judged on a busy build node) is decided after G.
- The runner's journal floods with ends that name `pipeline ""`: the build seats' run asks are heard on the runner's
subjects.
- `TestAProposalIsAnsweredApprovedAndWritten` (assigner) fails on main; `TestTheNodeComposesItsWantsFromTheBus`
(node-engine) fails now and then.
- `mesh-enrolment` is placed on no node, so its composition step can never run and it never releases.
- `claude_code_wait`'s `said` refused a wait past its bound; `mesh_wait` cannot wait on the gate's `source-moved` nor on
the runner's events.
@@ -1,290 +0,0 @@
---
layer: to-be
status: in-progress
design: 47
milestone: G
updated: 2026-11-17
decisions:
- "ADR 0667"
- "ADR 0666"
- "ADR 0596"
- "ADR 0564"
- "ADR 0267"
---
# 47, milestone G: one composition run per candidate and machine, one test run per level and tested packages
One file of milestone G's part of [design 47](../47-delivery-from-commit-to-delivered.md); the part opens at
[G.md](G.md). Its design lines are numbered across every file of the part and cited as "design 47 G §n".
*§718 to §733 come from milestone G's live delivery of 2026-11-17. The 24 pipelines of one catalog revision asked 96
composition runs, one per pipeline and machine, and 80 more when they were asked again. Each run kept its own copy of
a node's input of 1.1 to 1.5 MB in the assigner's state `inputs`, which reached its 64 MiB cap twice. The indexer's
and the teller's same failing tests failed once per artifact. The operator, 2026-11-17 about 10:20 CET: "In G, now".
Each line is a choice within ADR 0666 §7, §8 and §17, settled by the principle it names. The review by architectural
domain of 2026-11-17 was answered by the lead in A-466 to A-466l (G-22), each cited at the line it settles.*
### Composition runs
- §718 **One composition run per candidate and machine.** (§354, A-226, A-243, A-252, A-466l; ADR 0666 §17; principle
7) The assigner, holding the seat `mesh-wants`, composes each machine once per candidate, whatever number of
composition steps name it. The candidate is named by its key (A-226): `<branch>.<revision>` for a branch pipeline,
`run-<id>` for a run on request. The first composition step of a candidate that needs a machine starts that machine's
composition run: one `compose-candidate` ask of the node, its request kept once in `inputs`, one `run` ask on
`node-build-go`. Every other composition step of that candidate whose module is placed on that machine (A-252) reads
that run's verdict, under §720's rules. The request carries the candidate's manifests, verdicts and seat
definitions, depth compose, the one machine and the case `change`, and the node's own `compose-candidate` answer at
the moment the run started; it carries nothing of the module whose pipeline asked it. A step of the same candidate
that comes later so reuses a verdict composed from the node's answer of that earlier moment, knowingly: within one
candidate, that answer is the machine as the candidate is judged on it (A-466l). The composer program is chosen once,
when the run starts, by A-252's and A-451's rule, and recorded in the run. This replaces "one run ask per machine" for
each composition step (A-243, A-252) with one per candidate and machine.
- §719 **Kept in the assigner's state `composition-runs`.** (§354, §85; ADR 0666 §4, §7; A-466e; principles 1, 2, 7 and
11) Each composition run is one key of the assigner's old `state` section `composition-runs`, whose `max-mib` is the
assigner's setting `composition-runs-cap-mib`, default 16. The key is `<candidate key>.<machine>`, each part escaped as
a key's name (`keys.EscapeName`). The step that starts the run writes the key create-only, so two steps of one
candidate starting at once start one run and the second reads it. The value holds:
- `candidate` and `machine`;
- `program`: repository, commit, directory, and the node-engine fingerprint it was chosen from;
- `input`: the digest of the kept request;
- `ask`: the id of the build seat's run ask;
- `started`;
- `readers`: the step keys of the composition steps reading the run, each added and removed by compare-and-set;
- at the run's end, `ended`, `outcome` (`passed`, `failed` or `could not run`, with its words) and `verdict` (that
machine's composer verdict, §721).
A step waiting on a running composition run hears its end through the assigner's own watch of that key (a module
watches its own state, principle 1). At its start the assigner takes up again each key with no `ended`, by its
`ask`'s `step-ended` (A-240) and the bound of §720. The assigner deletes a key once the time its setting
`composition-runs-kept`, default 24 hours, names has passed since its `ended`; both this and the bound are judged as
the state `inputs` is (A-465b). At the cap no run is started, and its steps end `could not run`, naming the fill (as
A-465a).
- §720 **What a run's result serves, and its bound.** (§75, §86, §718; ADR 0666 §8, §17; ADR 0596; ADR 0564 §2;
A-466, A-466b, A-466n, A-466p, A-466q, A-466s; principles 1 and 3)
- **Within its candidate only.** An ended run's verdict is read only by composition steps of the same candidate. A
step of another candidate starts a run of its own; nothing composed for one candidate crosses to another.
- **`could not run` is never read.** A step that finds an ended run whose outcome is `could not run` starts a new
run, replacing the key by compare-and-set; its former readers have already ended `could not run` with it.
- **The bound times owed progress, not run length** (§75; ADR 0564 §2; A-466n, A-466p). A run has one clock: a bound
key `bound.<run key>` in `composition-runs`, with its own time to live (A-77, A-101). The assigner writes it at
the build seat's `ask-taken` of the run's ask, and writes it again at each `step-progress` of that ask, its time
to live the assigner's setting `composition-step-bound`, default 30 minutes. An ask still waiting in the queue has
no clock: it is timed by §86's build-capacity finding, since a `could not run` for a run that only waited for a
build node would say what is not true. A run that runs past 30 minutes and keeps saying its progress is never
ended by it.
- **When the clock ends.** Its expiry, heard as the bus's event, ends the run: the assigner drops its ask (§119,
A-182), writes `ended` with `could not run` naming the ask and the bound, and ends every reader `could not run`
with it. A `step-ended` of that ask heard later is ignored, said in its journal with the ask and the run's key.
- **A run never taken** (A-466s). A run whose ask has no `ask-taken` within the assigner's setting
`run-untaken-bound` after its `started`, default 24 hours, ends `could not run` the same way, naming the bound;
§86's `build-capacity-waits` says it meanwhile.
- **What the assigner hears** (A-240, A-466q). Its manifest gains `consumes` entries for the build seats'
`ask-taken` and `step-progress`, heard on its durable consumer as A-240 hears `step-ended`. The assigner never
reads the build seat's state (ADR 0596).
- §721 **A machine's verdict names the modules it blames.** (ADR 0666 §17; A-452, A-466g, A-466h, A-466r, A-466u; principles 10, 3, 7
and 11) The composer's verdict of a machine (mesh-delivery-sdk's `composer.Machine`, answered by the node-engine's
`mesh-compose`) gains `blamed`, a list of `{module, problem}`.
- **What it names.** Each module that the candidate's composition of the machine holds or refuses and the
composition without the candidate does not (the modules in its input's `HeldBefore` are left out). Two modules
owning one path are each blamed, with that path. `composes` stays false when the machine does not compose with
every module of the candidate. A machine that does not compose and blames no module fails on the node's own
account (its own composition, or no module composed at all, as A-452 has it).
- **How culprits are found, and its bound.** Only the candidate's changed modules placed on the machine (those whose
entry in the candidate differs from the composition without it) are held, one at a time, each try composing once
more; the search ends at the first module whose hold ends the problem, as the indexer's validator names a manifest
whose removal ends a problem. It composes at most once per such module plus once, never more than `blame-tries`, the
assigner's setting, default 20, carried in the run's request to the composer (the request's field
`blame-tries`), since the composer program has no settings of its own (A-466r); past that bound, the modules not yet tried are named in `blamed` with the words
"not tried: the search reached its bound".
- **An old composer.** A verdict with no `blamed` field (a node-engine's composer from before this line) is judged as
today: a machine that does not compose fails every composition step placing a module on it, with the warning "the
composer names no culprits".
- **No order between them.** mesh-delivery-sdk's `composer` package is published before the node-engine and the
assigner build (an edge of kind 1, as for every package); nothing orders the node-engine's composer before the
assigner, since an assigner meeting an old composer judges as today (A-466u).
- §722 **One module's fault fails only its own pipelines.** (§721; ADR 0666 §9, §17; A-452; principles 10 and 3) A
composition step judges each of its machines from that machine's verdict:
- `failed` when the verdict blames the step's module, or when the machine does not compose and blames no module;
- `could not run` when the composition run could not run;
- `passed` otherwise, with a warning for each module blamed there that is not the step's own (`<machine> holds
<module>: <problem>`). Another module's fault is so said in every pipeline it touches and fails none of them.
The step's outcome then follows from its machines, as today: failed before could not run before passed (§354). A
machine that is away passes with a warning and is not composed (§64).
- §723 **How a composition run ends and is said.** (§73, §116, §119, §496, A-182; ADR 0666 §7, §21; A-466j;
principles 1, 7 and 8) A composition run says no event of its own. Its end is the build seat's `step-ended` of its
`ask`, which the assigner alone hears (A-240). Each composition step reading the run says its own `step-ended` on
`mesh-wants`, as today, with its own build-input fingerprint and `shared` (§729), naming per machine the run it read,
that run's `ask` and its verdict: the result was taken from the build seat's holder once, at that ask, and the step
names it, as §25's carry names where a carried result came from (ADR 0666 §21). Each reading step says its
`step-progress` once a minute while it waits (A-262), naming the runs' asks in `shared`. A step that is superseded or
cancelled leaves `readers`. The run's `ask` is dropped (§119, A-182) only when no reader is left, so a superseded
pipeline never takes away another pipeline's composition run.
### Test runs
- §724 **One test run per level and tested packages.** (§22, §25, §27, §416; ADR 0666 §8, §17; ADR 0267 §1; A-466,
A-466d; principles 3 and 7) The runner asks a lint, unit test or integration test step of a build seat once per
candidate, level and tested packages, whatever number of artifacts' steps name them. A test step's candidate is its
pipeline's in A-226's form: `<branch>.<revision>`, or `run-<id>` for a run on request. A module's program and its
tools bundle are built from different import closures (ADR 0267 §1), but their test steps run the packages of one
directory (the build seat's `steps`, §22), so one set of tests is run. The share digest is the sha256 of:
- the step's build-input fingerprint with the artifact's own part left out (its program's package and recipe), so two
artifacts of one directory meet;
- the step's status in the policy (§23), so the key is §25's carry key: two artifacts whose policies differ do not
share;
- the sorted lines `<package>@<digest>`, one for each package the step would run after its carry (§25: those with no
kept result for their digest), the digests being those the runner already reads for its carry (§416).
The first step of a key puts the build seat's `step` ask; every other step of the same candidate with that key reads
its result. An ended run's result is read only within its candidate; a step of another candidate asks a new run, and
a passed result crosses candidates only as §25's carry, through `kept`. A `could not run` result is never read: a
step finding one asks a new run, replacing the key by compare-and-set. So within a candidate the same failing tests
fail once, not once per artifact, and a second revision with the same digests runs a failed test again.
- §725 **Kept in the runner's state `test-runs`.** (§27, §85, §330; ADR 0666 §4; A-466e, A-466f, A-466p, A-466v; principles 1, 2, 3, 7
and 11) Each test run is one key of the runner's old `state` section `test-runs`, whose `max-mib` is the runner's setting
`test-runs-cap-mib`, default 16. The key is `<candidate key>.<level>.<digest>`, each part escaped as a key's name,
written create-only by the step that asks the run. The value holds:
- `level` and `digest`; the list of packages with their digests is in the run's output object, never in the key or
the value;
- `seat` and `ask`, and `node` once a holder has taken the ask;
- `started`;
- `readers`: each reading step's pipeline key and artifact, added and removed by compare-and-set;
- at the run's end, `ended`, `outcome`, its test counts, and the name of its output object.
A test run's output object is kept in the state's own object store `test-runs-objects`, an old `objects` section
with no age of its own, so it lives exactly as long as its key, whatever `step-outputs`' 7 days (A-466v); a step's
own output stays in `step-outputs` as today. A reader whose run's object is gone (a drop, a fault) answers its run
without the packages, saying "the run's output is gone".
The runner hears the run's end as the build seat's `step-ended` of its `ask`, on its durable consumer, as it hears
every step (§24). A test run has §720's one clock, a bound key `bound.<run key>` in `test-runs`, written at the
build seat's `ask-taken` of its ask and again at each `step-progress` of it, its time to live the runner's setting
`test-step-bound`, default 30 minutes; an ask still in the queue is timed by §86's build-capacity finding alone. Its
expiry ends the run as §720's does: the ask dropped (§119), every reader ended `could not run`, a later
`step-ended` of the ask ignored and said in the journal. A run whose ask is never taken ends `could not run` at the
runner's setting `run-untaken-bound`, default 24 hours after its `started` (A-466n, A-466p, A-466s). The runner
consumes `ask-taken` already (§647); its manifest gains `step-progress` where it does not consume it. At its start the runner takes up again each key with no `ended`, by its
`ask` and that bound. It deletes a key once the time its setting `test-runs-kept`, default 7 days, names has passed
since its `ended`, in the step log's order as §330 ages its `pipelines`, and deletes the run's output object from
`test-runs-objects` with the key, after the last reader's end. At the cap no run is asked, and the step ends `could not run`, naming the fill, as
§719 has it, with no condition of its own. A passed run's results go into `kept` per package, as today (§27), so a
step asked after the key is deleted carries them.
- §726 **How a test run ends and is said.** (§24, §73, §119, §419, §496; ADR 0666 §8, §21; A-466i, A-466j; principles
3, 7 and 1)
- **Each reading step is said.** Each step reading a test run says its own `step-started` and `step-ended`, with its
own build-input fingerprint and `shared` (§729). Its `step-ended` carries the run's outcome and counts. Its
`step-started` names the run's `ask`, so the watchman times it from that ask's `step-progress` (§496). The result
was taken from the build seat's holder once, at that ask, which the step names, as §25's carry does (ADR 0666 §21).
- **Counted once.** `pipeline-ended` counts a module's tests once per pipeline and test run, never once per step
reading it (§24, §419).
- **Dropped only with its last reader.** A step that is superseded or cancelled leaves `readers`, and the run's ask
is dropped (§119) only when no reader is left.
### For both kinds
- §727 **Asking a run again moves every reader.** (§30, §73, §83 `rerun`, §29; ADR 0666 §9, §11, §24; A-466a;
principle 3) One rule for composition runs and test runs. A `rerun` of a composition step (for each machine whose
verdict in it was not `passed`) or of a test step joins the run of its key while that run is running, reads one that
started after the step's last end, or otherwise starts a new run, replacing the ended key by compare-and-set and
carrying the former run's `readers` into the new value. The new run's end moves every step that read the former run
and did not pass: each says `step-ended` again with the new outcome, marked as a rerun with the caller of the step
asked again (§73). A moved step reopens its pipeline, which says `pipeline-ended` again with a higher end count; the
assigner writes wants only from a pipeline's latest end (§29). A step a person `accepted` (§30) does not move: a
person's act stands. A machine that passed in a composition step keeps its verdict. A step left reading a failed
result would say what is no longer true. So twenty composition steps of one revision asked again together start one
run per machine.
- §728 **The tools.** (§83, §391; ADR 0666 §25; A-466c; principle 4) Two for each new state, in §83's table:
- `assigner_compositions` (class `read`) takes a candidate, a machine, or neither, and answers each composition run
with its program, input digest, ask, readers, outcome and verdict, and the state's fill against its cap.
- `assigner_compositions_drop` (class `act`, §391's default callers) takes `{candidate, machine, why}`. It writes the
hand-act log first, drops the run's ask, ends each reader `could not run` naming the drop, and deletes the key.
- `runner_test_runs` (class `read`) takes a candidate, a level, a digest, a module, or none of them, and answers each
test run with its packages (read from its output object), ask, node, readers, outcome and counts, and the state's
fill against its cap.
- `runner_test_runs_drop` (class `act`, §391's default callers) takes `{key, why}` and does the same as
`assigner_compositions_drop`, deleting the run's output object with the key.
- §729 **`shared` in the seat contracts.** (§73, §116, §496; ADR 0666 §21, §24; A-466j; principles 1 and 8) The seat
definitions in mesh-delivery's `mesh-delivery-contracts` change, and the contracts' code is generated from them by
`seatgen`, never edited by hand:
- **`mesh-wants`' `step-ended`** gains `shared`: a list of `{machine, run, ask}`, one per machine composed, `run` the
`composition-runs` key and `ask` its run ask's id, all strings.
- **The composer's request** (mesh-delivery-sdk's `composer.Request`) gains `blame-tries` (a number, §721).
- **`mesh-wants`' `step-progress`** gains the same `shared` list, naming the runs the step waits on.
- **`mesh-pipeline-runner`'s `step-started`** gains `shared`: `{run, ask}` for a test step, `run` the `test-runs` key
and `ask` its build seat ask's id, strings.
- **`mesh-pipeline-runner`'s `step-ended`** gains `shared`: `{run, ask, asked-by}`, `asked-by` being `{pipeline,
artifact}` of the step that asked the run (strings), left out for that step itself.
- **`mesh-pipeline-runner`'s `stands`** answer: each entry gains `ask` (string) and `shared` (`{run, ask}`, strings,
where the runner knows it), as §731 says.
A step that names `shared` names its own build-input fingerprint beside it, as every `step-ended` does (§73). A
composition step's `step-started` is said by the runner when it asks the assigner, before any run is chosen, so it
cannot name the runs' asks; the assigner, the part that knows them, names them in its `step-progress`, and the
watchman times a composition step from that (§496, A-262, A-466m).
- §730 **What runs in flight, and going back.** (§65, §78; ADR 0666 §19, §24; ADR 0667 §9; A-466k; principle 3) A
composition step or test step asked before the new assigner or the new runner runs ends by the path it was asked
under, one run per step; composition runs and test runs are made only for steps asked after the new part runs. A
return to an earlier build (§78) leaves `composition-runs` and `test-runs` unread; their readers are ended `could not
run` by the bound of §720 and §725 once the new build runs again. Until then the earlier build applies no such bound,
and a reader standing still is said by the watchman as `pipeline-stands`, by §732 (A-466o).
- §731 **The runner's `stands` names what a reading step waits on.** (§75, §83; A-466t; principles 3 and 4) `stands`
already answers every pipeline step started and not ended whose outcome is running or waiting (mesh-delivery's
runner on main, its `Stands` read), so a composition step waiting on the assigner is in it. Each of its entries
gains `ask`, the step's own ask (§496), and `shared` where the runner knows it (§729, a test step's run key and
ask). At its start the watchman seeds §732's open steps from it, each clock begun at that moment, and times each by
those asks from then on.
- §732 **The watchman times every step that reads a run.** (§75, §496, §602; ADR 0564 §2, §4; ADR 0666 §24; A-466o;
principles 3 and 1) §75 and §496 time each pipeline step from its `step-started` or its latest `step-progress`, but
the watchman on main times only a build seat's running ask (its `ask-taken` and `step-progress`) and a step queued
for a build node; a step whose run has ended, or a composition step waiting on the assigner, is timed by nothing.
From G the watchman also:
- **hears** the runner's `step-started` and `step-ended` of every pipeline step (it consumes them already, for the
build capacity), and `mesh-wants`' `step-progress`, a `consumes` entry its manifest gains;
- **keeps** each started step with no `step-ended` in memory under `<pipeline>/<step>`, its clock begun at its
`step-started` and begun again at each `step-progress` whose `ask` is the step's own ask (§496) or an ask its
`shared` names (§729), and at the `step-ended` of the run's ask a test step names;
- **raises** `pipeline-stands` for that step when its clock passes the watchman's existing five-minute progress bound
(§75), naming the pipeline, the step and the ask it last heard of, and clears it at the step's `step-ended`. A
step said waiting on a person, or queued for a build node (§86), is owed no progress, as today;
- **seeds** its open steps at its start from the runner's `stands`, as §75 has it.
So a reader that neither the assigner nor the runner ends, after a return to an earlier build or any fault, is said
within five minutes of its last sign of life.
- §733 **How it is checked.** Tests 108 and 109.
- **Whole (assigner, mesh-delivery), test 108.** Two composition steps of one candidate started at once make one key,
one request and one run ask. Three composition steps of one revision on two machines start two runs, and each step
reads both verdicts. A machine whose verdict blames module A fails A's composition step and passes B's, with a
warning naming A; a machine that does not compose and blames no module fails both; a verdict with no `blamed` is
judged as today and says "the composer names no culprits". A step of another candidate starts its own run, and a
`could not run` result starts a new one. A taken ask with no `step-ended` and no `step-progress` for 30 minutes
ends `could not run`, with its readers and its ask dropped, and a `step-ended` of that ask heard later is ignored
and said in the journal; a run past 30 minutes that keeps saying its progress is not ended; an ask never taken
ends `could not run` at `run-untaken-bound`. Steps asked again together start one run per machine that did not
pass, and move every former reader; a reopened pipeline says `pipeline-ended` again. A superseded step leaves the run running for its other readers. An assigner restarted during a run takes it
up again by its ask. At the cap a step ends `could not run`, naming the fill. `assigner_compositions_drop` ends the
readers and deletes the key, and a reader-only account calling it is refused.
- **Whole (the node-engine's composer, `mesh-host`).** A fixture module whose manifest is refused on the machine is
blamed by name, two modules owning one path are both blamed, and the search past the request's `blame-tries` names
the untried.
- **Whole (runner and Go build module, mesh-delivery and mesh-catalog), test 109.** A module whose program and bundle
test one directory asks one unit step and one integration step, and both artifacts' steps end with that result and
`shared`. A failing test fails once, and `pipeline-ended` counts the module's tests once. A rerun of one artifact's
failed step that passes moves the other artifact's step to passed too, and the pipeline says `pipeline-ended` again;
an `accepted` step does not move. A runner restarted during a run takes it up again by its ask. A replaced reader
leaves the ask to the other readers. At the cap a step ends `could not run`, naming the fill. A run past 30
minutes that keeps saying its progress is not ended, and a taken ask silent for 30 minutes ends `could not run`
with its readers. A test run queued past five minutes with a holder present is not failed (A-466y). A second
revision with the same digests runs a failed test again. `runner_test_runs_drop` deletes the key and its output object, and a
reader-only account calling it is refused.
- **Unit (runner).** A test run whose output object is gone is answered by `runner_test_runs` and its readers
without its packages, saying "the run's output is gone"; the object outlives `step-outputs`' 7 days while its
key lives.
- **Whole (watchman), tests 108 and 109.** A composition step whose `mesh-wants` `step-progress` stops raises
`pipeline-stands` within five minutes; a test step whose run's ask ended with no `step-ended` of the step raises it
five minutes later; each clears at the step's `step-ended`; a step waiting on a person raises nothing; a watchman
restarted while a composition step waits on the assigner seeds it from `stands` and raises it if no progress
follows.
- **Live.** In the first publish after G's delivery, the composition run asks of each revision number at most its
machines, read with `assigner_compositions` and `assigner_inputs`; each module's test steps run once per level, read
with `runner_test_runs`.
+2 -4
View File
@@ -3,7 +3,7 @@ layer: to-be
status: in-progress status: in-progress
design: 47 design: 47
milestone: G milestone: G
updated: 2026-11-17 updated: 2026-11-12
decisions: decisions:
- "ADR 0500" - "ADR 0500"
- "ADR 0673" - "ADR 0673"
@@ -88,7 +88,7 @@ file on 2026-11-10, and is cited as "design 47 G §n". A sentence that holds a d
stayed in the main file, and G builds what it says from G's delivery. A section named in italics is in this part, or, stayed in the main file, and G builds what it says from G's delivery. A section named in italics is in this part, or,
when it is not here, in the main file. when it is not here, in the main file.
The part is twenty-four files, each read whole, its design lines numbered across them: The part is twenty-two files, each read whole, its design lines numbered across them:
- [G-1-pipelines-registration-and-steps](G-1-pipelines-registration-and-steps.md): pipelines per module: registration, watched branches, steps and policy, what holds a delivery, approval, groups, dependencies, a publish. - [G-1-pipelines-registration-and-steps](G-1-pipelines-registration-and-steps.md): pipelines per module: registration, watched branches, steps and policy, what holds a delivery, approval, groups, dependencies, a publish.
- [G-2-pipelines-sizes-checks-and-tools](G-2-pipelines-sizes-checks-and-tools.md): pipelines per module: any size, the pipeline makes the check, who may say what, health, recovery, tools, kept data, how G itself is delivered, the choices under ADR 0666 and ADR 0667. - [G-2-pipelines-sizes-checks-and-tools](G-2-pipelines-sizes-checks-and-tools.md): pipelines per module: any size, the pipeline makes the check, who may say what, health, recovery, tools, kept data, how G itself is delivered, the choices under ADR 0666 and ADR 0667.
@@ -112,7 +112,5 @@ The part is twenty-four files, each read whole, its design lines numbered across
- [G-20-lead-answers](G-20-lead-answers.md): the lead's one-line answers to develop's questions, each tested against the principles (A-1 on). - [G-20-lead-answers](G-20-lead-answers.md): the lead's one-line answers to develop's questions, each tested against the principles (A-1 on).
- [G-21-provider-and-revert-ask](G-21-provider-and-revert-ask.md): the provider a requirement points to, the named seat and the contribution edge (§708, §709, completing §357), and the assigner's ask of a held revert (§710, completing §300), the edge an acting rule gives (§711, completing §47's kind 5), the validation before take-in (§712, §713, completing §16), the take-in and groups of every watched branch (§714, §715), where the gate keeps a group's members (§716) and the seats of the status view's and the assigner's views, followed before their holder is known (§717). - [G-21-provider-and-revert-ask](G-21-provider-and-revert-ask.md): the provider a requirement points to, the named seat and the contribution edge (§708, §709, completing §357), and the assigner's ask of a held revert (§710, completing §300), the edge an acting rule gives (§711, completing §47's kind 5), the validation before take-in (§712, §713, completing §16), the take-in and groups of every watched branch (§714, §715), where the gate keeps a group's members (§716) and the seats of the status view's and the assigner's views, followed before their holder is known (§717).
- [G-22-lead-answers-2](G-22-lead-answers-2.md): the lead's answers continued, from A-182. - [G-22-lead-answers-2](G-22-lead-answers-2.md): the lead's answers continued, from A-182.
- [G-23-after-delivery](G-23-after-delivery.md): what is owed once G is delivered.
- [G-24-composition-runs-and-test-runs](G-24-composition-runs-and-test-runs.md): one composition run per candidate and machine, one test run per level and tested packages, from G's live delivery of 2026-11-17 (§718 to §733).
Design 34's milestone [every-event](../34-milestones/every-event.md) and design 46's milestone [7-approval-mark](../46-milestones/7-approval-mark.md) ship in milestone G's release, built in its repositories beside G's lines (lead-47, 2026-11-11 15:30 CET); where one of their lines and a line of G differ, G's later line holds and the other is corrected in place (§624 to §626). Design 34's milestone [every-event](../34-milestones/every-event.md) and design 46's milestone [7-approval-mark](../46-milestones/7-approval-mark.md) ship in milestone G's release, built in its repositories beside G's lines (lead-47, 2026-11-11 15:30 CET); where one of their lines and a line of G differ, G's later line holds and the other is corrected in place (§624 to §626).