Design 47 G: one composition run per candidate and machine, one test run per module's packages (G-24) #666
@@ -620,6 +620,15 @@ 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
|
||||
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**.
|
||||
- **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
|
||||
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
|
||||
|
||||
@@ -2,7 +2,7 @@
|
||||
layer: to-be
|
||||
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]
|
||||
updated: 2026-11-11
|
||||
updated: 2026-11-17
|
||||
decisions:
|
||||
- "ADR 0673"
|
||||
- "ADR 0672"
|
||||
@@ -1972,6 +1972,27 @@ 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
|
||||
delivery, a node-engine restarted with the full seat list clears its `seat-list-unread`, read with
|
||||
`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
|
||||
|
||||
|
||||
@@ -384,12 +384,15 @@ 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
|
||||
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
|
||||
failed at once, naming the language and the missing build seat. It reads that a seat has no holder from the step
|
||||
itself: an ask on that seat's work queue whose `step-started` is not heard within five minutes ends the pipeline
|
||||
failed, naming the seat (§32). It reads neither from the seat list, which answers definitions alone (§527), nor
|
||||
from any holding. Why: §32 already ends a pipeline whose step nothing starts, and the catalog half is the runner's
|
||||
one view (develop question Q-RN7). How it is checked: whole (runner), a fixture language with no build seat ends at
|
||||
once, naming it; a seat whose holder is stopped ends within five minutes, naming the seat.
|
||||
failed at once, naming the language and the missing build seat. *Amended by A-466y and A-466z (2026-11-17):* it reads that
|
||||
a seat has no holder only when the seat `mesh-module-assigner`'s view `seat-holders` names none for it (G-21 §717's
|
||||
follower; never the seat list, which answers definitions alone, §527), and a seat with none ends the pipeline failed
|
||||
at once, naming it; an ask waiting for an existing holder is timed by §86's `build-capacity-waits` and A-466s's
|
||||
`run-untaken-bound` (G-24 §720, §725), never by five minutes from the ask. Why: §32 already ends a pipeline whose
|
||||
step nothing starts, and the catalog half is the runner's one view (develop question Q-RN7); a queued step ended
|
||||
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
|
||||
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
|
||||
|
||||
@@ -378,9 +378,17 @@ 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
|
||||
build-input fingerprint `fingerprint`, not `fp`, as §585 reads it. [mesh-delivery DQ-2.] How it is checked: unit
|
||||
(runner's contract).
|
||||
- §647 **The runner times an ask from `ask-taken`.** (§535, §602) §535's five minutes run from the ask until the build
|
||||
seat holder's `ask-taken` (§602), which the runner consumes; `step-started` is the runner's own. [mesh-delivery
|
||||
DQ-3.] How it is checked: whole (runner), an ask no holder takes ends its pipeline after the setting.
|
||||
- §647 **The runner times an ask from `ask-taken`.** (§535, §602; A-466y) The runner consumes the build seat holder's
|
||||
`ask-taken` (§602); `step-started` is the runner's own. *Amended by A-466y and A-466z (2026-11-17):* §535's five
|
||||
minutes from the ask until `ask-taken` go. A seat for which the seat `mesh-module-assigner`'s view `seat-holders`
|
||||
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,
|
||||
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).
|
||||
|
||||
@@ -3,7 +3,7 @@ layer: to-be
|
||||
status: in-progress
|
||||
design: 47
|
||||
milestone: G
|
||||
updated: 2026-11-11
|
||||
updated: 2026-11-17
|
||||
decisions:
|
||||
- "ADR 0667"
|
||||
- "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` |
|
||||
| `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 |
|
||||
| `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 |
|
||||
| `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 |
|
||||
| `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`
|
||||
@@ -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 |
|
||||
|---|---|---|---|
|
||||
| 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 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 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 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 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 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 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 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) |
|
||||
| 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,6 +230,8 @@ 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 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 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 |
|
||||
| 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 |
|
||||
|
||||
@@ -245,8 +245,9 @@ the principle that settles it, cited as "design 47 G A-n".
|
||||
`view_tiers` call for a source revision compares the kept assignment revision whose catalog for that branch is that
|
||||
source revision with the revision kept before it. The view keeps a state `waits` (key owner, step, node, module)
|
||||
written by its process from every part's `wait-held` and `wait-ended` it consumes, read by its own read tool.
|
||||
- **A-243** (corrects A-226's joining; A-237, A-238; principle 7) The composition step runs one request per machine,
|
||||
each carrying that machine's input; no inputs are joined. A-237 holds for every run's input (the assigner's and
|
||||
- **A-243** (corrects A-226's joining; A-237, A-238; principle 7; amended by design 47 G §718 on 2026-11-17) The
|
||||
composition step's machines are composed by one request per machine and candidate, shared by every composition step
|
||||
of that candidate (§718), each request carrying that machine's input; no inputs are joined. A-237 holds for every run's input (the assigner's and
|
||||
`mesh-wants`' `input` too): any size, kept with an `-objects` store, answered in chunks. The composition run names
|
||||
no head (A-238); its program is the node-engine fingerprint's entry (repository, commit, directory) with the
|
||||
composer's package.
|
||||
@@ -284,7 +285,9 @@ the principle that settles it, cited as "design 47 G A-n".
|
||||
come from the step's catalog revision through mesh-catalog's `revision` (each entry's manifest digest and verdict,
|
||||
its `definitions`), depth compose, the one machine, one case `change`. A machine's node-engine build is what the
|
||||
assigner keeps from the node-engine seat's own events, never read from the node-engine's bucket; where the step's
|
||||
revision's node-engine entry differs from the trunk's, that build serves every machine. One run ask per machine.
|
||||
revision's node-engine entry differs from the trunk's, that build serves every machine. One run ask per machine and
|
||||
candidate, which every composition step of that candidate placing a module on that machine reads (amended by design
|
||||
47 G §718 on 2026-11-17).
|
||||
- **A-253** (A-249; principle 8) The tool runner hands a bundle a chunked answer as the verb's own answer with the
|
||||
whole file added as the member `file` (base64).
|
||||
- **A-254** (§712, §354, A-240, A-247, ADR 0596; principles 1, 2 and 7) A build seat's `step-ended` of a run carries
|
||||
@@ -1535,6 +1538,78 @@ the principle that settles it, cited as "design 47 G A-n".
|
||||
time, and an input with its object once no ask's key names it, so no bookkeeping key of its own is kept. A key of the
|
||||
old form `<time>.<digest>` is left to the day rule by the time it carries, never deleted earlier, so a composition
|
||||
still running on one keeps its input. (From the develop of A-465a.)
|
||||
- **A-466** (§720, §724; ADR 0666 §8, §17; principle 3) An ended run's result is read only by steps of the same
|
||||
candidate; a step of another candidate asks a new run, a passed result crossing candidates only by §25's carry; a
|
||||
`could not run` result is never read and always starts a new run, so a second revision with the same digests runs a
|
||||
failed test again. (From the review by architectural domain of design 47 G §718 to §728, 2026-11-17.)
|
||||
- **A-466a** (§727; principle 3) A rerun of a composition run or a test run moves every step that read the former run,
|
||||
whose readers are carried into the new value; a moved step reopens its pipeline, which says `pipeline-ended` again,
|
||||
and wants are written only from a pipeline's latest end; an `accepted` step does not move, a person's act standing.
|
||||
- **A-466b** (§720, §725; ADR 0596; principle 1) A run whose ask has no `step-ended` within the step's own bound ends
|
||||
`could not run`, heard on the durable `step-ended` consumer; no part reads a build seat's state to judge it.
|
||||
- **A-466c** (§728, §391; principle 4) The two drop tools are of class `act`, with §391's default callers; a
|
||||
reader-only account is refused (test 108).
|
||||
- **A-466d** (§724, §25; principle 3) The test run's digest also covers the step's build-input fingerprint without the
|
||||
artifact's own part, and its status in the policy, as §25's carry is keyed.
|
||||
- **A-466e** (§719, §725; principle 11) Each run state's time kept and cap is a setting with a default: the assigner's
|
||||
`composition-runs-kept` (24 hours) and `composition-runs-cap-mib` (16), the runner's `test-runs-kept` (7 days) and
|
||||
`test-runs-cap-mib` (16).
|
||||
- **A-466f** (§725; principle 7) `test-runs` keys a run by the package list's digest alone, the list kept in the run's
|
||||
output object; at the cap a step ends `could not run` naming the fill with no condition of its own; the runner
|
||||
deletes the output object with its key, after the last reader's end.
|
||||
- **A-466g** (§721; principle 3) A composer verdict with no `blamed` (an older node-engine) is judged as today, saying
|
||||
"the composer names no culprits"; the milestone plan orders mesh-delivery-sdk, then the node-engine's composer, then
|
||||
the assigner.
|
||||
- **A-466h** (§721; principles 7 and 11) The search for culprits holds only the candidate's changed modules placed on
|
||||
the machine, one at a time, at most once per such module plus once and never past the composer's setting
|
||||
`blame-tries` (20).
|
||||
- **A-466i** (§726; principle 3) A module's tests are counted once per pipeline and test run.
|
||||
- **A-466j** (§723, §726, §729; ADR 0666 §21; principles 1 and 8) `shared` is added to the seat definitions of
|
||||
`mesh-wants` (`step-ended`, `step-progress`) and `mesh-pipeline-runner` (`step-started`, `step-ended`) in mesh-delivery,
|
||||
generated by `seatgen`; a reading step names its own fingerprint and the run's ask, which meets ADR 0666 §21 as §25's
|
||||
carry does.
|
||||
- **A-466k** (§730; principle 3) Steps asked before the new assigner and runner run end by the old path; runs are made
|
||||
only for steps asked after; a return to an earlier build leaves the new states unread, their readers ended `could not
|
||||
run` by A-466b's bound.
|
||||
- **A-466l** (§718; principle 3) A composition run's request carries the node's `compose-candidate` answer of the
|
||||
moment it started, so a later step of the same candidate reuses that verdict knowingly, within the candidate.
|
||||
- **A-466m** (§729; principle 1) The runs' asks are named in `mesh-wants`' `step-progress`, and the watchman times a
|
||||
composition step from there: the runner says `step-started` before any run is chosen, so the part that knows says it.
|
||||
- **A-466n** (§720, §725; principles 11 and 3) A run's bound is a setting, the assigner's `composition-step-bound` and
|
||||
the runner's `test-step-bound`, each default 30 minutes counted from the build seat's `ask-taken` of the run's ask; an
|
||||
ask still in the queue is timed by §86's build-capacity finding, never by this bound, since a false `could not run`
|
||||
would say what is not true.
|
||||
- **A-466o** (§730, §732; principle 3) After a return to an earlier build, the watchman's `pipeline-stands` says a
|
||||
reader left standing; the watchman on main timed only a build seat's running ask, so §732 makes it time every step
|
||||
that reads a run.
|
||||
- **A-466p** (§720, §725; §75, ADR 0564 §2; principle 3) A run's bound times owed progress, not run length: one clock,
|
||||
a bound key in the run's state, written at the build seat's `ask-taken` of its ask and again at each `step-progress`
|
||||
of it; its expiry drops the ask (§119, A-182), ends the readers `could not run`, and a later `step-ended` of that ask
|
||||
is ignored and said in the journal. (From round 2 of the review by architectural domain, 2026-11-17.)
|
||||
- **A-466q** (§720; A-240; principle 1) The assigner's 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 runner consumes
|
||||
`ask-taken` already (§647).
|
||||
- **A-466r** (§721; principle 11) `blame-tries` is the assigner's setting, carried in the run's request to the composer
|
||||
program, which has no settings of its own.
|
||||
- **A-466s** (§720, §725; principle 3) A run whose ask is never taken ends `could not run` at the assigner's or the
|
||||
runner's setting `run-untaken-bound` after it started, default a day; §86's finding says it meanwhile.
|
||||
- **A-466t** (§731; principles 3 and 4) The runner's `stands` already includes a composition step waiting on the
|
||||
assigner (every started step not ended and running or waiting); each entry gains `ask` and `shared`, so the
|
||||
restarted watchman times it by them.
|
||||
- **A-466u** (§721; principle 7) No order is kept between the node-engine's composer and the assigner: an old composer
|
||||
is judged as today, so nothing needs it.
|
||||
- **A-466v** (§725; principle 3) A test run's output object is kept while its key lives, whatever `step-outputs`' own
|
||||
age, in the state's own object store `test-runs-objects`; a reader whose object is gone answers without it, saying so.
|
||||
- **A-466w** (§733; principle 3) Test 108 checks that a reopened pipeline of a composition run says `pipeline-ended`
|
||||
again, as test 109 does for test runs.
|
||||
- **A-466x** (G-24; principle 8) G-24's lines read in number order, the watchman's line before the checks.
|
||||
- **A-466y** (§535, §647, §86, A-466s; principle 3) "No holder" is read only when the seat-holders view names no holder
|
||||
(A-466z): a seat with none ends the pipeline failed at once, naming it; an ask waiting for an existing holder is timed by §86's finding and
|
||||
A-466s's `run-untaken-bound`, never by §647's five minutes.
|
||||
- **A-466z** (§535, §647, §527, G-21's seat-holders follower; principles 1 and 9) "No holder" is read from the seat
|
||||
`mesh-module-assigner`'s view `seat-holders`, followed through the runner's `consumes` entry
|
||||
`seat:mesh-module-assigner.views.seat-holders`, which its manifest gains, never from the seat list, which answers
|
||||
definitions alone.
|
||||
- **A-467** (A-234, A-252; ADR 0636 §1; principles 3 and 2) A composition step never passes on a machine it did not
|
||||
judge: the composer's `not judged` for a machine ends that machine `could not run`, naming why, so a step that judged
|
||||
nothing never ends `passed`. The assigner hands the composer the seat definitions of the step's catalog revision, and
|
||||
|
||||
@@ -167,3 +167,16 @@ deals with it, which is how the list is kept true.
|
||||
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.
|
||||
|
||||
@@ -0,0 +1,290 @@
|
||||
---
|
||||
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`.
|
||||
@@ -3,7 +3,7 @@ layer: to-be
|
||||
status: in-progress
|
||||
design: 47
|
||||
milestone: G
|
||||
updated: 2026-11-12
|
||||
updated: 2026-11-17
|
||||
decisions:
|
||||
- "ADR 0500"
|
||||
- "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,
|
||||
when it is not here, in the main file.
|
||||
|
||||
The part is twenty-two files, each read whole, its design lines numbered across them:
|
||||
The part is twenty-four 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-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,5 +112,7 @@ The part is twenty-two 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-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-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).
|
||||
|
||||
Reference in New Issue
Block a user