Design 47 G: the lead's answers A-363 to A-372 (G starts) #609

Merged
mesh-tools merged 70 commits from design/47-G-lead-answers-31 into main 2026-11-16 08:24:39 +00:00
@@ -746,3 +746,432 @@ the principle that settles it, cited as "design 47 G A-n".
on a cycle, so a call word's edge on a cycle is left out like an invoked verb's.
- **A-362** (completes A-353; principles 3 and 7) The seat list a runner starts with (mesh-sdk's bootstrapped list)
holds `mesh-delivery` beside `mesh-catalog`, so `mesh-delivery.source` is admitted before the seat list is read.
- **A-363** (cycle C7; principles 7 and 2) While its catalog half is unread, grants composes each account from the
manifest the indexer's `modules` first view names for its module (the trunk's), in union with what its want's entry
gives, never from the list in force alone; so the first G parts get their G subjects before any of them serves.
- **A-364** (completes A-363; principle 7) Grants' own account carries the right to create each kept event stream of
the seat list (`SEAT_*`, such as `SEAT_git_branch-moved`) while the catalog half is unread, composed the same way.
- **A-365** (cycle C4, a silence of ADR 0573 §2/§4, which speaks of the latest published version; principle 7) A mesh
Go package no published version holds is built, for its importer, at the commit the gate's `source` names for its
repository, as an import of the same repository is; once a version is published, the latest published applies. The
indexer asks such a build with that commit, not on the version line.
- **A-366** (W5; principles 7 and 3) The indexer takes its own build from `MESH_FINGERPRINT` (mesh-sdk
process.OwnBuild) first, and asks the node-engine's `composition` only when it is unset.
- **A-367** (W22; principle 3) A planner of the catalog half (the bus keeper) treats a `none-yet` trunk as not yet
viewed: it plans nothing, deletes no plan and says no module orphaned until the first revision with entries.
- **A-368** (C6; principle 7) When neither the registrations nor the gate's `source` name a branch (a fresh mesh),
the catalog half counts the trunk as `none-yet`, once in the catalog client's `Ready` for every part, so the approval
gate is ready and `indexer_seed_again` runs. In this release, since G's genesis needs it.
- **A-369** (completes A-368; principle 7) Grants' own wait for its catalog half (`CatalogOf.Waiting`) asks the catalog
client's `Ready`, so a mesh that names no branch counts as `none-yet` for grants as for every other part.
- **A-370** (cycle C8, found by dry run 2's baseline; principles 1 and 7) The indexer answers the first views of the seat
`mesh-catalog` (`registrations`, `revision`) at once from what its state holds, never held behind a running take-in;
a take-in that changes them says so on its events. So a runner's catalog half is read before the take-in's own calls
(such as the forge bridge's `bridge_merged_message`) reach it.
- **A-371** (review r1 finding 1; completes A-364; principles 7 and 3) A first view grants reads from a seat stream that
does not exist yet, and that grants itself creates (such as `SEAT_node-engine_running`), is empty, not a wait: grants
composes the pass, writes its own right to create the stream with it, then creates the stream and hears it from its
start; its health says the stream was created after the pass.
- **A-372** (completes A-368; principle 7) The assigner's wait for its catalog half (its `adopted` callback) asks the
catalog client's `Ready` as well, so a mesh that names no branch is `none-yet` for the assigner too.
- **A-373** (live start, novox 21:56: "the value for list in mesh-grants_user-list is 422584 bytes, over the 262144 bytes
the bucket takes"; principles 1, 3 and 7) Grants keeps its user list and its pass result, which outgrow one value of a
key-value bucket, as objects in an object store of its own state (declared in its manifest like any kept data), the key
naming the object; a write that cannot be made stays loud as today.
- **A-374** (completes A-373; principles 3 and 7) The seat verb `withheld`, served from grants' tools bundle, reads a
small key `withheld` that the process writes beside the list in its state `user-list` each pass it changes, so it
answers without the object the list became; before that key is first written it reads the list as before.
(Built in mesh-delivery d6d6bd18.)
- **A-375** (live start, novox 22:28-22:44: grants "the first view seat:mesh-broker.list of the bindings is not answered
(Not run: the marks of nats are not read yet ...)", and the indexer runtime "was bound no object-store called
catalog-revisions ... bound: none"; extends A-359; principle 7) The gate's start path also lets through the seat
`mesh-broker`'s verb `list` (the bindings' first view) while the catalog half is unread, since the catalog half's own
owner is bound its bus state through it.
- **A-376** (live start, novox 22:4x-23:0x: the indexer runtime "was bound no object-store called catalog-revisions";
the keeper plans nothing "before the catalog half's first views", which need that very store; cycle C12; completes
A-367 as A-363 completes grants; principles 7 and 3) Before its catalog half's first views are in, the bus keeper
makes the bus state of the holder of the seat `mesh-catalog` (the catalog half's own source), read from that module's
manifest on the trunk as the indexer's `manifests` first view gives it, and says each made entry as it does today, so
grants binds it; every other module waits for the catalog half as A-367 says.
- **A-377** (live start, novox 22:26: grants' first views of the indexer's `modules`, `manifests`, `verdicts` "Not run:
the marks of mesh-delivery-indexer are not read yet"; the keeper's A-376 reads the same views; widens A-359 back toward
A-353; principle 7) While the catalog half is unread, the gate's start path also lets through each module's own
first-view tools (the tools its first views name, which a caller list already limits), besides the seat verbs of A-359
and A-375.
- **A-378** (completes A-376; principle 7) The indexer's first views `modules` and `manifests` name the bus module (`nats`)
among their callers, so its keeper reads the catalog holder's manifest.
- **A-379** (replaces A-376 and A-378 for the start: the indexer's `catalog-revisions` is declared in its manifest's
old `objects` section, which grants creates (records.go objectsOf, assertions.go), while the tool runner reaches an
object store only by a new-form binding (`node-tools` internal/bus/bindings.go objectStore), so nothing binds it;
principle 7: what exists) The tool runner reaches a module's object store by the binding when one is bound, and
otherwise by the old `objects` entry its membership names, under the bus name grants created for it
(`OBJ_<module>_<name>`); a name neither names stays refused as today.
- **A-380** (corrects A-379's source of the name: grants issues no `objects` map in a membership; principle 7) With no
binding of that local name, the runner reaches the store under the name grants creates for a module's old `objects`
entry, `<module>_<name>` (stream `OBJ_<module>_<name>`); the bus's grants to the module's account decide whether it
may, and a refusal is said with the store's name.
- **A-381** (live start, novox 23:42-23:58: grants is "Permissions Violation for Publish to $JS.API.STREAM.NAMES" while the
loaded list grants it STREAM.CREATE/INFO of each kept seat stream, so its assertion of the seats' kept events never
reaches the create and SEAT_mesh-conditions_findings-asked stays missing; every bundle with a finding writer exits;
principle 7) Grants' own account carries `$JS.API.STREAM.NAMES` (the read its assertion of kept streams starts with),
composed with the create rights of A-364.
- **A-382** (widens A-381 to its kind, met a second time: live 00:02, every G bundle with a finding writer exits "no stream
on the bus carries mesh-conditions.findings-asked", because the tool runner's SubscribeNew finds a stream by subject
through `$JS.API.STREAM.NAMES`, which `novox.node-tools` may not publish, while EVENTS carries `mesh.seat.*.event.>`;
principles 7 and 6) Every account grants composes carries `$JS.API.STREAM.NAMES`, the read of stream names by subject
that hearing an event starts with; it lists names only.
- **A-383** (completes A-382; live 00:21: list revision 274 loaded, yet `novox.node-tools` still lacks
`$JS.API.STREAM.NAMES` (1805 publish rights, unchanged), since grants keeps an account it holds "beyond this pass" as
the list in force while the catalog half is unread; principles 7 and 3) A right every account carries (A-382) is added
to every account grants writes, a kept one included: keeping an account in force never withholds what every account
is given. A pass that only adds still never takes from a loaded user.
- **A-384** (completes A-382/A-383 for the whole hearing path, met a third time: live 00:35 "an ordered consumer of
mesh-conditions.findings-asked on EVENTS: context deadline exceeded", the runner account holds only INFO of named durables
on EVENTS; principles 6 and 7) Every tool runner account carries what the runner's SubscribeNew (an ordered consumer from
the next message, mesh-tools `node-tools` internal/bus/subscribenew.go) asks of the stream that carries the events its
bundles hear: the create of an unnamed consumer filtered to those events' subjects, its next-message fetch, its info and
its delete, on EVENTS and on every kept seat stream; the same form for every runner, composed in one place.
- **A-385** (generalizes A-383, met a fourth time: live 01:00 "mesh-delivery-gate's bundle asked mesh/ledger.get and it
failed after 10s", the gate's ledger `records` exists and is bound, and `novox.node-tools` holds no right on
KV_mesh-delivery-gate_records_state, since a held runner account is copied whole from the list in force; principles 7
and 3; A-363's union) An account grants keeps beyond a pass, a runner's included, is written as the union of the list
in force and what this pass composes for it (its carried modules' grants from the trunk's manifests and their
bindings), never the list in force alone; a pass that only adds still never takes from a loaded user.
- **A-386** (completes A-385 for runners kept as they run; live 01:31: grants 3c582b1b in, `novox.node-tools` unchanged
(2004 publish rights, none on KV_mesh-delivery-gate_records_state), since `runnerUsersKept` keeps a runner whose running
manifest does not say it is the tool runner whole (ADR 0601 §4); principles 7 and 3) A runner kept as it runs is written
as the union of the list in force and the runner grants its carried modules' bindings and events give (the ledger
readers, the new-event rights of A-384, the streams' names of A-382): what a carrying runner is given, never what a
plain module is given, so ADR 0601 §4 stands.
- **A-387** (generalizes A-353, A-359 and A-375, met a fourth time: live 02:16 the first take-in took in none of 18
repositories, "the seat git did not answer pull: Not run: the definition of the seat git is not yet read by this tool
runner's seat list", and the runner's own `mesh-catalog.seat-definitions` is refused "the marks of
mesh-delivery-indexer are not read yet"; principles 7 and 3) Before the catalog half is read, the gate lets through
every verb that the seat definition the runner holds classes `read` and does not mark needs-approval, and judges every
other call as before; the hand-kept list `startReads` goes. The bootstrapped definitions carry every seat the first
take-in reaches: `git` joins them, a byte-for-byte copy of its contracts file with its row in the bootstrap test. The
catalog seat's contract classes `modules`, `module`, `provides`, `dependents` and `seat-definitions` as `read`, and
its bootstrapped copy follows.
- **A-388** (completes A-387; the developer's question: seatdef callers.go reads a verb with no class as a read, which
would let unclassed acts such as `mesh-delivery-checker.try` and `operator-channel.tell` through before the catalog
half is read; principles 3 and 7) A-387's start path takes a verb whose definition names the class `read` explicitly,
never one that names none. The broker seat's contract classes `list`, `show`, `check` and `orphans` as `read`, and its
bootstrapped copy follows, so A-375's `mesh-broker.list` still passes.
- **A-389** (completes A-387 for module tools, met a fifth time: live 02:32 the take-in's
`mesh-delivery-forge-bridge.bridge_merged_message` is refused "the marks of mesh-delivery-forge-bridge are not read
yet"; a module tool names no class, and its marks live only in the catalog half's entry the take-in has not made yet;
principles 7 and 3) Before the catalog half is read, a module tool whose proven caller is another module's account (never
a session's or the mesh MCP server's) runs unmarked, and the runner logs each such call once per tool with its caller ("run
unmarked before the catalog half is read"); a module tool called otherwise waits and is judged as before. A module
tool's mark is read again, and holds, from the call after the half is read. Today the one marked module tool,
`gitea_branch_protection_loosen`, has no module among its callers.
- **A-390** (live 03:17 on novox: the tool runner's first view of the catalog half is refused "mesh-catalog.revision is
refused to `novox.node-tools`: the tool answers only mesh-delivery-builder"; `node-tools` declares `invokes: ["*"]`, and
the verb revision's callers rule (ADR 0663 §2) matches `seat:mesh-catalog.revision` by its exact text alone, while the
grants part reads a single `*` as every seat verb; principles 7 and 3) The verb revision's callers are the parts whose
entry in the newest trunk revision declares `seat:mesh-catalog.revision` or a single `*` in invokes, as the grants part
reads invokes; the holder stays off the list.
- **A-391** (live on novox: the indexer's start ran 50 minutes of CPU in its first hour without reaching its take-ins
watch, so the seed was never asked; it wrote the whole catalog view again after each finished build of the build log,
though none changed a module; principles 7 and 3) A finished build writes the view again only when it changed a module;
at the start the build log's finished builds are applied first and the view is written once, the replay said in one
line at its start and one at its end with its count and duration.
- **A-392** (live on novox: the seed asked every artifact's build seat for its steps one by one, each call to a seat with
no holder retried for 30 seconds, so a seed of 178 entries ran for hours before refusing; principles 3 and 7) Within one
seed, a build seat that did not answer is not asked again for its later artifacts; they stay unanswered, the seed refuses
with the same words, and the seat's first silence is said in one line.
- **A-393** (live: the build runtimes serve `steps` only on `mesh.seat.node-build-go.tool.steps.<node>`, and the seed asks
`seat:node-build-go.steps` naming no machine, since it cannot know the holders before the assigner's view; principles 7 and 1)
A verb of a node-scoped seat asked with no machine is answered by any one holder: each holder's runtime also serves the verb
on the subject without the machine (tool and call forms), in one queue group per seat and verb, and the grants part grants
each holder those subjects.
- **A-395** (live: novox's tool runner was refused `mesh-catalog.revision` 54 times, the verb answering only parts that
declare it in invokes, while the runner reads the catalog half for every module it serves; principles 7 and 4) Every part
the newest trunk revision holds may read the verb revision, and so may the tool runner; the holder stays refused. ADR 0663
§2's rule that a part reads it only by declaring it is proposed for its end.
- **A-396** (live: the shanks build runtimes' seat list and catalog-half reads were refused on their caller-named subjects,
since no build module's manifest invokes them; principles 7 and 4) Every module is composed as invoking the tool runner's
own reads (the seat list's verb, the catalog half's revision and registrations, the delivery seat's source), so each
account the runner serves a module on may ask them.
- **A-397** (live, ace 2026-11-14: the assigner's program and its tool runner both bound the durable consumer
`ace_mesh-delivery-assigner` on `SEAT_mesh-catalog_registration-changed`; the runner pulled all 178 events of the first
registrations and the program, which acts on them, heard none and said nothing; principles 1 and 7) A durable name is
shared only where the work is meant to be shared: a work queue, each item to one taker, as NATS shares one durable among
its pullers. Every other reader needs every message, so each process of a module that hears events has a durable consumer
of its own, named constantly across restarts: the module's program `<node>_<module>`, its tool runner
`<node>_<module>_tools`, any other process its manifest names `<node>_<module>_<process>` (A-340). A durable name holds no
dot (design 19 *The consumer*). The grants part composes and makes each, with the hear of exactly that process's events.
This is a builder's judgement no design line overrode (the operator, 2026-11-14: "the developer should use his brains");
design 19's *one durable consumer per module* was written when a module was one process.
- **A-398** (live, shanks 2026-11-14 18:13: the G builder was refused `KV_mesh-build-go_steps` and the image and node steps,
since its reads `seat:node-build-{go,image,node}.steps` resolved to no holder: no assignments holds the build seats; the
operator decided, 2026-11-14 about 18:16: "yes, do it", after their word of 16:45 that who holds a seat follows from the
module graph and the assignments; principles 1 and 7) A seat-form read, view or view tool resolves to the holder on
record, else to the first module assigned to a node (nodes and modules in name order) whose manifest claims the seat.
Holds keep heldWherePlaced's rule. The whole question of holders stays with the post-G remarks.
- **A-399** (live, shanks 2026-11-14 18:32: the Go build seat was refused `toolchain-reported.shanks`, and `step-ended` too: a
seat pulled by kind is composed by the seat-traffic rules, which grant an event only under a kind or a caller's name, and
the held-seat rule skips such a seat, so its own events were granted to nobody and the builder heard no toolchain;
principle 7, and who-may-is-not-the-operators-question) The holder of a seat pulled by kind (not kinded) says each of the
seat's events no caller names: on its own machine in its account where the definition's subject names `<node>`
(machineEvent now reads `<node>` from any node seat's event subject, not the node-engine's alone), and with any machine in
its membership, since the runtime carrying it checks the membership; the account is therefore granted any machine's too.
- **A-400** (live, the control-node 2026-11-14 19:12: the indexer waited for ever on the view `seat:mesh-module-assigner.assignments`
for a holder of the seat, since the assigner's state seat-holders is written from the assignments' holds alone and no
assignments holds mesh-module-assigner; its versions fill stayed undone and no build began; the operator, 2026-11-14 about
16:45 and 18:16, as for A-398; principles 1 and 7) The assigner writes seat-holders from the assignments' holds and, for
each seat no holding names (a seat held once: on no node; a seat of every node: on that node), the first module assigned
to a node (nodes and modules in name order) whose manifest of the trunk claims it: the same rule as A-398, in the
writer every reader of the holders reads. It says each key so derived once, and when it stops being derived. The
assignment graph's requirement resolution and the order waits keep reading holders from the holds alone; the post-G
remarks take that up with the rest of the holders question.
- **A-401** (live, the control-node 2026-11-14 21:5x: the assigner ended every proposal, since f1-circuits (watched on
`master`), link2pay and photos (watched on nox-mesh) are held in no catalog graph of their branch; the gate writes
`source.<branch>` only on a take-in of a merge on that branch (A-34), so a newly watched branch is never started; the
operator, 2026-11-14 about 22:00: "by doing a git clone"; principles 2, 4 and 7, §15, §430, A-85, A-93) A watched branch
starts from the forge, as a clone does. The gate, at its start and on each `registration-changed` of the seat
`mesh-catalog`, writes `source.<branch>` for every watched branch the registrations name that no source key holds yet
(§430, which wrote the default branch alone): each repository registered on it at the branch's head, asked of the seat
`git`'s verb `branch`, the group left empty, and says `source-moved`; a repository whose head cannot be read is left out
and said, and is added at the next registration change or by hand. Its tool `gate_source_start` (branch, why) does the
same by hand through the hand-act log. A key it holds is never rewritten this way: from then on only a take-in moves it
(A-34). The indexer takes a head the source names in from that head's merged message as before; a head with no merged
message is read whole at that commit through the seat `git` (its tree and files), taken in as a merge whose changed
files are every file of that tree, and computed as any other (A-93). So the branch keeps its first revision
`branch.<branch>.1`, and its later merges follow the designed path.
- **A-402** (A-401; principles 7 and 3) The indexer reads a head whole through the seat `git` on any failure to read its
merged message, not only on the forge bridge's "no merged pull request": the read at the same commit gives the same
tree, so no typed error is added to the bridge; each such read is logged with its cause, and a head neither way reads
stays unread, as before.
- **A-403** (A-401; principles 2 and 7) "A key it holds is never rewritten" means no head it holds is changed: at its start,
on each registration change and by its tool, the gate adds to a held `source.<branch>` every registered repository the
key does not name yet, at the branch's head, and says `source-moved` only when it added one; the heads it holds move by
a take-in alone (A-34). So a repository left out once, or registered later on a branch already watched, comes in the
same way.
- **A-404** (A-401, A-403; principles 7 and 3) A `source-moved` the gate says for heads it started from the forge, on a new
key or added to a held one, names no group, as A-401's new key does: no group moved it, so nothing times it as a
group's; the key keeps the group a take-in last wrote.
- **A-405** (live, the control-node 2026-11-14 22:34: its node-engine refused every candidate, "nothing provides" postgres-database,
secret, route, s3-bucket, document-server and mcp-endpoint, since its catalog holds only modules whose wanted build has a
catalog entry, and the providers' wants name the builds running from before G, which have none, their new builds waiting
for a pipeline that cannot be placed while the node refuses; the operator, 2026-11-14 about 22:40: "yes, go ahead";
principles 2 and 7, §421) A module the node runs whose wanted build has no catalog entry stays in the node's catalog as
the build it runs, from the manifest of that build the node keeps: it provides, claims and requires what that manifest
says, so the node resolves around it. Its want stays held with `entry-missing` (§421) and nothing new of it is composed;
when its new build's entry comes, it is composed as any other.
- **A-406** (live, the control-node 2026-11-14 22:34: the pipeline's manifest at its build was refused by the manifest judge on
2026-11-13, and its candidate carried no parts; the operator, as for A-405; principles 5 and 7) The pipeline's manifest is
made to pass the validator, as any module's; its first build is asked of the builder once by hand, the way a run on request
asks it, since only a pipeline asks builds and none runs yet.
- **A-407** (A-405; principles 7 and 2: the node keeps no manifest of a build that has no entry, and the running event
carries only a digest) A running module whose wanted build has no entry is described from the catalog entry of the build
its want says is being built (the newest of its first watched branch), read through the seat `mesh-catalog`'s `entry` as
any entry: what it provides, claims and requires there stands for the running build, for resolving the node alone. A
want that names no newer build leaves the module as today (a name alone), said once.
- **A-408** (live, the build node 2026-11-14 22:45: the builder held every build "wait-held, the catalog has not said
versions-filled", while the indexer said it once at 01:33 UTC and keeps it as said; the builder keeps the mark in memory
alone and its durable consumer took the event once, so a restart lost it; principles 1 and 3, §369, §372) The builder
reads at its start the last `versions-filled` the seat's stream keeps (it is kept with no age limit, §372) by a direct
read of the last message on its subject, and takes it as heard; the event heard later sets it as before.
- **A-409** (live 2026-11-14: the assigner's and the builder's durable consumers filter only
`mesh.mod.mesh-catalog.event.catalog-revision`, so neither hears a catalog revision after its first view; the seat
definition says the event `catalog-revision` with the subject `catalog-revision.<branch>`, and the grants part, finding
no match for the consumed `mesh-catalog.catalog-revision`, fell back to a module's event without a word; principles 1
and 3) A consumed seat event matches the seat's event of that name whatever its subject's further tokens, and its filter
is the seat event's subject with each `<...>` token as `*` (a trailing one also as the rest); a consume naming a seat
that says no such event is refused aloud by the grants part, never turned into a module's event. The indexer's
`catalog-revision` duplicate id names the branch, and it is published with the bus's acknowledgement.
- **A-410** (live, the control-node 2026-11-14 about 22:55: proposals placing the pipeline were answered "differs", with
fail2ban, pacman and mesh-mail-reader counted as removed, while all three run and their assignments hold them; a module
started before the node-engine wrote fingerprints has none in what it runs, and none can be made for it, so its
comparison is skipped, and a skipped comparison was counted as a removal; principles 2 and 3) A module the node runs
whose fingerprint it cannot read or make is held: it is kept as it runs and said as held, with why, in the node's
answer, never counted as removed and never stopped for it. Only a module the node runs that no assignment names is
removed.
- **A-411** (A-408; live, the build node 2026-11-14 23:27-23:34: the builder's read of the stream `EVENTS` is refused, since
no module is granted that stream's details, by design; `versions-filled` is a kept seat event on its own stream, which the
builder consumes and is granted; principles 1 and 7) The builder reads the last `versions-filled` at its start from the
seat event's own kept stream, through the SDK's hearing of a kept event read from its first message, as any kept event
is heard; it reads nothing of `EVENTS` and needs no new grant.
- **A-412** (live, the build node 2026-11-14 23:40-23:41: the builder's claim of every build is refused, "is not a manifest
digest, 64 lowercase hex digits", since the indexer's catalog entry now says its manifest digest as `sha256:` and hex,
and the builder passes it on as it reads it, while its builds and its manifests are keyed by bare hex; a build asked
again then answers "wrote nothing … its log says why" with no why; principles 3, 7 and 8) The builder takes a catalog
entry's manifest digest in its bare form, through the contract's own reading of it, wherever it plans, claims or keys
a build; the form the entry says is the entry's. A look that writes nothing says why in the builder's log, for each
of its ends, and the answer to a build asked again carries that why.
- **A-412a** (A-412; principles 1 and 7: the form of a seat's entry is its contract's) Both readings of an entry's
manifest digest (the entry's form and the bare one) move into the seat `mesh-catalog`'s contract package; the indexer
and the builder use them from there, and neither keeps its own.
- **A-413** (§544 as G-12 answered it, A-170, A-231; live, the bus 2026-11-14 23:49: the builder of G asked 113 builds on
`accept.delivery.<asker>`, and no named worker exists to take them, since the grants part counts named asks unused while
no entry of the revision invokes a build seat's queue, and in the start no entry of G is in the revision yet; principles
3 and 2) Named asks are unused only when no entry of the revision invokes a build seat's queue and no account the part
composes is granted to publish a named ask; while either holds, each build seat's queue keeps its named worker, made at
the part's next pass. The purge at a revert stays as §544 says, for a revision whose accounts ask no named ask.
- **A-414** (A-407, A-413; live, the bus 2026-11-15 00:17: after A-413 the grants part still made no named worker, since the
holders of the build seats, and the builder, run builds from before G with no catalog entry, so the part composes none of
them and carries their last memberships unchanged; the operator, 2026-11-15 about 00:20: "yes"; principles 2 and 7) The
grants part composes a running module whose wanted build has no catalog entry as A-407 describes it for the node: from
the catalog entry of the build its want says is being built (the newest of its first watched branch), read through the
seat `mesh-catalog`'s `entry` as any entry, for its account's grants, membership and seat traffic alone. A want that
names no newer build leaves its membership carried as today, said once.
- **A-415** (§588, A-73; read from the code 2026-11-15 by the developer, the live proof waits on its new log lines: the
builder records a trunk build's digests on its reservation only after the build's claim is finished, while the registry
publishes during the build, so a registry seat's `published` heard before then marks nothing, is acknowledged and is
lost, and package-published is never said, as for 0.1.6; principles 1, 3 and 7) A `published` that marks no artifact
of its reservation yet is kept on that reservation, in the builder's own kept state, as heard (name, version, digest);
when the build records its digests, each kept `published` whose digest matches marks its artifact and package-published
is said then, in the same way as for one heard after. Nothing asks the registry; a kept `published` whose digest never
matches is said in the builder's log when the build records its digests.
- **A-416** (§588, A-302, A-415; live, the build node 2026-11-15 02:02 and 02:16: `builder_publish_again` for
mesh-delivery-pipeline 0.1.6 queued nothing, "no module running that claims the registry seat oci-artifact-registry
is known to the builder since its start", since the builder learns a registry seat's holder only from node-engine
`running` events heard since it started, and that knowledge dies with every restart; principles 1, 4 and 7) The
builder knows each registry seat's holder through the SDK's FollowSeat, as A-302 has the indexer follow its seats,
from its start; a `running` heard still queues the versions waiting on that holder, as §588 says, but is no longer
how the holder is known. A publish again whose seat has no holder said by FollowSeat says so, naming the seat.
- **A-416a** (A-416, A-298; principles 1 and 7: one source of who holds a seat, and nothing followed that nobody reads)
FollowSeat follows a state of a holder, and the registry seats keep none the builder reads; so the builder knows a
registry seat's holder from the seat-holders reading A-298 names (`SeatHolders` of the catalog client), the one its
FollowSeat of the assignments already takes, read from its start. Its manifest and grants do not change. A-416 is
read with "the SDK's FollowSeat" as this reading.
- **A-417** (A-73, A-50, §588; live, the control-node 2026-11-15 01:57 and 02:28: the build node's publish of
mesh-delivery-pipeline 0.1.6 stores each artifact untagged, as A-73 has it, and the registry holds it, under the
artifact digest the builder reserved; the builder's publish of the version with that digest and no parts is then
refused, since the holder of `oci-artifact-registry` says published only for a tag it already holds and otherwise
opens a transfer with no parts; principles 3 and 7) A registry holder given a publish with a version, a digest and no
parts tags that version on the manifest it holds of that artifact digest under the name, and says published; when it
holds none, it takes the bytes from the artifact store by that digest, as A-73 and A-50 say, and stores and tags them;
when neither has it, it refuses as not stored, naming the digest. The builder's publish again names its transfer in
the transfer form the build's own step uses.
- **A-418** (§478, §676, §694, A-417; live, the control-node 2026-11-15 02:57: the tag of mesh-delivery-pipeline 0.1.6 is
refused since the builder's `reserved` answers "no entry carries the name mesh-delivery-pipeline/program": it matches a
name only against an artifact's `package`, which a bundle or an archive has none of, so no bundle is ever found;
principles 7 and 8) A bundle's or an archive's name for `reserved` is `<module>/<artifact>`, read from its catalog
entry's artifact reference (`<module>:<artifact>`), the name the build step and the builder publish it under; the
entry stays the one source of the name, and no `package` is added to it. A name that matches no entry is said in the
builder's log with the entries looked at.
- **A-419** (A-96, A-67; read from the code 2026-11-15: the assigner finds a trunk build's released version and parts by
its module and the source revision of the kept assignment graph, so after any merge that does not rebuild a module,
its wants and candidates carry no version and no parts; principles 2 and 7) A trunk build's release is matched by its
module and the source revision its fingerprint was built at, read from its catalog entry's `fp-src`, which is
`version-released.source` for that build; A-96's "matched to `version-released.source`" is read so. A want or a
candidate whose entry's release is not heard says so, naming the module, the fingerprint and that source.
- **A-420** (principle 3; the builder and the indexer hear their events with five deliveries, and the bus drops a message
after the fifth without either saying so) On the last delivery its consumer allows, the builder and the indexer each
say in their log that they give the message up, naming its subject, the artifact and version it carries, and the
last refusal. (Quick fix, said: the same silence holds for every part that hears an event; the thorough fix is the
SDK's hearing saying it once for every part, noted on the issue of the hand start.)
- **A-421** (A-419, ADR 0601 §1; read live 2026-11-15: six entries of trunk revision 225 carry no `fp-src`, since a
fingerprint that moves without a merge clears it, so A-419 finds no release for them; principles 2, 3 and 7) A trunk
entry with no `fp-src` is matched to the release whose parts' digests are the digests its fingerprint's `build.ended`
made, as the assigner already hears it; an entry with `fp-src` is matched as A-419 says. An entry neither finds is
said as A-419 says, with which of the two was tried.
- **A-422** (A-397; live, the bus 2026-11-15 03:45: the indexer, the assigner, the checker, the teller, the forge bridge,
the view, distribution and nats each have a durable on a kept seat stream their manifest consumes that was never
delivered, since only the builder binds its kept streams; the indexer never heard a package-published; principles 1,
3 and 7) The SDK's event hub binds a part's kept seat streams in its own start, after the stream `EVENTS`, so every
part hears each kept event its manifest consumes on its own durable there, as A-397 says, with no call of its own;
a stream it cannot bind is said in its log and its start goes on. The replay of what waited is heard as any event;
a part whose handler cannot take its backlog is a finding of the change, read before its delivery. (Thorough fix,
said: the indexer's own call, b0242f68, is the quick fix placed meanwhile.)
- **A-423** (A-397, A-422; read from the code 2026-11-15: the assigner reads machine-away and machine-back, and the forge
bridge branch-moved, with readers of their own on the durable the hub now binds too, so each message would reach one
of the two; and the checker, the forge bridge, the view and distribution consume registration-changed in their
manifests with no route, so its durable fills unread; principles 1, 3 and 7) One reader per durable: the hub is the
only reader of a part's kept streams, and a part that read one itself hands its handler to the hub, which gives each
event to every handler it has for it. A kept event a part's manifest consumes and no route takes is said at its start,
naming the event, as a fault of the part to be fixed in its manifest or its code.
- **A-424** (§394, §450, A-423; the operator, 2026-11-15 about 15:50 CET: "there is no limit for the amount of asks in my
telegram", said many times before; live: the teller held the pipeline's proposal ask behind two week-old asks, since
an asker may have at most three asks open; principles 3 and 7) The operator channel keeps no count of open asks per
asker and holds none back for room: every ask is offered when it is raised. The router's limit, the teller's own and
the ask-again for a held-back ask (§394, §450) go; an ask still lapses at its expiry or ends at its answer.
- **A-425** (the operator, 2026-11-15 about 15:57 CET: "yes, remove the per-placement approve", after the lead proposed
it under propose-removing-a-wrong-rule: a person's yes for every placement holds work on a form, against "merges and
deliveries need no approval"; principles 3 and 7) A proposal whose verdict passes is applied by the assigner at once,
with no ask of the operator, when it only places, pins, unpins, holds, unholds, decides or configures. A proposal
that takes a module off a node, removes a node, or whose verdict says a node would stop or remove a module or its data,
is still asked of the operator, as are the asks of a module whose moves a person takes. Each applied proposal is said
as an event and in the assigner's log, naming who proposed it and why. The decision record that made every proposal
wait on the operator's yes gets a new record saying so once the knowledge base admits callers again.
- **A-425a** (A-425; the operator, 2026-11-15 about 16:00 CET: "this is all configuration, a simple, single mesh mcp
call"; read live: the assigner declares only `outside-settle-seconds` and `outside-wait-minutes`, and asks every
passing proposal in its code; principles 4 and 7) Which proposals the assigner asks of the operator is the assigner's
declared config key `ask-operator-for`, a list of change kinds (`place`, `take-off`, `pin`, `unpin`, `hold`,
`unhold`, `decide`, `config`, `add-node`, `remove-node`, and `stops` for a verdict that stops or removes a module or
its data), set at mesh level with `mesh-config.config`; its default is A-425's: `take-off`, `remove-node`, `stops`.
A proposal none of whose changes is listed is applied at once. The asks of a module whose moves a person takes stay
as they are. A change of the key is said in the assigner's log at its next pass.
- **A-426** (§268, A-323, A-330; live, the build node and ace 2026-11-15 15:52-15:56: the pipeline's want on novox
waited for an assigner build not yet built, while a working assigner ran, and only a hand release moved it; the
operator: "then our design is stupid"; principles 2, 3 and 7) An acting wait waits only while its acting part runs
nothing that serves the edge: an acting part that runs a build serving the edge's seat or verb ends the wait at
once, whatever version its newest is, and the wait says which build it took. A wait on a version not yet built is
never held for that alone. (This replaces the node-engine exemption of A-323 and A-330 with a rule for every part.)
- **A-427** (A-426; live: the builder refuses a put of a version it did not build, so a part started by hand cannot be
held, and the trunk's newest build of it would replace it; principles 2 and 4) A put may name the build a node
runs now, read from the node's running statement, and holds the want there; the builder's store is not asked for it.
- **A-428** (§29, A-328; read from the code 2026-11-15 16:05: a want follows a passed pipeline, and no pipeline can
pass while no holder of the seat `mesh-pipeline-runner` runs, so the runner itself never gets a want; the gate
returned before the want rules without a word; principles 3 and 7) While no module holding `mesh-pipeline-runner`
runs on any node, a want of a module whose manifest claims `mesh-pipeline-runner` does not wait for a passed
pipeline: the assigner writes it from the trunk's entry by its other rules, and says once that it does and why.
Every other module still waits for a passed pipeline, so nothing else moves before a runner runs; once one runs,
A-328 has the runner's own changes pass on it. (Whether a want waits for a passed pipeline at all is a gate for the
generic gating research to make configured.)
- **A-429** (§379, A-421; live 2026-11-15 16:07: the assigner's rule 1 said a released build "is being built", since
it knew build ends only from a stream it read from its start on, kept by age, not one per subject as the builder's
manifest declares; principles 2 and 7) A build whose version is released (`version-released` heard for its
fingerprint's parts) is done for rule 1, as §379 takes its parts from that event; `build.ended` counts for a build
not released (another watched branch, a kept build). The assigner reads the builder's build ends whole at its start.
That the bus keeps that stream by age, not one per subject as declared, is a fault of the grants part, noted.
- **A-426a** (A-426, ADR 0614 §2; live 2026-11-15 16:15: rule 8 holds the pipeline runner's want, "the verb
seat:mesh-hand-acts.hand-act mesh-delivery-pipeline invokes is served by no running build", while mesh-hand-acts runs
on the control-node and serves that verb with a build from before G; principles 2, 3 and 7) A-426 holds for every
rule that waits on another part, the acting waits and rule 8 (an invoked verb served) alike: a part counts as
serving when a node runs a build of it that serves the seat or verb and is healthy, from its running statement and
the tool runner's announcement, whatever its version and whether or not the catalog lists that build. The rule says
which build it counted.
- **A-430** (§379, §525, §526; the operator, 2026-11-15 about 16:45 CET: "the artifacts simply carry the module
version of course, why would a module have a version otherwise"; principles 6 and 7) A want names the module and its
released version (and the kept-on node for a kept build), never its artifacts' digests: the node-engine fetches each
artifact the module's catalog entry names under that version from the registry seat that holds it, as the registry
tags it, and the registry's answer is what it applies. §379's digests in the want, and the assigner's check whether
a node's node-engine reads them (`want-parts`), go. A build of another watched branch, which has no released
version, is named by the version the builder numbered it under.
- **A-430a** (A-430; principles 7 and 8) Every build a want names has a version: a released trunk build its released
version, a build of another watched branch the version the builder numbered it under (A-430), and a kept build its
numbered version with `kept-on` naming the node that keeps it (§526); a want never names a fingerprint's artifacts
or digests. The node-engine resolves each artifact the catalog entry names at that version through the seat that
holds its kind (`oci-artifact-registry` for a bundle or archive, `container-image-registry` for an image), by its
verb `versions` with the artifact's registry name `<module>/<artifact>`, and fetches the bytes as today over the
artifact store by the digest that answer gives; an image is pulled by name and version. The node-engine's manifest
invokes those `versions` verbs; no registry verb is added.
- **A-430b** (A-430a, §52, §53, §371; principles 7 and 8) The version a build of another watched branch is numbered
under is the one the builder reserved when its build started (§52), never released: `build.ended` names it as
`version` for every build that reserved one, and the registry seat that holds each artifact tags a branch build's
artifact at that reserved version without releasing it, so the node-engine resolves it through `versions` like a
released one. §371's and §53's "stored by digest with no version" becomes "tagged at its reserved version,
unreleased"; the `package-published` comparison by digest stays. Order within G: the node-engine's resolution by
version first (it unblocks every released build), then the builder and registry tagging; until those land, a want
for a branch build keeps its digests for a node whose node-engine reads them, and that form goes with them.
- **A-431** (§476, §493, §648, A-34; live 2026-11-15 17:44: the pipeline runner heard eight `take-in.taken` with no
branch and no source revision, started no pipeline and asked each again for ever; principle 7) The source revision a
take-in names is one above the newest the indexer has seen of that branch (the gate's `source-moved`) or named in an
earlier `take-in.taken`; the gate's `source.<branch>` then moves to it (A-34). Every taken event of one take-in carries
the same `branch`, `source` and `entries`, so a reader keyed by branch and source revision (the runner, the gate)
acts once; a taken event that took nothing in (a group's end, one said before G) carries none, and the runner writes
it in its journal and lets it go (§493).
- **A-432** (§524, ADR 0259 §8; principle 7) A module of its own account is run by a runtime of its own, a process
whose program is the tool runner's build, not the module's: the check of §524 leaves that process out, and the tool
runner's own want checks its program. Every other archive, process and container of the module's composition is
checked against its want's `parts` as §524 says. (novox, 2026-11-16 01:00 CET: the new indexer was held
"parts-differ: fetched and not in the want's parts" for the tool runner's program.)
- **A-433** (A-389, §19; principle 6) While its catalog half is unread, a tool runner runs unmarked every call whose proven
caller is a module's account, a seat verb as a module tool, and a module's own call in a runtime of its own; it holds the
mesh MCP server's account (the one sessions and agents call as), a person, the controller and an unproven caller as before.
Approval marks are for agent calls; inside the mesh a module may do everything. (novox, 2026-11-16 02:35 CET: the
indexer's runtime of its own refused its own `mesh-catalog.revision`, the very first view it waits on, so every reader
of the catalog waited for ever.)