Merge pull request 'Design 47 G: the lead's answers A-101 to A-111' (#565) from design/47-G-lead-answers-7 into main

2026-11-11 23:12:59 +00:00
parent d65ed10931 369c875358
commit 84e9f8a192
1 changed files with 52 additions and 0 deletions
@@ -396,3 +396,55 @@ names the principle that settles it, and is cited as "design 47 G A-n".
 - **A-100** (§379, A-96; principle 7) As built in mesh-delivery a5e1a5e5 and 5a352482: `build.ended` is said for a done
  build only; its `branch` is empty for the trunk; its old-section stream keeps 7 days with no keep-last setting (an
  old `streams` entry has none), which A-96's "kept last per subject" gives up.
 - **A-101** (§532, §521, A-74, A-89; principles 1, 3 and 7, shared code in mesh-sdk) mesh-sdk's `stdio.TopicMatches`
  understands the bus's own `>`, so an adopted follower's `<seat>.<event>.>` hears every event, not the first view only.
  The operator-channel asker (the seat holder found on the seat list, the ask published, the router's record read for
  the warrant, `decided` heard) is one mesh-sdk helper that the builder, the teller, the indexer and the runner use; no
  module keeps its own copy. A step's own bound is a key with its own time to live too (A-77), not a timer.
 - **A-102** (§22, §24, A-97; principle 7) A part that puts work on a seat's accepted kind names it in `invokes` as
  `seat:<seat>.<kind>` (the runner: `seat:mesh-builds.step` and each build seat's `check.step`), and the grants part
  composes the publish of that accept subject from it, as it composes a verb's call.
 - **A-103** (§532, §614; principle 7, shared code in the follower) When two watched branches list one module, the
  module's own registration decides: its first branch is the one read. The `Entry` and `Ready` helpers over the branch
  follower, the `<module>_entry_again` tool, the `entry-not-found` finding and the entries rows of
  `<module>_first_views` are built once, in `meshcatalogclient` and mesh-sdk's views, and every reader uses them.
 - **A-104** (§22, §70, §482, §25, §416, §535, §647, A-70, A-77, A-68; principle 7) The runner's write verbs (`review`,
  `rerun`, `accept`, `cancel`) are served by its tools bundle, which writes the state `pipelines` by compare-and-set and
  says `step-ended`; an optional step still waiting does not hold a pipeline's end, only a required one does. A step
  ask's kept results are the `kept` entries whose `package` is the artifact's package (from the entry); its
  `toolchain` is the runner's `toolchain.<language>` kept as heard from `toolchain-agreed`. An unanswered ask is read
  from the build seat holder's `ask-taken` as §647 says (not the seat list), its five minutes a key with its own time to
  live in a state `bounds` of the runner.
 - **A-105** (A-104; principle 7) The runner keeps what it hears of `toolchain-agreed` in a state of its own,
  `toolchains` (history 1), key `<language>`, value its language, version and digests; a step ask's `toolchain` is read
  there.
 - **A-106** (§25, §416, §535, §647, A-104; principle 7) As built on the runner's recover branch (239a6693, e8b69509,
  2d9c6591): a kept result counts for an artifact when its package is the artifact's or lies beneath it; the ask's
  toolchain carries language and version; only the three build seats' asks are bounded by `ask-taken`; the five
  minutes are a constant; an expired step ends `could not run` and the others run on. The runner's write verbs wait on
  the operator's answer whether a process may answer calls (then the process writes `pipelines` by compare-and-set
  itself); the runner gains a whole-module integration test against the bus in G.
 - **A-107** (the operator, 2026-11-11 about 23:45 CET: yes, a process may answer calls; principles 1 and 7; withdraws
  A-45, A-59, A-60's bundle principal, A-70, A-87's bundle part and A-104's bundle part) mesh-sdk's rule that a process
  answers no call (issue 1171, AC3) is removed: a process answers its seat's verbs directly over the bus, with the
  proved caller, through one mesh-sdk call. The part that holds the data answers for it: the bus module's keeper serves
  `mesh-broker`'s verbs and sends the chunks itself; the builder's process serves `reserved` and `builder_build`; the
  runner's process serves `review`, `rerun`, `accept` and `cancel`, writing `pipelines` by compare-and-set; the chunk
  subjects go to the process that answers.
 - **A-108** (§630, §214, §406, §516; principle 7) The catch-up is the node agent's: after the restore and the `Apply` of
  the reverted build, it calls the point's recorded `{tool, arguments}` as that module's tool on its own node through
  the tool runner, as `holder:node-engine` is granted (§406); `restore-kept` carries the snapshot only. §630's "passes
  its catch-up to restore-kept" reads "runs its catch-up after it".
 - **A-109** (A-107, §681, ADR 0675; principles 6 and 7) A process that answers its seat's verbs declares them in its
  manifest's process section as `serves` (mesh-sdk's `ProcessBus` takes the field, its old "a process serves nothing"
  gone), and the grants part composes the process account's subscribe of `mesh.seat.<seat>.call.<verb>.*` and
  `.tool.<verb>` from it, plus, for a `chunks: true` verb, the publish of `.chunk.<verb>.>` and the subscribe of
  `.ack.<verb>.*.*`. A snapshot's chunks are a transfer, published on the core bus with no stream; any caller of
  `snapshot-get` receives the chunks (who may hear them is no question), a protected snapshot never.
 - **A-110** (A-109; principle 7) A process's `serves` is a list of `seat:<seat>.<verb>` strings, the form of `invokes`
  beside it; whether a verb sends chunks is read from its seat definition (`chunks: true`), never declared again.
 - **A-111** (§22, §70, §482, A-104, A-107; principle 7) As built in mesh-delivery 210abfc8 and bb51e59a: a rerun's ask id
  carries its time; a rerun carries the kept results and toolchain; `rerun` of `approval` is refused naming
  `ask-again`; `cancel` drops the asks' bounds and leaves what the build seats already took; the hand act's verb is
  `mesh-pipeline-runner.<verb>`; a review ends every running pipeline at that commit and fingerprint waiting on one. A
  review given after a pipeline ended passed is refused, as built.