Design 47 G: the lead's answers A-363 to A-372 (G starts) #609
@@ -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.)
|
||||
|
||||
Reference in New Issue
Block a user