03-DESIGN/01-to-be/47-milestones/G-20-lead-answers.md

@@ -275,3 +275,124 @@ names the principle that settles it, and is cited as "design 47 G A-n".
 - **A-70** (§572, A-45; the rule that a process answers no call) The builder's tools bundle serves `reserved` and
   `builder_versions`, following the catalog half's view itself as other bundles follow views; the builder's process
   serves no call.
+- **A-73** (§588, §369; principle 7) To publish again, the builder takes each artifact's kind and package name from the
+  catalog entry of the reserved commit, and sends the registry seat's `publish` with the digest and no parts: the
+  holder takes the bytes from the artifact store, addressed by digest (A-50). "Not stored" is the holder's refusal;
+  the entry then ends failed, said with its reason.
+- **A-74** (§700; principle 1, no module names another) The indexer reads the router's `asks` through the seat
+  `operator-channel`: its manifest `uses` that seat, and the bucket is formed from the seat's holder on the seat list
+  and the contract's `StateAsks`, never a module's name in code; the teller's and the node-engine's `messenger_asks`
+  constant goes the same way in their own change.
+- **A-75** (§654, §610; principle 7, and who may do what is no question) mesh-issues shows the pipeline rows where it
+  already shows a delivery: its `DeliveryLine` gains `pipelines`, one row per module with its steps, `no run` where the
+  runner's list answers none. A runner verb's old callers list does not refuse a module: from G no verb names its
+  callers (§610), so the class's default holds.
+- **A-76** (§588, §568, A-73; principle 7) A reservation keeps the fingerprint of the catalog entry it was made from
+  (`versions.Source` gains it), so publish again reads that entry; the registry seat for an artifact is found from its
+  package ecosystem as the builder's seat hearing already maps it. A transport fault's class (`no responders`, `name
+  lookup`, `connection`, `deadline`) is the one the existing retake reads from the call's error (ADR 0664, ADR 0668).
+- **A-77** (§373; principles 1 and 7) A wait's bound is a bound key with its own time to live in the waiting part's own
+  state, as the condition keeper times its two hours (COND7): its expiry is heard as the bus's event and ends the wait
+  then, failing the step naming the member; no timer in the process and no looking only at the next event.
+- **A-78** (§374, §375, §377, §354; principles 1 and 7) For `outdated` and its inputs, the indexer keeps what it hears:
+  (a) `acted.<acting part>.<dependent>` in its own state, the newest `wait-ended` (ran or released) with the build it
+  acted for, compared with the dependent's current build (its newest entry's fingerprint); (b) what a delivered
+  version serves is read from that version's catalog entry (its manifest's `serves` and words); (c) a derived edge is
+  marked by a field `filled: true` the contract's `VersionEdge` gains, the machines that place a module come from the
+  assigner's `placement` (A-62), and each node's last `running` from the node-engine's stream read whole at start
+  (§556); (d) an `inputs` entry is also keyed by its run ask's id, so the build seat's `step-ended` of that ask finds
+  and deletes it.
+- **A-79** (§558, §614, §684, §196, §444; principle 7) As built in mesh-delivery 6d483af2: the gate's `source` is named
+  in the short `invokes` form (the manifest's `invokes` is a list of names); the catalog half's rows go into the part's
+  existing `grants_first_views`; while the catalog half is unread the part keeps what the bus loaded and only adds,
+  which is §684's way past the cycle, so no registered branch holds nothing. The part's remaining reads of the
+  indexer's `manifests`, `modules` and `verdicts` go too (§196): the catalog half answers them.
+- **A-80** (A-66, A-68, A-69, §375, §73; principles 7 and 8) What the indexer keeps as heard (`steps-since`, `toolchain`,
+  `delivered`, `pending`, `acted`) lives in one state of its own, `heard`, not in `own-build`, which keeps its one key;
+  every key part is escaped as a name (§73), so a dotted module name parses; a kind-3 edge compares its artifact's
+  language with `toolchain.<language>`.
+- **A-81** (§588, §369; principle 7) As built in mesh-delivery f12883b2: the publish-again queue key is
+  `<holder>.<module>.<version>`; the holders and their nodes are what the builder hears on `running` (read whole at its
+  start, §556, so a restart rebuilds them); `running` means not stopped, with a fingerprint; a not-stored artifact is
+  remembered on the reservation (`Unstored`); the tool's request rides a reasks mode `republish`; a message the state
+  cannot take is not acknowledged, as the other parts do.
+- **A-82** (§7, §428, §704's seed; principle 1, no module names another) The builder finds a build module the way the
+  indexer's seed does (mesh-delivery d73aeb02): the build seat whose acting rule `build` has an `on` matching the
+  artifact's language or `kind:image`, and that seat's holder on the seat list. `Task.Module` and every lane key are
+  that holder's name as the seat list gives it; a plan's artifact, the toolchain sources, `UnpublishedModules` and
+  `builder_stuck` all derive from it, and `builder_stuck` reads each build seat's steps through the seat (`<seat>.steps`)
+  rather than a named module's state. The floor's sources are the holders of the seats `git` (tags) and `mesh-catalog`
+  (requirements) on the seat list.
+- **A-83** (§374, A-78, A-80; principles 1 and 7) `BuildEdges.fp` is the fingerprint of the branch's catalog entry at
+  the revision `source` names, which the indexer holds itself; no field is added to `package-published`. For a build
+  of another watched branch, kind 1 compares with that branch's newest build, kept as heard in `heard` as
+  `branch-build.<module>.<branch>` (the digest `package-published` carries), not with a released digest.
+- **A-84** (§194 and its candidate's-view line, §348, §473; principle 1) The builder follows no candidate: only a run's
+  steps read a candidate's view, so the builder learns a candidate's build from the run's build step ask, which names
+  each entry by fingerprint; it reads each entry through `mesh-catalog.entry` (repository and commit are the member's
+  head) and needs no pull request number, a build being per fingerprint. Its read of the indexer's `candidates` view
+  goes.
+- **A-85** (§291, ADR 0666 §6, §9, §614, A-83; principle 7) The indexer keeps a catalog revision per watched branch, as
+  it keeps the trunk's: objects `branch.<branch>.<n>` (the branch escaped as a name) beside `trunk.<n>`, the trunk being
+  the first watched branch's; the branch follower's per-branch `revision` reads them, and `BuildEdges.fp` is the entry's
+  fingerprint in the revision whose `source` the build names.
+- **A-86** (§354, §375; principle 7) `KeepInput` is called by the indexer's own `input` verb, when a run on request's asker
+  hands an input; the indexer asks no `run` itself. A kind-3 edge's language is its catalog edge's target artifact's
+  language, else the one language the entry's artifacts share, as built in mesh-delivery 652285f0.
+- **A-87** (§568, §589, A-70, A-76; principle 7) As built in mesh-delivery bd228d51: a fault with no node says `no node`;
+  `FaultClass` maps `buildstep.PassingCause`'s words onto A-76's four classes. `builder_build`'s `newest: <branch>` is
+  read by the tools bundle following the catalog half itself, as A-70 has it for `reserved`.
+- **A-88** (§610, the main file's item 85; principle 7) mesh-networking's A-N1 (callers named in its seven seat
+  definitions) is not brought in: from G no verb names its callers (§610), which supersedes item 85's reading.
+- **A-89** (§37, §700, A-74; principle 7, one way for every asker) The runner reads its approval ask's warrant from the
+  router's record of its ask, through the seat `operator-channel` as A-74 has it, never from the decided event's body;
+  the decided event only wakes it.
+- **A-90** (§13, §14, §291, ADR 0666 §6, A-85; principle 7) A non-first branch's revision is made by the same take-in as
+  the trunk's, taken per watched branch: `sourceFollow` takes `source.<branch>` for every watched branch, and the
+  source path (`ApplySource`, the catch-up, the heads' take-in) runs with the branch as its argument, writing that
+  branch's revision (corrected by A-93).
+- **A-91** (§26, §37, §700, Q-RN8; principle 7) The router's record value carries its `warrant` as §700 says: the
+  operator-channel contract's `AsksByAskerIDValue` gains the field. A step the module's policy does not name is no step
+  of its pipeline, so `Status` has no open question for it. The runner places a pipeline's steps when it starts it and
+  asks each build seat for its step, as its asking half; that half is built in G.
+- **A-92** (§560, A-77, §627; principle 7, and who may do what is no question) The node-engine's bound keys live in a new
+  state `bounds` of the seat `node-engine`'s definition, declared in its old section as a foundation part's states are
+  (§627), key `<what>.<id>` with its own time to live; the node-engine's account holds it as it holds its other states.
+- **A-93** (§13, §14, §291, ADR 0666 §6, A-85, A-90; principle 7; corrects A-90's trunk) A non-first branch's take-in
+  is a pure computation from that branch's merged messages straight into its revision (`KeepBranchEntries`): each
+  module's fingerprint, inputs and graph node at the branch's heads, computed as the trunk's are, with no modules view
+  or bucket of its own; the trunk's `modules`, `manifests` and graph stay the trunk's alone. The trunk stays the
+  mesh-wide branch `main` (ADR 0666's default watched branch), named once in the indexer; a registration's own first
+  branch decides only which of its branches it delivers from.
+- **A-94** (§379, §525, §526; principle 1, a part asks for another's data or hears its events) The assigner hears the
+  builder's `build.ended` event (§379 names it) and reads no builder state such as `build-log`. A want for a trunk
+  revision's entry takes `version` and its parts' digests from the `version-released` whose `source` is that revision;
+  a build `build.ended` marks kept (its keeping node) is a kept build, its parts and `kept-on` from that event; a build
+  of another watched branch is the one whose `build.ended` names that branch, its parts from that event.
+- **A-95** (§421, §683, §698, A-47; principle 7) As built in the node-engine's commits 7703162c and 97d3df3e: the entry key is
+  `entry.<digits>` (a key takes no colon); `want.<module>` holds the want with its own `since`; an entry another node
+  runs is learned from `running`; the refusal "no entry of fingerprint" is `not-found`; `first-view-again` refuses in
+  words, the node-engine following no view. Still owed in G: a restart composes the bus module and the indexer from the
+  kept entries and wants while both are down, without waiting for every input (§683's purpose), and the
+  `entry-not-found` finding (§614).
+- **A-96** (§379, G-4's event table, §529, A-67; principles 1 and 7) The builder says `build.ended` itself, as a module
+  event on its own stream: a foundation part's old `streams` entry `mesh-delivery-builder-builds`, 7 days, kept last per
+  subject `build.ended.<module>.<fingerprint>` (each escaped), its body the build log entry's `module`, `fingerprint`,
+  `made` (artifact → digest), `kept-on` and `branch`; the assigner `consumes` `mesh-delivery-builder.build.ended`. A
+  want's source revision is the one its pass's kept assignment graph revision was computed from (A-67), matched to
+  `version-released.source`; `parts` stay keyed `<module>:<artifact>`, the contract's comment corrected to say so.
+- **A-97** (§230, §194, §473, A-84, A-91; principle 7) A candidate's build is asked by the runner as a pipeline step of
+  its own: the runner's asking half asks the seat `mesh-builds` a `build` step naming each entry by fingerprint, and the
+  builder takes that ask (its one entry point for a candidate) and answers the step's end; `StepRun`'s steps stay lint,
+  unit and integration on the build seats. With the candidate coming that way, the builder's watch of the gate's
+  `source` for candidate base merges goes. A kind-3 dependency's `part` is the entry's kind-3 edge, as built in
+  2dc51626.
+- **A-98** (§297; principles 3 and 7) The node agent gains one act, `Env.Stop`: it stops a module's units and containers
+  and removes nothing, so a revert's data survives; the revert stops the newer build with it, asks `restore-kept`, and
+  then `Apply` starts the reverted build. `Remove` keeps its meaning.
+- **A-99** (§230, A-91, A-97; principle 7) `build` is a step every pipeline has, placed first and required whatever its
+  policy names, so the runner's step enum gains `build`; each module's pipeline asks the build of its own module's
+  entry only, and a group's members are built by their own pipelines.
+- **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.