Design 47 G: write in round 2 of the review of the composition runs and test runs

A run's bound times owed progress from the ask's taking, a run never taken ends at a bound of
its own, blame-tries travels in the request, the hand order goes, a test run's output lives
with its key, stands names what a reader waits on, and G-24 reads in number order
(A-466p to A-466x).
This commit is contained in:
2026-11-17 10:37:41 +01:00
parent cebac2e791
commit d7321df3e5
5 changed files with 97 additions and 37 deletions
@@ -1972,16 +1972,18 @@ 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 §731). Two composition
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. Both drop tools end
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 §732). A module whose program and tools
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
@@ -231,7 +231,7 @@ and an estimated 2 mesh-sdk publishes a day, each rebuilding about 120 artifacts
| 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 (§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 | `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 |
@@ -1582,3 +1582,24 @@ the principle that settles it, cited as "design 47 G A-n".
- **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.
@@ -17,7 +17,7 @@ decisions:
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 §732 come from milestone G's live delivery of 2026-11-17. The 24 pipelines of one catalog revision asked 96
*§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".
@@ -59,20 +59,29 @@ domain of 2026-11-17 was answered by the lead in A-466 to A-466l (G-22), each ci
`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.** (§718; ADR 0666 §8, §17; ADR 0596; A-466, A-466b; principles 1
and 3)
- §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.** A run whose `ask` has no `step-ended` within the bound of the step that started it (the step's own
bound key with its time to live, A-77, A-101; A-466n) ends `could not run`, naming the ask and the bound, and every reader
with it. The end is heard on the assigner's durable consumer of the build seat's `step-ended` (A-240); the assigner
never reads the build seat's state (ADR 0596). A composition step's bound is the assigner's setting
`composition-step-bound`, default 30 minutes, counted from the build seat's `ask-taken` of the run's ask, never
from its asking: an ask still waiting in the queue is timed by the build-capacity finding of §86, not by this
bound, since a `could not run` for a run that only waited for a build node would say what is not true (A-466n).
- §721 **A machine's verdict names the modules it blames.** (ADR 0666 §17; A-452, A-466g, A-466h; principles 10, 3, 7
- **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
@@ -83,15 +92,16 @@ domain of 2026-11-17 was answered by the lead in A-466 to A-466l (G-22), each ci
- **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 the composer's
setting `blame-tries`, default 20; past that bound, the modules not yet tried are named in `blamed` with the words
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".
- **The order.** mesh-delivery-sdk's `composer` package is published before the node-engine and the assigner build (an
edge of kind 1); the node-engine's composer is delivered before the assigner, an order the milestone plan names.
No `needs` is declared for it, since an assigner meeting an old composer judges as today.
- **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;
@@ -131,8 +141,8 @@ domain of 2026-11-17 was answered by the lead in A-466 to A-466l (G-22), each ci
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; principles 1, 2, 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
- §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
@@ -140,16 +150,24 @@ domain of 2026-11-17 was answered by the lead in A-466 to A-466l (G-22), each ci
- `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 in `step-outputs`.
- 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 run whose `ask` has no `step-ended` within the bound of the step that asked it ends `could not
run`, as §720 has it (A-466n), and every reader with it. A test step's bound is the runner's setting
`test-step-bound`, default 30 minutes, counted from the build seat's `ask-taken` of the run's ask as §720 counts the
composition step's; an ask still in the queue is timed by §86's build-capacity finding alone (A-466n). At its start the runner takes up again each key with no `ended`, by its
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 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
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
@@ -191,11 +209,14 @@ domain of 2026-11-17 was answered by the lead in A-466 to A-466l (G-22), each ci
`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
@@ -207,6 +228,12 @@ domain of 2026-11-17 was answered by the lead in A-466 to A-466l (G-22), each ci
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
@@ -224,30 +251,40 @@ domain of 2026-11-17 was answered by the lead in A-466 to A-466l (G-22), each ci
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.
- §731 **How it is checked.** Tests 108 and 109.
- §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 run whose ask has no `step-ended` within the 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 superseded step leaves the run running for its other readers. An assigner restarted during a run takes it
`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 `blame-tries` names the untried.
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 second revision with
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 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.
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`.
+1 -1
View File
@@ -113,6 +113,6 @@ The part is twenty-four files, each read whole, its design lines numbered across
- [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 §732).
- [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).