|
|
|
@@ -3,7 +3,7 @@ layer: to-be
|
|
|
|
|
status: in-progress
|
|
|
|
|
design: 47
|
|
|
|
|
milestone: G
|
|
|
|
|
updated: 2026-11-17
|
|
|
|
|
updated: 2026-11-13
|
|
|
|
|
decisions:
|
|
|
|
|
- "ADR 0667"
|
|
|
|
|
---
|
|
|
|
@@ -746,754 +746,3 @@ 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.)
|
|
|
|
|
- **A-394** (A-392; principle 3) A build seat's finding writer that cannot start is said in the module's journal and in
|
|
|
|
|
its health, and the module serves its steps on: a step's verdict never waits on a finding being written.
|
|
|
|
|
- **A-434** (A-433, §19; the operator, 2026-11-15 about 23:15 CET: "I only see 3 accounts, the mesh account, the agent
|
|
|
|
|
account and the operator account. The mesh accounts should have all the permissions"; "we can always add in gates and
|
|
|
|
|
guards later") Until the research on the mesh's accounts replaces it, every account the grants part composes but an
|
|
|
|
|
enrolling node's may publish and subscribe on every subject and put an ask on any seat; a seat verb answered by a
|
|
|
|
|
process and a tool runner's seat verb admit every caller; no seat loses its holder for every account hearing it.
|
|
|
|
|
Approval marks stay, for calls that are not a module's (A-435).
|
|
|
|
|
- **A-435** (A-433, A-434) Approval is the one mark kept: while a verb's seat definition is unread, a call of a verb
|
|
|
|
|
that may need approval from a caller that is not a module's account (the mesh MCP server's, a person's, an unproven
|
|
|
|
|
one) is held as before, never run unmarked; a module's account runs it.
|
|
|
|
|
- **A-436** (A-430b; principle 7) Until every node-engine reads a want by its version, a want for a node whose
|
|
|
|
|
node-engine reads parts carries the build's parts beside its version, and a module wanted with no passed pipeline
|
|
|
|
|
names the parts its `build.ended` made until its release is heard. Both forms go in the first change after G is
|
|
|
|
|
delivered, with A-430b's.
|
|
|
|
|
- **A-437** (A-428, §16; principle 7) The holder of `mesh-catalog` is wanted with no passed pipeline, as the pipeline
|
|
|
|
|
runner's own want is: every pipeline runs on a revision it took in, so it cannot wait on one. Every other module still
|
|
|
|
|
waits.
|
|
|
|
|
- **A-438** (A-426a; principle 7) For an acting wait, a running have whose node-engine states no health counts as
|
|
|
|
|
healthy, since an engine from before G states none; and a node that is online runs its node-engine, since online is
|
|
|
|
|
that engine's own word. Both go when every node-engine states health.
|
|
|
|
|
- **A-439** (principle 4) The assigner's tool `assigner_why` says why a want is what it is: the step of the pass that
|
|
|
|
|
decided it and what it read, kept as `why.<node>.<module>` in its state `written`. Until a manifest naming the tool
|
|
|
|
|
is taken in, `assigner_written` with `why` answers it; that stand-in goes with A-436's forms.
|
|
|
|
|
- **A-440** (the operator, 2026-11-15 about 18:35 CET) A build seat's queue serves its kinds in turn, so no kind of step
|
|
|
|
|
waits behind another's backlog.
|
|
|
|
|
- **A-441** (principles 3, 4 and 7; each a fault met live while G was brought up, fixed where it lives) These stand:
|
|
|
|
|
an ask's words cut a digest or fingerprint to 12 digits, so the operator channel does not withhold the ask as a
|
|
|
|
|
secret, and the backup ask names its composition by that prefix; the indexer writes the first registrations from the
|
|
|
|
|
module graph it holds, with no ask (the operator, 2026-11-14: a module in the module graph is a registration), and a
|
|
|
|
|
seed asked again writes what its key composed, ends no proposal key, logs each step with its time and prunes nothing
|
|
|
|
|
on a first registration (completing A-392); a pipeline step fetches a module directory only by its artifact's paths;
|
|
|
|
|
grants makes each seat's ask stream the bus lacks, from the seat list, with its part's account allowed to; a state is
|
|
|
|
|
read in pages, never a key at a time, and the indexer's tools keep their view of the trunk while its revision stays
|
|
|
|
|
the newest (a read over bus state); a get session's object reader lives as long as the session; the forge bridge
|
|
|
|
|
names each member of a group once and answers open groups or one group, never every ended one; grants reads its
|
|
|
|
|
loaded list one user per answer, so no answer outgrows one bus message.
|
|
|
|
|
- **A-442** (A-401; principle 7) The gate's start pass runs once; it asks again only while the registrations cannot be
|
|
|
|
|
read. A repository it leaves out is said and added at the next registration change or by hand, as A-401 says.
|
|
|
|
|
- **A-443** (principle 3) Each bus step of a distribution publish is bounded at 10 seconds and logged by name; a step
|
|
|
|
|
past its bound is given up and said, and its call is cancelled with it, never left running behind.
|
|
|
|
|
- **A-444** (the seat `git`'s contract; principle 7) The seat `git`'s `branch` with no branch named answers the
|
|
|
|
|
repository's default branch, as the forge names it; a build seat says each toolchain it reported, not only the ones
|
|
|
|
|
it could not.
|
|
|
|
|
- **A-443a** (A-443; principles 3 and 7) A step given up at its bound is not cancelled through the SDK, whose bus calls
|
|
|
|
|
take no context: its call ends at the SDK's own bound of the ask, and distribution logs, by the step's name, that it
|
|
|
|
|
gave the step up and, later, when the call behind it ended and how. No context is added to the SDK for it.
|
|
|
|
|
- **A-445** (A-379 replaces A-376 and A-378 for the start; principle 7) The bus keeper reads nothing of the seat
|
|
|
|
|
`mesh-catalog` before the first views: its A-376 path, and the manifest's consumes of `seat:mesh-catalog.views.modules`
|
|
|
|
|
and `.views.manifests` and invokes of `seat:mesh-catalog.modules` and `.manifests`, go, since the seat offers neither
|
|
|
|
|
those views nor those verbs and the validator refuses them.
|
|
|
|
|
- **A-446** (replaces A-195, A-206 and A-218, and §266's hold of pipelines for the runner's new version; the operator,
|
|
|
|
|
2026-11-16 about 10:35 CET: "yes remove the hold"; principle 7) The pipeline runner holds no pipeline for its own new
|
|
|
|
|
version: a take-in that changes the runner starts its pipelines as any take-in does, run by the runner that runs, and
|
|
|
|
|
the runner's new version is wanted once its own pipeline passed, as any module's. The state `bounds`' held keys, the
|
|
|
|
|
wait's `on` value `runner version`, the finding `pipeline-waits` and the verb `release` go. A pipeline a runner before
|
|
|
|
|
this one left held is started at the runner's start, as a newly started one. (Live, 2026-11-15 18:05 to 2026-11-16:
|
|
|
|
|
every pipeline was held for a new runner whose want waited on that runner's own held pipeline, so none ran a step.)
|
|
|
|
|
- **A-446a** (completes A-446; principles 3 and 7) When the runner places a pipeline whose steps were never asked, it says
|
|
|
|
|
`pipeline-started` for it, a pipeline a runner before it set aside included: the watchman ends a branch head's wait
|
|
|
|
|
on that event alone, and hearing it twice for one head ends the same wait again. What only the set-aside used goes
|
|
|
|
|
with it: the seat definition's `acts` entry for step `pipeline` and its 30-minute bound, the runner's wait `step` value
|
|
|
|
|
`pipeline` and the wait's `clock-from`, and the tools `runner_waits` and `runner_release`; G-5 §174 and §190 and G-10's
|
|
|
|
|
lines naming them are replaced by A-446.
|
|
|
|
|
- **A-447** (the build source of a Go artifact is its own module and what it loads, ADR 0267 §1; principle 7; the
|
|
|
|
|
operator, 2026-11-16 about 11:00 CET: "start the fix") The Go build module's fetch, asked with a module's directory
|
|
|
|
|
(`dir`), downloads, resolves and judges the go.mod and go.sum of that directory's Go module alone, and of each
|
|
|
|
|
directory its go.mod replaces with a local path, followed through their own replaces; never another Go module of
|
|
|
|
|
the fetched tree. A fetch asked with no `dir` (a check of a whole repository) does every Go module of the tree, as
|
|
|
|
|
before. The builder names the module's directory on every fetch it asks, not only for a module that names its paths;
|
|
|
|
|
the pipeline runner already does. (Live, 2026-11-16: every build and pipeline step of mesh-delivery's assigner,
|
|
|
|
|
builder, checker, teller, view and watchman at 901c800c failed on the indexer's `takein` go.mod, which none of them
|
|
|
|
|
loads; their fingerprints did not move with #219's fix, so they could never pass.)
|
|
|
|
|
- **A-447a** (completes A-447; principles 3 and 7) A module's own Go modules are the go.mod of its directory or, when
|
|
|
|
|
its directory holds none (a module at the repository's root whose Go code lies in `go/`, a contracts module with a
|
|
|
|
|
go.mod per seat), every go.mod under its directory (in a narrowed tree, under its paths); then each one's local
|
|
|
|
|
replaces, as A-447 says. A fetch asked with a `dir` that chooses no Go module fails, naming the directory: it never
|
|
|
|
|
goes on to steps that would pass with nothing tested or built.
|
|
|
|
|
- **A-447b** (replaces A-447's "a fetch asked with no `dir` does every Go module of the tree"; the operator, 2026-11-16
|
|
|
|
|
about 11:30 CET: "a build is also for a module, not/never a repo"; principles 3 and 7) A build, a step and a check are
|
|
|
|
|
always for one module. Every fetch of a build seat names its module's directory; a fetch with no `dir` is refused,
|
|
|
|
|
naming its asker, and no step runs on a whole repository. Every caller that asks a fetch with no `dir` today names the
|
|
|
|
|
module it builds or checks, in the same change.
|
|
|
|
|
- **A-447c** (principle 10, added 2026-11-16 at the operator's word: "nothing is ever repo-based") A-447b holds for
|
|
|
|
|
every part of building, checking and delivering, not only the fetch.
|
|
|
|
|
- **A-447d** (A-447b; principle 10) The checker's check of a pull request asks one fetch per module the pull request
|
|
|
|
|
changes, each naming that module's directory, and judges each module apart; it never fetches a repository whole.
|
|
|
|
|
- **A-447e** (replaces A-447d, and A-447b's refusal until then; G-6 §321; principles 7 and 10) The checker's check of a
|
|
|
|
|
pull request is removed with the checker at G's delivery (§321), so it is not rebuilt per module. Until it is, the
|
|
|
|
|
Go fetch's one caller with no `dir` is that check, and a fetch with no `dir` still fetches the tree whole for it;
|
|
|
|
|
every pipeline step and build names its module (A-447 to A-447c). The refusal of a fetch with no `dir` lands with
|
|
|
|
|
the checker's removal.
|
|
|
|
|
- **A-448** (§476, §493, §200; principles 3 and 7) `take-in.taken` names the catalog graph revision the take-in made
|
|
|
|
|
(`revision`), written by the indexer with the event. The runner starts each pipeline of a take-in at that revision,
|
|
|
|
|
never at the revision its own view holds; while its view holds an older one, it waits for it (§200) and places no step.
|
|
|
|
|
(Live, 2026-11-16: main.947 was started at revision 356 while its take-in made 357; its composition read 356 after
|
|
|
|
|
the indexer had removed it.)
|
|
|
|
|
- **A-449** (§153, §579, design 47's "kept while a delivery record pins it or it is current"; principle 7) A pipeline
|
|
|
|
|
pins its catalog graph revision as a delivery record does: the runner says the seat `mesh-delivery`'s `pinned` when it
|
|
|
|
|
starts a pipeline and `freed` when the pipeline ends, under the record id `pipeline.<key>`, so the indexer keeps the
|
|
|
|
|
revision while any pipeline runs on it. No new mechanism; who may say them is a grant of the runner's account.
|
|
|
|
|
- **A-449a** (completes A-449; principles 3 and 7) The indexer pins the revision a take-in made for each pipeline the
|
|
|
|
|
take-in starts, under `pipeline.<key>` (`<branch>.<source>.<module>` of each entry), in the same write as it keeps the
|
|
|
|
|
revision, so no later take-in can remove it before the runner hears of it. The runner's pin at a pipeline's start stays
|
|
|
|
|
(a set: saying it twice is harmless) and its `freed` at the pipeline's end removes it.
|
|
|
|
|
- **A-226b** (completes A-226 and A-167; ADR 0593 §7; principles 7 and 9) The seat `node-engine`'s `compose-candidate`
|
|
|
|
|
takes three key forms, parsed by one parser in the seat's client (`nodeengineclient`) that every caller builds its key
|
|
|
|
|
with: a check's candidate `<group>.<heads hash>` (as today), a branch pipeline's revision `<branch>.<revision>` and a
|
|
|
|
|
run's `run-<id>`. For a revision key the node-engine reads that catalog graph revision's entries through
|
|
|
|
|
`mesh-catalog.revision` and composes them as the candidate; for a run's key it reads the run's candidate from the
|
|
|
|
|
indexer's `runs` state. The seat definition's `candidate` input names the three forms. The assigner builds its key
|
|
|
|
|
with the client's builder, never by hand. (Live, 2026-11-16: main.948's composition step: "\"main.362\" is not a
|
|
|
|
|
composition key".)
|
|
|
|
|
- **A-226c** (corrects A-226b's run form; A-160; principle 7) For a run's key `run-<id>` the node-engine reads the run's
|
|
|
|
|
candidate from the indexer's `candidates` state under the group `run-<id>`, as it reads a check's candidate, with no
|
|
|
|
|
heads comparison; the `runs` state holds only a run's members and their ends.
|
|
|
|
|
- **A-450** (ADR 0663 §2, ADR 0621 §2; principle 7) A verb of the seat `mesh-catalog` that checks its callers takes the
|
|
|
|
|
node-engine's account `node.<machine>` as the module whose trunk entry serves the seat `node-engine`, and grants it
|
|
|
|
|
when that module declares the verb in `invokes`, as for any part. (Live, 2026-11-16: main.949's composition, "mesh-
|
|
|
|
|
catalog.revision is refused to \"node.novox\"".)
|
|
|
|
|
- **A-237b** (A-237, A-249; principles 3 and 7) The seat `node-engine`'s `compose-candidate` is a verb marked `chunks`:
|
|
|
|
|
asked with `input`, the node-engine sends the composition input in chunks (`buscalls.SeatChunks`) over its own bus
|
|
|
|
|
connection, whatever its size, and its answer names the chunks; the assigner takes it through its ordinary chunked
|
|
|
|
|
seat call (`CallFile`), as it takes the indexer's `input`. No size bound refuses an input any more. (Live,
|
|
|
|
|
2026-11-16: main.952's composition input was 1,000,641 bytes, over the 921,600 one answer carries.)
|
|
|
|
|
- **A-237c** (completes A-237b; G-6 §321; principle 7) An ask of `compose-candidate` that names no `call` token (the
|
|
|
|
|
checker's, until the checker is removed at G's delivery, G-6 §321) keeps the inline input and its 900 KiB bound; an
|
|
|
|
|
ask with a token gets the input in chunks only, with no bound. The assigner reads an inline input only from an engine
|
|
|
|
|
that answers no `chunks` (one before A-237b); both forms go with the checker.
|
|
|
|
|
- **A-451** (completes A-226, A-243 and A-252; principles 2 and 3) Where a machine's node-engine is not heard running
|
|
|
|
|
(no `running` of the module holding the seat `node-engine` on that machine, or one with no fingerprint), the
|
|
|
|
|
composition step builds that machine's composer from the revision's node-engine entry, the build the catalog says
|
|
|
|
|
the machine runs, and its log says so with the machine and the entry's fingerprint; the step does not stop on it.
|
|
|
|
|
(Live, 2026-11-16: main.953's composition could not run, "novox: no build of mesh-host is heard running there": a
|
|
|
|
|
node-engine running a build the catalog holds no entry for says no `running`.)
|
|
|
|
|
- **A-452** (extends A-405 and A-407 as ADR 0636 §3 does for claims; principles 10 and 3) A requirement nothing on the
|
|
|
|
|
node or in the rest of the mesh answers costs the modules that want it, not the machine: each such consumer stays on
|
|
|
|
|
the build it runs, its have saying why (the same "nothing provides" words, naming the provision), as a refused claim's
|
|
|
|
|
claimant does, and every other module of the node composes. The machine is refused only when what fails is the node's
|
|
|
|
|
own composition or no module could be composed at all. (Live, ace 2026-11-16 23:11: the node refused its whole
|
|
|
|
|
composition on ten unanswered requirements, eight of them of modules already staying on their builds with
|
|
|
|
|
`entry-missing` or no part digest, so the tool runner's released build 7df8e170 (`node-tools`) was never composed there.)
|
|
|
|
|
- **A-453** (ADR 0539 §16, §541; principles 3 and 1) The operator is asked about a backup only when a backup failed. Every
|
|
|
|
|
other hold the node-engine writes in a have (an entry asked or missing, §421; parts that differ; a kept data's form
|
|
|
|
|
not known) carries its `wait` with step `compose` and its reason, as §541 says; a hold for a failed backup carries
|
|
|
|
|
none. The assigner raises the backup ask of ADR 0539 §16 only for a held have with no `wait`, and withdraws a backup
|
|
|
|
|
ask whose have now carries one or is no longer held. (Live, 2026-11-17 00:32: the assigner asked "The backup of avahi
|
|
|
|
|
failed on ace" and the like for about forty modules held only for `entry-missing` or `entry-asked`.)
|
|
|
|
|
- **A-453a** (A-453, ADR 0539 §16; principle 3) "No longer held" in A-453 means the have has moved past the hold: running,
|
|
|
|
|
removed, or at another fingerprint. A have in the middle of a move (`backing-up`, `applying`, `checking`) is not "no
|
|
|
|
|
longer held", so the backup ask stands while the node backs up again after an "again" answer, and a second failure
|
|
|
|
|
is asked under the next number, as §16 says. "At another fingerprint" applies only to a have that is not held: a held
|
|
|
|
|
have names the build it keeps running, which on a failed backup's hold is never the want's, so a held have has not
|
|
|
|
|
moved past its hold (corrected 2026-11-17, from the review of A-453's assigner half).
|
|
|
|
|
- **A-454** (§421's parts check, A-432; principles 7 and 3) A want's parts are the artifacts the mesh built for the
|
|
|
|
|
module. The node-engine's check that what a composition fetches matches the want's parts counts only what is fetched
|
|
|
|
|
from the mesh's artifact store (a bundle, an archive, a program, or a container image the mesh built, named through the
|
|
|
|
|
artifact store or the registry seat); a container image the manifest pins from outside (an upstream image by its digest)
|
|
|
|
|
is no part and is never "fetched and not in the want's parts". (Live, novox 2026-11-17 00:46: distribution 0.1.11 held
|
|
|
|
|
"parts-differ: fetched and not in the want's parts" for the upstream `registry` image its manifest pins.)
|
|
|
|
|
- **A-455** (§369, §588; principles 4 and 3) A trunk build that starts while its series is reserved by an older build of
|
|
|
|
|
the module that was never released takes the reservation over: the newer build reserves the series' next version, the
|
|
|
|
|
older one, which no want follows any more, is dropped and said so in the builder's log. And a done trunk build that
|
|
|
|
|
reserved no version is given one by the builder's tool `builder_reserve_done` (module, fingerprint, why; a hand act):
|
|
|
|
|
it reserves the next version of the series for that fingerprint with the build's artifact digests and queues its
|
|
|
|
|
publish as §588's publish-again does. (Live, 2026-11-17 00:49: the tool runner's (`node-tools`) 0.1.13 stayed reserved for build b5c7a048,
|
|
|
|
|
whose entry was gone, so the passed build 7df8e170 of main.984 reserved nothing, was never released, and its wants
|
|
|
|
|
carry no parts; a done key cannot be built again.)
|
|
|
|
|
- **A-454a** (A-454; principle 3) The A-454 exception applies only to the direction "fetched and not in the want's parts":
|
|
|
|
|
a digest the want's parts name always counts as fetched when the composition fetches it, whatever marks its
|
|
|
|
|
resource carries; a fetched digest the parts do not name is counted only when it is the mesh's own (named through
|
|
|
|
|
the artifact store or the registry seat, and not an upstream copy). (From the review of A-454: a mesh-built image
|
|
|
|
|
whose seat holder is not on record carries no `image-seat`, so skipping it would hold the module on its own part.)
|
|
|
|
|
- **A-456** (§369, §588, A-455; principle 3) A pipeline's build step passes only when the build it judges has a
|
|
|
|
|
reserved version for its fingerprint. A build that ended done with no reservation fails the step loudly ("built at
|
|
|
|
|
<fp>, but no version is reserved for it"), naming `builder_reserve_done` as the recovery, so no pipeline says
|
|
|
|
|
"passed" for a build that can never be released. (Survey 2026-11-17 00:58: the tool runner's build 7df8e170 passed
|
|
|
|
|
main.984 and was never released.)
|
|
|
|
|
- **A-457** (§588; principles 1, 3 and 4) A version's publish is work the builder owns until `version-released` is
|
|
|
|
|
written for it: every reservation of a done build is a publish item on the builder's own work queue, asked when the
|
|
|
|
|
build ends, redelivered after a failed or unanswered publish with a growing pause (a setting, principle 11), and
|
|
|
|
|
acknowledged only once the release is written. At its start the builder puts on the queue every reservation whose
|
|
|
|
|
build is done and that has no release, so what stood before this change moves too. A publish that fails its
|
|
|
|
|
setting's number of tries is said loudly (log and condition) and stays readable in the builder's tools; it is never
|
|
|
|
|
waited on a `running` or `manifest-reads-changed` event any more. (Survey 2026-11-17: 115 reservations, 108 built,
|
|
|
|
|
3 released.)
|
|
|
|
|
- **A-458** (§354's composition step; principle 3) The composition step judges by what the composer said: when it judged
|
|
|
|
|
no candidate (every verdict "not judged"), the step ends "could not run" with the composer's words, never "passed";
|
|
|
|
|
a step passes only when at least the candidates it was asked are judged and none refused. The asker (the assigner)
|
|
|
|
|
names the seat list in the request's `seats` from the seat list it holds (ADR 0636), so the composer has what it needs
|
|
|
|
|
to judge. (Survey 2026-11-17: 86 of 141 pipelines "composition could not run", and the code read "not judged" as a
|
|
|
|
|
pass.)
|
|
|
|
|
- **A-459** (the assigner's rule 7; principles 10 and 3) Rule 7's "composed" is asked per module: a module waits only
|
|
|
|
|
on the composition of its own have at the fingerprint it waits for, on that node, never on whether the node composed
|
|
|
|
|
anything else. One module that does not compose on a node never holds another module there. (Survey 2026-11-17:
|
|
|
|
|
`composed(node, module, fp)` read the node's own have and ignored module and fingerprint, so one node that composes
|
|
|
|
|
nothing held every module on it.)
|
|
|
|
|
- **A-460** (A-452, ADR 0539; principles 10, 3 and 2) A node-engine's install of a build of itself that fails (the
|
|
|
|
|
version's folder cannot be made, its archive not fetched) costs the node-engine's own have only: it stays on its
|
|
|
|
|
current build, its have says why with the error's words, and every other module of the node composes. The
|
|
|
|
|
node-engine makes its versions folder where its own unit lets it write; a refusal there ("operation not permitted")
|
|
|
|
|
is a fault of the node-engine's install and is fixed in it, not on the machine. (Live, ace 2026-11-16 23:33: the
|
|
|
|
|
node composed nothing after `mkdir .../versions/88216c0e9496.unpacking: operation not permitted`; its want for the
|
|
|
|
|
node-engine names an older build, d9e5d175, because no pipeline of the node-engine passed at a newer one; that want
|
|
|
|
|
moves with this change's own passed pipeline, by §29.)
|
|
|
|
|
- **A-461** (A-452, A-407; principles 2 and 10) Where a module on this node needs another node's module (a store
|
|
|
|
|
address, a provider's endpoint) and that module runs a build that has no entry, the node lays it from the entry of
|
|
|
|
|
the build its want names, which is the mesh's truth of what it runs there. Where neither build has an entry, the
|
|
|
|
|
holder stays name-only and only the modules that need its address wait, as A-452's consumers do, with the same
|
|
|
|
|
words; the node is never refused whole for it. (Live, ace 2026-11-17: ace laid the artifact store's holder
|
|
|
|
|
`distribution` name-only, novox running 44a32f00 with no entry while its want names 4133e115, which has one, and
|
|
|
|
|
refused its whole composition, "the artifact store has no address".)
|
|
|
|
|
- **A-462** (§29, A-428; principles 2, 5 and 3) A want of a module that names no version and no parts while the build
|
|
|
|
|
it names has a released version is completed by the assigner in one pass of its own: the want keeps its
|
|
|
|
|
fingerprint (nothing moves, so §29's passed pipeline is not needed for it) and gets that version and its parts. The
|
|
|
|
|
pass runs at the assigner's start and on every `version-released`, and says per want what it filled. A want whose
|
|
|
|
|
build has no entry is not filled: the indexer is asked to take that build in again (`indexer_take_in_pending`), and
|
|
|
|
|
the want says it waits for the entry. (Survey 2026-11-17: 40 to 80 modules per machine on wants from before G with
|
|
|
|
|
no version or parts, `entry-missing` or "want names no digest", and a want was rewritten only after a passed
|
|
|
|
|
pipeline, which waited on A-458.)
|
|
|
|
|
- **A-459a** (A-459; principles 1, 10 and 3) Rule 7 learns "composed" per module from the node-engine's `composed`
|
|
|
|
|
for `<node>.<module>.<fp>` (its digest a composition, a refusal not composed), followed per node as the assigner
|
|
|
|
|
follows the haves, through the read its manifest already declares (`reads`: `mesh-host.composed`); the module's own
|
|
|
|
|
have is not the source, since none names a fingerprint before its want does. (From the develop of A-459:
|
|
|
|
|
`composed(node, module, fp)` read only `<node>.node`. Corrected 2026-11-17: the first wording said "never by
|
|
|
|
|
reading the node-engine's bucket", which contradicted the declared read the haves already use.)
|
|
|
|
|
- **A-462a** (A-462; principles 7, 9 and 3) "A build that has no entry" is a fingerprint the catalog half the assigner
|
|
|
|
|
follows holds no entry for on any watched branch. The assigner asks the indexer nothing for it: taking a build in is
|
|
|
|
|
the indexer's own work on its pending state, and its tool `indexer_take_in_pending` takes the indexer's own keys,
|
|
|
|
|
not a module or a fingerprint. The want says, in its words, that it waits for the entry of that fingerprint, so the
|
|
|
|
|
wait is loud and read with `assigner_why`; that sentence of A-462 about the indexer's tool is withdrawn. (From the
|
|
|
|
|
develop of A-462.)
|
|
|
|
|
- **A-456a** (A-456; principles 3 and 7) A released build counts as reserved: the build step passes a reserving build
|
|
|
|
|
whose fingerprint has a reservation or a released version. The builder knows the second from its own record of the
|
|
|
|
|
`version-released` it wrote for that fingerprint; where that record keeps no fingerprint today, the builder keeps
|
|
|
|
|
it there (its own state), never asking the catalog. (From the develop of A-456: the reservation is deleted at
|
|
|
|
|
release, so a rerun of a released build's step failed "no version reserved".)
|
|
|
|
|
- **A-457a** (A-457; principles 7, 1 and 11) "The builder's own work queue" is no new stream and no new process: the
|
|
|
|
|
publish item is a re-ask in the builder's own re-ask state, the mechanism `builder_reserve_done` and publish-again
|
|
|
|
|
already queue on, consumed by the builder's one process. The value carries its tries and its next try; a failed or
|
|
|
|
|
unanswered publish is written again with tries plus one and a pause of `publish-pause` doubled per try up to
|
|
|
|
|
`publish-pause-max`, and after `publish-tries` tries it ends loudly (log, condition) and stays readable in the
|
|
|
|
|
builder's tools; all three are settings with defaults (30 s, 30 min, 8). (From the develop of A-457: a work-queue
|
|
|
|
|
stream would need a `bus` restating the builder's whole account, or a second process.)
|
|
|
|
|
- **A-461a** (A-461; principles 7 and 1) "The build its want names" for another node's module is read from what the
|
|
|
|
|
composer already holds for every node: the assignment's placed build of that module on that node (absent meaning
|
|
|
|
|
the newest delivered, as the assignment says). The composer watches no other node's wants. (From the develop of
|
|
|
|
|
A-461: the composer holds only its own node's wants.)
|
|
|
|
|
- **A-460a** (A-460; principles 2, 3 and 7) The versions folder's refusal on ace was a hand act (an immutable mark set
|
|
|
|
|
2026-11-13, lifted since), not a fault of the node-engine, so A-460 needs no change to its install. A have that
|
|
|
|
|
failed to install is not tried again on every pass: it is tried again when its want changes (a new fingerprint or
|
|
|
|
|
version), which is how it leaves a stale failure; the node-engine's want on ace still names an older build, and
|
|
|
|
|
moves when this change's own pipeline passes (§29). Trying the failed install of that older build again would put
|
|
|
|
|
an older node-engine on the machine, so no retry is added. (From the develop of A-460.)
|
|
|
|
|
- **A-461b** (A-461a; principles 7 and 9) Where the placement names no build ("the newest delivered"), the composer
|
|
|
|
|
takes that module's trunk build from the seat `mesh-catalog`'s verb `module`, as it already does for a module an
|
|
|
|
|
assignment adds (`addedModule`), and lays the module from that entry. A-461's fallback applies only to another
|
|
|
|
|
node's module, and only when its running build has no entry; and only a store with no known address (the holder
|
|
|
|
|
opens no listen, or two) holds the modules that fetch from it: every other fault of finding the store still refuses
|
|
|
|
|
the node, as before (principle 3). (From the review of A-461: novox's placement of `distribution` names no build.)
|
|
|
|
|
- **A-456b** (A-456a, A-457a; principles 7, 11 and 3) The builder's record of releases is one key per module,
|
|
|
|
|
`released.<module>`, holding its last `released-kept` releases (fingerprint and version; a setting, default 16), the
|
|
|
|
|
oldest dropped when a newer one is written; a rerun of an older build's step than those is judged as a build with
|
|
|
|
|
no reservation. A publish item is deleted when its reservation is dropped or taken over, and when its release is
|
|
|
|
|
written; never because its artifacts are published, so a release that never comes is tried again. At its start the
|
|
|
|
|
builder asks an item for every reservation of a done build, whatever its artifacts. (From the review of A-456a and
|
|
|
|
|
A-457a: one key per release filled the 1 MiB state for good, and an item went before its release.)
|
|
|
|
|
- **A-457b** (A-457, A-457a; principle 7) The builder's setting `republish-max-versions` goes: it bounded what one
|
|
|
|
|
`running` or `manifest-reads-changed` event queued for publish, and A-457 retired that path, so nothing reads it.
|
|
|
|
|
A value set for it in the mesh's configuration is left unread and may be removed there. (From the review of A-457a.)
|
|
|
|
|
- **A-459b** (withdraws A-459 and A-459a; ADR 0571 §6; principles 7 and 10) Rule 7 reads the node's own composition,
|
|
|
|
|
as on main: a node names its composition only after it composed what its wants name, so no node holds a module's
|
|
|
|
|
composition at a fingerprint before a want names it, and a per-module, per-fingerprint read would hold every new
|
|
|
|
|
build on every placed node. That one module costs only itself is the node-engine's part (A-452, A-461): a node that
|
|
|
|
|
composes the rest names its composition, so no module's fault holds the others. (From the review of A-459: four
|
|
|
|
|
order-wait tests fail and no placed node moves once the fixtures write compositions as the node-engine does.)
|
|
|
|
|
- **A-462b** (A-462a; principle 3) A want a rule holds keeps that rule's words, which say why it does not move; A-462a's
|
|
|
|
|
words ("waits for the entry of that fingerprint") are written only on a want no rule holds. (From the review of
|
|
|
|
|
A-462.)
|
|
|
|
|
- **A-463** (ADR 0573 §2; principles 3, 1 and 4) A merge the indexer never took in is noticed and taken in by the
|
|
|
|
|
indexer itself: at its start and on every source revision the gate's source names, it compares each repository's
|
|
|
|
|
`taken` merge with the head that source names, and a repository whose head is newer is taken in as its merged
|
|
|
|
|
message would have been (the catch-up of `indexer_take_in`, for that repository), said in its log, with a condition
|
|
|
|
|
raised while it stays behind (the repository, its taken merge and the head) and cleared once taken. A merge is never
|
|
|
|
|
left untaken in silence, so no package stays published at a commit older than its trunk. (Live, 2026-11-17 02:00:
|
|
|
|
|
mesh-contracts #14, merged 2026-11-16 14:14Z, was never taken in; `packages` kept every mesh-contracts package at
|
|
|
|
|
20b06dbc, and every build of the node-engine since 15:24Z and of the assigner since 22:51Z failed on symbols only #14
|
|
|
|
|
holds.)
|
|
|
|
|
- **A-464** (amends A-463; principles 2, 3, 1 and 4) The gate's source of a watched branch follows every merge into
|
|
|
|
|
that branch, whoever made it: on the forge bridge's `merged` of a repository the source names, at the branch the
|
|
|
|
|
source watches, the gate moves that repository's head to the merge and says `source-moved`, as for a group it
|
|
|
|
|
merged itself; a merge it did not make is said so in its log and its record. At its start the gate compares each
|
|
|
|
|
head with the forge's branch head (through the seat `git`) and moves every one behind it the same way, so a merge
|
|
|
|
|
whose message was lost is followed too. The gate's tool `gate_source_follow` (branch, repository, why; a hand act)
|
|
|
|
|
does the same for one repository now. A-463's comparison in the indexer stays: it then takes in what the source
|
|
|
|
|
names. (Live, 2026-11-17 01:45: the source still named mesh-contracts at 20b06dbc, the node-engine's `mesh-host` at 13fcfae0 and
|
|
|
|
|
mesh-delivery at 8c4489fb, though #14, #232, #233 and #237 were merged into their mains; every merge made outside
|
|
|
|
|
the gate, as in recovery, was never taken in, built or delivered.)
|
|
|
|
|
- **A-464a** (A-463, A-464; principle 4) The indexer's state `takeins` is read with the tool `indexer_read_takeins`, as
|
|
|
|
|
`indexer_read_taken` reads `taken`: every key, or one key, with its ask, whether and when the indexer answered it and
|
|
|
|
|
its answer, and how full the state is against its cap. A take-in asked by hand and never answered is then seen, not
|
|
|
|
|
guessed. (Live, 2026-11-17 01:39: the catch-up of `indexer_take_in` answered "in takeins.catch-up", and no tool could
|
|
|
|
|
read that key.)
|
|
|
|
|
- **A-464b** (A-464; principles 7 and 3) A merge the gate did not make is one whose `merged` names no delivery group of
|
|
|
|
|
the gate. "Said so in its log and its record" is its log line (the repository, the branch, the merge and "not made by a
|
|
|
|
|
delivery group of the gate") and its `source-moved`, which then names no group; the gate writes no other record for
|
|
|
|
|
it. (From the develop of A-464: the gate holds no merge state of its own for such a merge.)
|
|
|
|
|
- **A-464c** (A-464; principles 2 and 7) The gate moves a head of its source only forward and only when it changes: on a
|
|
|
|
|
`merged`, at its start and through `gate_source_follow`, it moves a repository's head to a merge only when the head it
|
|
|
|
|
holds is contained in that merge (through the seat `git`), and it writes no source revision and says no
|
|
|
|
|
`source-moved` when the head would stay the same, as on `take-in.taken` for a head a `merged` already moved. A merged
|
|
|
|
|
message heard again, late or out of order is so left without effect, said in its log. (From the develop of A-464: a
|
|
|
|
|
replayed message moved heads backward, and each merge wrote two revisions.)
|
|
|
|
|
- **A-463a** (A-463, A-464; ADR 0633 §4; principles 3 and 7) A head the source names that the indexer's pending holds
|
|
|
|
|
(a merged message waiting for its group's end or its build) is not behind: it is taken in by that path, whole with its
|
|
|
|
|
group, and raises no condition. The comparison takes in, through the catch-up, only a head that no pending item holds
|
|
|
|
|
and whose taken merge it contains. A source revision heard while a catch-up runs is compared again when that catch-up
|
|
|
|
|
ends, so none is skipped. (From the review of A-463: under A-464 the source moves at each member's `merged`, before its
|
|
|
|
|
group ends, so a catch-up there took one member of a group in alone.)
|
|
|
|
|
- **A-464d** (A-464c; principle 2) Every move of a head of the gate's source is forward only, the move at `take-in.taken`
|
|
|
|
|
too: a head moves only to a merge that contains the held head, and a later merge that already moved it is never moved
|
|
|
|
|
back. (From the review of A-464c.)
|
|
|
|
|