Compare commits

...
6 changed files with 158 additions and 31 deletions
+22 -3
View File
@@ -1,6 +1,6 @@
---
name: mesh-code-reviewer
description: Reviews one change of the Novox mesh before it is pushed (hq playbook 07, the review; at most three rounds): each commit against the design lines it cites, code no design line asks for, the build maps' What exists today, and whether its tests prove it. Read-only; reports findings, never fixes, and never re-judges the design.
description: Reviews one change of the Novox mesh before it is pushed (hq playbook 07, the review; at most three rounds): each commit against the design lines it cites, code no design line asks for, the build maps' What exists today, whether its tests prove it without standing in for another part of the mesh, and each changed module against the live mesh with the order of delivery it needs. Read-only; reports findings, never fixes, and never re-judges the design.
tools: Read, Grep, Glob, Bash, mcp__mesh__mesh_call, mcp__mesh__mesh_describe, mcp__mesh__mesh_search
model: opus
---
@@ -34,6 +34,14 @@ questions are.
searches again on the reviewed tree), or one the search finds and the answer omits;
- a test that does not fail without its change (check it by taking the change out in a copy), an acceptance
criterion with no test, a new test function where the repository is over budget, real sleeping;
- **a test that stands in for another part of the mesh, by rule** (playbook 07 step 2, item 11): one that creates a
stream, a consumer or a process taking a work queue's asks where the bus module, the grants part or the
node-engine should, or fakes a seat's holder in a whole test. The fix is composing what it needs with the parts' own
composers from the module's bus-shape sheet (step 0, item 11); a composer it cannot import is a gap of the build and
delivery system, named for the lead. List every new or changed test that creates bus state or fakes a seat's
holder, each with the composer that should make it;
- a changed module whose bus shape differs from its bus-shape sheet (its manifest sections, accounts, streams and
subjects, work queues and who takes their asks, who creates each);
- vet or tests that fail: run `go vet ./...`, `go vet -tags integration ./...` and `go test ./...` in every
touched module, with the siblings placed as the build map's one placement says;
- a change to any `module.json` reported without the manifest validator's verdicts (every manifest whose verdict
@@ -44,6 +52,16 @@ questions are.
principle you know of, name the line and why in a note; the lead brings it to the operator. The code follows the
line until the design changes.
**Read each changed module against the live mesh, and name the order of delivery** (playbook 07 step 2, item 12;
the operator, 2026-11-22). Through the mesh MCP server's tools, read what runs on the nodes now: each node's haves of
every module the change touches or relies on, and which parts still carry the form the change replaces (the tool
runner, the build modules, the node-engine, the indexer and its manifest validator, the grants part). For each, ask
whether its running version can take in, judge, build, compose or page the new form. Write a section `Live mesh`:
each such part with the build read on each node and the time read, then the order of delivery the change needs (the
parts that judge, build, compose or page first, then the modules that use them), each step an ordering edge the
delivery plan derives, or a gap of the build and delivery system for the lead. A part on the old form that no step of
the order brings over is a finding.
**Prove it against the live mesh, never a re-creation.** When the change answers a fault seen on the machines,
check what it claims against the state the mesh itself uses, read through its tools (the manifest validator's own verdicts in the indexer,
the packages state, the store, a node's haves), never against a copy you rebuilt: a manifest validator run without the seat list,
@@ -53,5 +71,6 @@ such in the report.
Anything else (hardening, a further case, a nicer form) is a note, never a round. Read only: no edits, no git
write, no verb that writes, never ssh. Use a temporary directory under `/var/tmp`.
Answer playbook 07 step 2 item 10's two questions, one line each. Answer **APPROVED at** the full commit ids, or numbered findings each with file:line, the design line it concerns,
what is wrong, and the fix; design questions and notes apart. Under 25 lines, glossary words only.
Answer playbook 07 step 2 item 10's two questions, one line each; then the list of tests of item 11 and the section
`Live mesh` of item 12 (a report without them is not an approval). Answer **APPROVED at** the full commit ids, or numbered findings each with file:line, the design line it concerns,
what is wrong, and the fix; design questions and notes apart. Under 40 lines, glossary words only.
+5 -1
View File
@@ -35,7 +35,11 @@ A fact the build map got wrong (a file moved, a function renamed) you say to the
**How you work.** Worktrees from `origin/main` on the branch the handover names, subtasks in the build map's order:
one that uses a contract, type, verb or package another subtask adds starts from that subtask's commit. Commit per
subtask, its label in the subject and a line `Builds: design NN M §n, …` in the body, locally only: never push, never open a pull request, never call a verb that writes on the mesh (reads are fine). Never
ssh, never a shell helper for the mesh. Tests: every change carries a test that fails without it (check it);
ssh, never a shell helper for the mesh. Tests: every change carries a test that fails without it (check it), and no test stands in for another part of the
mesh (playbook 07 step 2, item 11): none creates a stream, a consumer or a process taking a work queue's asks that the
bus module, the grants part or the node-engine should, and none fakes a seat's holder in a whole test; compose what a
test needs with the parts' own composers from the module's bus-shape sheet, and a composer you cannot import is a
question for the lead;
rows or subtests in existing tests where the repository is over the test budget the instructions set; no real
sleeping. Run `go vet ./...`, `go vet -tags integration ./...` and `go test ./...` in every touched module as
the running checker places siblings (playbook 07). Once per head you report, not per commit, also run the integration tests of
+17 -4
View File
@@ -1,13 +1,14 @@
---
name: mesh-preparer
description: Prepares one milestone or small fix of the Novox mesh before any code is written (hq playbook 07, the prepare step; playbook 08), from the milestone's part of its design and the design's main file, read whole, then the code each design line lands in - one build map per repository (where each design line lands in code, what exists there today and what relies on it, the subtasks and their order), the list of design questions the design does not answer, and the list of places where a design line and the code disagree. Decides nothing; writes only its build maps and the milestone file's two lists.
description: Prepares one milestone or small fix of the Novox mesh before any code is written (hq playbook 07, the prepare step; playbook 08), from the milestone's part of its design and the design's main file, read whole, then the code each design line lands in - one build map per repository (where each design line lands in code, what exists there today and what relies on it, the subtasks and their order), the list of design questions the design does not answer, and the list of places where a design line and the code disagree. Decides nothing; writes only its build maps, the milestone file's two lists and a bus-shape sheet per module.
tools: Read, Grep, Glob, Bash, Write, mcp__mesh__mesh_call, mcp__mesh__mesh_describe, mcp__mesh__mesh_search, SendMessage
model: opus
---
You prepare one change of the Novox mesh for the lead who started you. The caller's handover names the issue, the
design and its milestone part at an hq commit, and where your files go (playbook 07, step 0). You write the build
maps and the milestone file's sections `Design questions` and `Design meets code`, nothing else; you call no verb that writes and make no git
maps, the milestone file's sections `Design questions` and `Design meets code`, and a bus-shape sheet per module with
the test that composes it, in your own worktree, nothing else; you call no verb that writes and make no git
write.
**The design is your only input for what is built.** Read the milestone part and the design's main file whole, at the commit the
@@ -38,6 +39,17 @@ code`: the design line, the code (file:line at the commit read, each repository'
which of the three it is, and your recommendation, said as one. The lead answers these against the principles before
develop starts, as it does the design questions; you answer none.
**End with a bus-shape sheet per module, composed in a test** (playbook 07 step 0, item 11; the operator,
2026-11-22). For each module the milestone adds or changes, write `.work/<slug>/<module>.bus.md`: its manifest
sections (each process, its `bus`, `serves` and `requires`), its bus accounts, its streams and their subjects, its
work queues and the process that takes each queue's asks, its durable consumers, and who creates each (the bus module
from `requires`, the grants part, the module's own process), every row citing its design line. Then judge it in a
test in a worktree of your own under `/var/tmp`: the manifest validator with the live seat list, and the grants part's
composer and the node-engine's composer (the composition of `mesh-delivery-sdk`) composing the manifests the sheet
describes. A refusal is an entry under `Design meets code`; a row no design line gives is a design question; a composer
the test cannot import you report to the lead as a gap of the build and delivery system. Name the test and its result
at the top of the sheet.
**Everything the design does not say is a design question, never your answer.** A reader or an effect with no fate,
a field's form, a key and who deletes it, a bound, a caller, an owner, a tool for a new state, an interaction whose
seat, verb, event or provision the design does not name, a live state that contradicts a design line: list
@@ -47,6 +59,7 @@ anything should be, no finding of your own and no ruling; where you think a desi
principles, it is a design question too, and you map the line as written.
Report to the caller in under 30 lines: the build maps' paths, the count of design lines mapped per repository and
any line not mapped, the subtasks' order, the design questions and the entries of `Design meets code`, one line each with your
recommendation. Glossary
any line not mapped, the subtasks' order, the bus-shape sheets' paths and their tests' results, the design questions and the entries of
`Design meets code`, one line each with your recommendation, and their count: more than ten together send the
milestone back to its design (step 0b, item 5). Glossary
words only; a guess is said as one.
+9 -3
View File
@@ -746,10 +746,16 @@ controller (the planner, the rollout) until release 6 of ADR 0429; from each rel
word goes to that entry's *Not:* line with the as-is update after that delivery.
- **dry run** — a session's run, before a release is pushed, of the parts that will take it in, build it and merge it,
as they run live, on the revision as the merge will make it: in process on the session's machine, reading the mesh
and writing nothing there. It holds four items: the live take-in run whole with the seat list it will read, every
build against the packages as published, the gate's merge path read for the group, and no item left open (hq
playbook 07, step 2b). Not a **try** nor a **run on request**, which the mesh runs and which deliver a verdict; a dry
and writing nothing there. It holds five items: the live take-in run whole with the seat list it will read, every
build against the packages as published, the gate's merge path read for the group, the reviewed heads delivered once
in the lab of one machine from take-in to `delivered`, and no item left open (hq playbook 07, step 2b). A change
of a delivery module, the node-engine, the tool runner, the bus module or the SDK's bus packages never skips it. Not a **try** nor a **run on request**, which the mesh runs and which deliver a verdict; a dry
run owes the forge nothing and is not a check.
- **bus-shape sheet** — the prepare's list, per module a milestone adds or changes, of what the module will be on the
bus: its manifest sections, bus accounts, streams and their subjects, work queues and the process that takes each
queue's asks, durable consumers, and which part creates each; judged by the manifest validator and composed by the
grants part's composer and the node-engine's composer in a test before any code (hq playbook 07, step 0, item 11).
Not a **build map**, which says where each design line lands in code.
- **trunk commit** — the commit of the trunk a merge check's verdict was judged against: the trunk's head when
the build module cloned it. The verdict holds for that commit only, goes out of date when the trunk moves, and
is then carried to the new commit (ADR 0323, ADR 0548). Goes at milestone G's delivery with the merge check: a pipeline
+101 -16
View File
@@ -67,22 +67,34 @@ A small fix (one repository, one issue, about an hour of work) follows
own indexer and five more modules with the live seat list, and its trunk builds waited on renamed packages only the
take-in would publish. The dry run (step 2b) now runs the live take-in, the builds against what is published and the
gate's merge path, and holds the push while any item is open.
- **A change of the delivery system proven only on the live mesh.** On 2026-11-21 and 2026-11-22 milestone H2 of
design 47 was delivered after a review that approved it, and about 25 faults showed only on the machines: the
node-engine's composer stripped one manifest section of a process and kept another, so the declaration read refused
the milestone's own manifests; a stream's subject was not widened, so an approved registration was never written; a
work queue had no process taking its asks; and a durable consumer left behind for each old form set off the grants
part's alarm. The tests had passed because they created the streams, consumers and takers of asks the broker should
have, or a stand-in for a seat's holder, and the review read the code against the design, not against what the nodes
ran: the tool runner, the build modules and the node-engine still carried the old form, and the parts that judge,
build and compose had to reach the machines first. The prepare now ends with a bus-shape sheet composed in a test
(step 0, item 11), a test that stands in for a part of the mesh is a finding (step 2, item 11), the review reads the
live mesh and names the order of delivery (step 2, item 12), and the dry run delivers the reviewed heads once in the
lab before any pull request opens (step 2b, item 4; the operator, 2026-11-22).
- **A module proven only after it reached the machines.** The mail modules were delivered with unit tests
only, then failed live three times (issues 859, 865, 868) and took five more hours of fixes.
## The shape
One feature is **one branch name**, **one worktree per repository**, **one pull request per repository**,
opened **once**, after the review, and **one check** (ADR 0548). It runs in five steps, with the design completed between the first two (step 0b) and, for a change of what judges, builds or merges it, a dry run between the review and the check (step 2b), and its time is bounded. A milestone has no phases
opened **once**, after the review, and **one check** (ADR 0548). It runs in five steps, with the design completed between the first two (step 0b) and, for a change of what judges, builds, composes or delivers it, a dry run between the review and the check (step 2b), and its time is bounded. A milestone has no phases
(the operator, 2026-10-17): these are its steps, and a report names the step it is in:
| Step | What happens | Bound |
|---|---|---|
| 0. Prepare | from the milestone part and the design's main file, read whole, then the code each design line lands in: where each line lands, what exists there today and what relies on it, as one build map per repository; every design question, the design's silences, listed; and every place where a design line and the code disagree, listed | 15 minutes, longer when what exists is large: code never starts on an incomplete answer |
| 0b. Design complete | every design question and every place where design and code disagree is answered: by the lead in one line against the principles, or, where no principle settles it, by the operator or `hq-design-writer` (step 0); each answer is written down (the lead's in the milestone's lead-answers file, the others into the milestone part, playbook 02) and its build map rows added | until the list is empty: develop never starts before |
| 0. Prepare | from the milestone part and the design's main file, read whole, then the code each design line lands in: where each line lands, what exists there today and what relies on it, as one build map per repository; every design question, the design's silences, listed; every place where a design line and the code disagree, listed; and a bus-shape sheet per module, composed in a test | 15 minutes, longer when what exists is large: code never starts on an incomplete answer |
| 0b. Design complete | every design question and every place where design and code disagree is answered: by the lead in one line against the principles, or, where no principle settles it, by the operator or `hq-design-writer` (step 0); each answer is written down (the lead's in the milestone's lead-answers file, the others into the milestone part, playbook 02) and its build map rows added; more than ten questions send the milestone back to its design | until the list is empty: develop never starts before |
| 1. Develop | one fixing agent per repository builds every design line of its build map locally, each commit citing the lines it builds, the whole unit suite before every commit, the integration tests compiled, and once per head it reports those of the packages it touched and their importers run against an embedded bus (below); nothing is pushed | the milestone's issues, 30 minutes each |
| 2. Review | one reviewer reads all of it, the local commits, judging the integration tests by reading them against the code; reports go both ways; at most 3 rounds | 15 minutes |
| 2b. Dry run | for a release that changes a part judging a change, or a module path, a package or a manifest form the take-in reads: the live take-in run whole with the seat list it will read, every build against the packages as published, the gate's merge path read for the group, and no item left open | until no item is open: nothing is pushed before |
| 2. Review | one reviewer reads all of it, the local commits, judging the integration tests by reading them against the code, a test that stands in for a part of the mesh a finding, each changed module read against the live mesh and the order of delivery named; reports go both ways; at most 3 rounds | 15 minutes |
| 2b. Dry run | for a release that changes a part judging a change, or a module path, a package or a manifest form the take-in reads, and always for one that changes a delivery module, the node-engine, the tool runner, the bus module or the SDK's bus packages: the live take-in run whole with the seat list it will read, every build against the packages as published, the gate's merge path read for the group, the reviewed heads delivered once in the lab from take-in to `delivered`, and no item left open | until no item is open: nothing is pushed before |
| 3. Check | push the reviewed heads once and open the pull requests together; the checker's one check runs the integration tests; no further review unless the check fails | one check run |
| 4. Deliver | merge; the source revision moves, each module is built once and wanted on its nodes, its canary first | until the view says the source revision `delivered` |
@@ -314,7 +326,24 @@ of the prepare the lead names at the next report.
Then, under `Design meets code`, every place item 3 found where a design line and the code disagree, each with
the design line, the code (file:line at the `origin/main` commit read), which of the three it is (a form the code
cannot take, a part the line assumes built that is not, a rule in code the line would break), and the preparer's
recommendation, said as a recommendation. The two lists are the prepare's last output and step 0b's input.
recommendation, said as a recommendation. The two lists and the bus-shape sheets (item 11) are the prepare's last
output and step 0b's input.
11. **Write a bus-shape sheet per module, and compose it in a test, before any code** (the operator, 2026-11-22). For
each module the milestone adds or changes, `.work/<slug>/<module>.bus.md` lists what the module will be on the bus
once the change runs: its manifest sections (each process, its `bus`, `serves` and `requires`), its bus accounts,
its streams with their subjects, its work queues with the process that takes each queue's asks, its durable
consumers, and for each of these who creates it (the bus module from the module's `requires`, the grants part, the
module's own process at its start). Each row cites the design line that gives it; a row no design line gives is a
design question (item 10). The sheet is judged as the mesh will judge it, in a test in the preparer's worktree: the
manifest validator judges the manifests the sheet describes, with the live seat list, and the grants part's
composer and the node-engine's composer (the composition of `mesh-delivery-sdk`) compose them; each must take the
sheet as written. A refusal is an entry under `Design meets code`. A composer a test cannot import is a gap of the
build and delivery system, said to the lead and built there before develop (the grants part's composer belongs in
the SDK, beside the composition of `mesh-delivery-sdk`); never a sheet left unjudged. The sheet is what the
developers' tests and the reviewer's reading of the live mesh (step 2, items 11 and 12) hold the change to.
How it is checked: every module a build map changes has its sheet, with the test that composed it and its result
(`ls .work/<slug>/*.bus.md`); a fault of the bus's shape met after the push that the sheet omits is a miss of the
prepare, named at the next report.
## Step 0b — Design complete
@@ -339,6 +368,13 @@ answer is written down before the code; 2026-11-11: the lead answers it against
answers it.
4. **The design is complete** when every entry of both lists names its answering commit. Then step 1 starts, from the milestone
part at that commit.
5. **More than ten design questions send the milestone back to its design** (the operator, 2026-11-22). When the
prepare leaves more than ten entries in `Design questions` and `Design meets code` together, the milestone part is
not ready to be built: the lead answers none of them one by one, hands them all to `hq-design-writer` as one
amendment of the milestone part (playbook [02](02-graduation.md)), read by the four reviewers by architectural
domain, and the prepare runs again on the amended part. Develop starts only from a prepare that left ten or fewer.
How it is checked: the milestone file's two lists, counted at the prepare's end (`grep -c`), and the hq commit of
the amendment when they held more than ten.
**A question met later stops only its part.** A developer or the reviewer who meets a question the milestone part
does not answer stops the subtasks that need the answer, says the question to the lead with the design line and
@@ -371,7 +407,10 @@ an answer no hq commit holds, is a finding of the review (step 2, item 2a).
the test calls what the change adds, the agent takes out the change's effect (the line that does it, not the new
function), sees the test fail, and puts it back (2026-10-19: a check request's new field was proven by a test of
its helper alone, and dropping the field from the request passed every test); `gofmt`, `go vet` and the whole unit suite stay green. **The tests are written from the issue's
acceptance criteria**: one test or more per criterion at the level it names, each test's comment citing
acceptance criteria**, and **a test never stands in for another part of the mesh** (step 2, item 11): it creates no
stream, consumer or taker of a work queue's asks that the bus module or the grants part should create, and fakes no
seat's holder in a whole test; it composes what it needs with the parts' own composers, from the bus-shape sheet
(step 0, item 11). One test or more per criterion at the level it names, each test's comment citing
the criterion it proves by its label (`// 1118/AC2`), and no criterion left without its test; an integration criterion is a test
that compiles and is run by the pull request's one check. The integration tests (those that start a store, a bus
or a process) are compiled with `go vet -tags integration ./...` while developing and run by that check. **Once per head it
@@ -510,15 +549,41 @@ an answer no hq commit holds, is a finding of the review (step 2, item 2a).
the record behind it, the lead brings it to the operator as a design question, and the code waits for the answer
in the design. How it is checked: the review report has a line for each question with its answer, and the lead reads both before the
push; a report without them is not an approval.
11. **A test that stands in for another part of the mesh is a finding, by rule** (the operator, 2026-11-22). A test
that creates a stream, a consumer or a process taking a work queue's asks where the bus module, the grants part
or the node-engine should, or that fakes a seat's holder in a whole test, proves what the test made, not what the
mesh will make: on 2026-11-21 milestone H2's tests passed on streams and takers they created themselves, and the
live broker made neither. The fix is the test composing what it needs with the parts' own composers (the grants
part's and the composition of `mesh-delivery-sdk`), from the module's bus-shape sheet (step 0, item 11); a
composer it cannot import is a gap of the build and delivery system, built there in the milestone, never a stand-in
kept. A unit test's fake of a function's own collaborator is not this; a stand-in for a part another module
holds is. How it is checked: the review report lists every new or changed test that creates bus state or fakes a
seat's holder, each with the composer that should make it, and a report without that list is not an approval.
12. **Each changed module is read against the live mesh, not only the design** (the operator, 2026-11-22). The
reviewer reads, through the mesh MCP server's tools, what runs on the nodes today: each node's haves of every
module the change touches or relies on, and which parts still carry the form the change replaces (the tool runner,
the build modules, the node-engine, the indexer and its manifest validator, the grants part). For each, it asks
whether the running version can take in, judge, build, compose or page the change's new form. Then it names, in
its report, **the order of delivery the change needs**: the parts that judge, build, compose or page the new form
first, then the modules that use it, each step an ordering edge of the module graph the delivery plan derives
(instruction design-it-as-it-should-be), or, where no edge carries it, a gap of the build and delivery system for
the lead to bring to the operator. A part still on the old form that no step of the order brings over makes the
change wrong. How it is checked: the review report holds a section `Live mesh` naming each node's build read for
each such part, with its time, and the order of delivery; the lead copies the order into the milestone file and
the dry run (step 2b, item 4) delivers in it. A fault met after the merge from a part on the old form is named at
the next report.
## Step 2b — Dry run (a change of the delivery system, or of what the take-in reads)
**When it runs.** After the review approves the heads and before the push of step 3, for every release that changes a
part judging a change (step 3, item 3: the indexer and its manifest validator, the gate, the builder, a build module,
the checker or the pipeline runner, the node-engine, a seat definition), and for every release that adds or renames a
module path or a package other modules take, or changes the form of manifests the take-in reads. The prepare step's
milestone file says per release whether it runs and why (`Dry run: yes` or `no`, with the reason); the review refuses a
group that lists a judging part with no such line. The operator, 2026-11-13: "remember the mistake and make sure our
module path or a package other modules take, or changes the form of manifests the take-in reads. **A release that
changes a delivery module, the node-engine, the tool runner, the bus module or the SDK's bus packages never skips it**,
and no rule is weighed against that (the operator, 2026-11-22: milestone H2's faults would each have shown in one
delivery off the machines). The prepare step's milestone file says per release whether it runs and why (`Dry run: yes`
or `no`, with the reason); the review refuses a group that lists a judging part with no such line, and a `no` for a
release that changes one of the parts just named. The operator, 2026-11-13: "remember the mistake and make sure our
pipeline catches this".
**What it is.** A dry run runs the parts that will take the change in, build it and merge it, as they run live, on the
@@ -526,7 +591,7 @@ revision as the merge will make it: in process on the session's machine, reading
asking no try and no check. An agent of hq's definitions runs it, read-only on the mesh and on every working copy; the
lead writes only the handover. Everything live it uses (the builds the nodes run, the seat list, the published
versions, the trunks) is read in the same hour as the push, and read again, with the dry run run again, when a head,
a main or a live build moves before the push. Four items, each held before any push:
a main or a live build moves before the push. Five items, each held before any push:
1. **The live take-in, run whole.** The indexer that will take the revision in (the running one, read from the view's
reach of its module; for a revision that names another build of the indexer, the running one, which keeps it
@@ -554,7 +619,18 @@ a main or a live build moves before the push. Four items, each held before any p
another base is moved to the gate's branch or left out of the group, a group the gate holds closed is pushed under a
new branch name, and an Approve ask that names fewer members than the group is ended and said to the operator,
never answered.
4. **No item open.** The dry run's report says of each item what ran, at which heads and on which live builds, and its
4. **The reviewed heads delivered once in the lab, from take-in to delivery** (the operator, 2026-11-22). The lab of
one machine raises the mesh's four node roles on the session's machine (the control-node's parts, a build node's,
the bus module and a node-engine with its tool runner), with an embedded bus and store, from the builds the nodes
run now (item 1's reading). The reviewed heads are merged there and run the whole way once: the take-in, the
pipeline and its steps, the builds, the grants part's memberships, the compositions, the wants, the node-engine's
apply and the tool runner's start, in the order of delivery the review named (step 2, item 12), until the lab's
view says the source revision `delivered` and every changed module runs healthy and answers its tools. A step that
refuses, holds or stands still is a fault of the release, fixed and reviewed before the push. Where the lab cannot
yet raise a part (no bed for it), that is a gap of the build and delivery system, built in the lab in the same
milestone or before it and said to the operator; the item is never closed as "not run". The pull requests open
only after this item passed.
5. **No item open.** The dry run's report says of each item what ran, at which heads and on which live builds, and its
counts ("ran: 193 manifests, 0 refused, seat list read at 13:05"). An item said "not run", "not known" or "read, not
run" is closed, by running it or by showing why it does not apply, or the push is held: **a dry run with an open
item is not a pass**, and no rule is weighed against it. Before the push the lead says to the operator, in one line
@@ -568,7 +644,8 @@ take-in publishes; no dry run had built a trunk module against the published pac
merged a group one member at a time with no undo, stopped at a member whose base was not main, and asked an Approve
while a group was still forming and per member of a closed group.
**How it is checked.** The milestone file holds a section `Dry run` with each item's result, the reviewed heads it ran
**How it is checked.** The milestone file holds a section `Dry run` with each of the five items' result, the lab
run's source revision and its `delivered` time among them, the reviewed heads it ran
on and its time (`grep -n -A6 '^## Dry run' .work/<slug>/milestone.md`), older than the push (the forge branch's
first push of the heads) and with no item open; the pull requests' description names it in one line. A push of a
release whose milestone file lists a judging part with no such section, or with an item open, is this step skipped;
@@ -676,7 +753,8 @@ a fault met after the merge that an item would have shown is named at the next r
4. **The milestone's acceptance is proven by its check.** A milestone that adds or changes a module
carries an integration test that starts the module whole, its process against the real bus and store, and
shows the milestone's acceptance sentence; the forge's checks run it (ADR 0391 §1, §6). Unit tests alone are not
that proof; the mesh has no end-to-end tests yet, and the lab is not used (the operator, 2026-10-16).
that proof; the mesh has no end-to-end tests yet, and the lab is used only for the dry run's delivery (step 2b,
item 4; the operator, 2026-10-16 and 2026-11-22).
**A new manifest word's test goes through the first composition that meets it, not only the verb that fills it.**
On 2026-10-19 release 1 of feature mail-sender tested a process's own bus account through `module issue`
alone; the first push after mesh-mail declared the process composed a random 40-character stand-in for the
@@ -943,8 +1021,15 @@ issues in `fixing` that nobody works on reads to the operator as stuck work.
item 6b). A fixing agent started on a file without the section, or an effect of a removed or moved part met only
after the delivery, is the prepare step skipped, named in the next detailed report and written into the playbook's
lessons here.
- A release whose milestone file lists a part judging a change holds a `Dry run` section with all four items closed,
older than its push (step 2b); one pushed without it, or with an item open, is that step skipped.
- A release whose milestone file lists a part judging a change, or that changes a delivery module, the node-engine,
the tool runner, the bus module or the SDK's bus packages, holds a `Dry run` section with all five items closed, the
lab's delivery among them, older than its push (step 2b); one pushed without it, or with an item open, is that step
skipped.
- Every module a build map changes has its bus-shape sheet with the test that composed it (step 0, item 11); a
milestone developed from a prepare that left more than ten design questions, with no amendment of its part between,
is step 0b item 5 skipped.
- Every review report holds the list of tests that create bus state or fake a seat's holder (step 2, item 11) and the
section `Live mesh` with the order of delivery (step 2, item 12); a report without either is not an approval.
- No issue of a running milestone is sized over an hour in its prepare note; an issue whose fixing agent passes
twice its bound was not split.
- Every issue of a running milestone has a note from the prepare step naming its files and tests (file:line), how
+4 -4
View File
@@ -476,11 +476,11 @@ const P = [
{n:"07",name:"Features",kind:"build",c:"--build",
trig:"Work that changes code across issues or repositories, too large for a small fix.",
who:"A lead (larger model), one fixing agent per repository (smaller), one reviewer (larger).",
steps:["Prepare: name the branch, make the worktrees, read the milestone part and the design's main file whole, then the code each design line lands in. (new)","List every place where a design line and the code disagree, beside the design questions. (new)","Every agent is one of hq's definitions (mesh-preparer, mesh-developer, mesh-code-reviewer, mesh-watcher); the lead writes only the handover. (new)","The prepare's only output: a build map per repository, each row a design line and where it lands, and the design questions. No rulings. (new)","Design complete: the lead answers every question against the principles; one no principle settles goes to the operator or the design writer; then develop. (new)","Read what exists today from the code and the live mesh: every effect of what is removed or moved, every reader of each, what happens to each and its test. No code before it is complete; the review refuses work without it. (new)","The build map opens with what exists today; subtasks ordered contract first, one writer per file.","Write the findings and acceptance criteria into each issue.","Survey every other reader and writer of each changed value. (new)","Answer three questions in the milestone file: who deletes each new key and stream, how the switch-over is tried on one node first, what the one check does not cover. The review checks them. (new)","List every part the change reaches; copy fixtures from the real writer.","Develop: one agent per repository, one commit per subtask, each citing its design lines; a question stops only its subtask. (new)","A test fails first on behaviour, not on compiling. (new)","Bring each branch up to the trunk; nothing is pushed, no try runs. (new)","Review all of it against the design lines, code no line asks for a finding, reading the integration tests against the code; at most 3 rounds; the report answers the state-and-seams and mesh-agnostic questions. (new)","Dry run, for a change of what judges, builds or merges it: the live take-in run whole with the seat list it will read, every build against the packages as published, the gate's merge path read for the group; an item left open holds the push. (new)","A group pins the group's own mesh-sdk head in every member. (new)","Push the reviewed heads once and read each forge head against the reviewed commit; no draft pull request, no fix round on an open one. (new)","Open one pull request per repository, together, with Reviewed-by and Pushed-by; the one check runs. A failed check is read, fixed, reviewed, pushed once more. (new)","The operator's Approve on Telegram; the group merges in one pass.","Follow the delivery in the status view (moving, settled, stuck, delivered) to done; resolve the issues; clean up. (new)","When the builder cannot deliver its own fix: revert, a build by a session's call, a registration at the terminal, copies kept outside the store; a broken controller is put back by a want the operator writes, a hand build by mesh-hand-compose and a want. (new)"],
steps:["Prepare: name the branch, make the worktrees, read the milestone part and the design's main file whole, then the code each design line lands in. (new)","List every place where a design line and the code disagree, beside the design questions. (new)","Every agent is one of hq's definitions (mesh-preparer, mesh-developer, mesh-code-reviewer, mesh-watcher); the lead writes only the handover. (new)","The prepare's only output: a build map per repository, each row a design line and where it lands, and the design questions. No rulings. (new)","Design complete: the lead answers every question against the principles; one no principle settles goes to the operator or the design writer; then develop. (new)","Read what exists today from the code and the live mesh: every effect of what is removed or moved, every reader of each, what happens to each and its test. No code before it is complete; the review refuses work without it. (new)","The build map opens with what exists today; subtasks ordered contract first, one writer per file.","Write the findings and acceptance criteria into each issue.","Survey every other reader and writer of each changed value. (new)","Answer three questions in the milestone file: who deletes each new key and stream, how the switch-over is tried on one node first, what the one check does not cover. The review checks them. (new)","List every part the change reaches; copy fixtures from the real writer.","End the prepare with a bus-shape sheet per module (manifest sections, accounts, streams and subjects, work queues and who takes their asks, who creates each), judged by the manifest validator and composed by the grants part's and the node-engine's composers in a test; more than ten design questions send the milestone back to its design. (new)","Develop: one agent per repository, one commit per subtask, each citing its design lines; a question stops only its subtask. (new)","A test fails first on behaviour, not on compiling. (new)","Bring each branch up to the trunk; nothing is pushed, no try runs. (new)","Review all of it against the design lines, code no line asks for a finding, reading the integration tests against the code; at most 3 rounds; the report answers the state-and-seams and mesh-agnostic questions. (new)","A test that stands in for another part of the mesh (a stream, consumer or taker of asks it creates, a faked seat's holder) is a finding; the review reads each changed module against the live mesh and names the order of delivery: the parts that judge, build, compose or page first. (new)","Dry run, for a change of what judges, builds or merges it: the live take-in run whole with the seat list it will read, every build against the packages as published, the gate's merge path read for the group, the reviewed heads delivered once in the lab of one machine from take-in to delivered; an item left open holds the push, and a change of a delivery module, the node-engine, the tool runner, the bus module or the SDK's bus packages never skips it. (new)","A group pins the group's own mesh-sdk head in every member. (new)","Push the reviewed heads once and read each forge head against the reviewed commit; no draft pull request, no fix round on an open one. (new)","Open one pull request per repository, together, with Reviewed-by and Pushed-by; the one check runs. A failed check is read, fixed, reviewed, pushed once more. (new)","The operator's Approve on Telegram; the group merges in one pass.","Follow the delivery in the status view (moving, settled, stuck, delivered) to done; resolve the issues; clean up. (new)","When the builder cannot deliver its own fix: revert, a build by a session's call, a registration at the terminal, copies kept outside the store; a broken controller is put back by a want the operator writes, a hand build by mesh-hand-compose and a want. (new)"],
prod:"One pull request per repository, one source revision delivered, resolved issues, no branch or worktree left.",
next:"02 (when it ships)",bounds:"Prepare 15 min · 30 min per issue · review 15 min, ≤ 3 rounds · one check, pushed once",
prev:["Pull requests as scratchpads","Context bought again and again","A change built on what was remembered, not on what runs","Review rounds spent on what a run would show","A node agent's bus reads, proven only by review","A dry run with an open item, taken as a pass"],
check:"The checker's one status, mesh/check; the review record; the dry run's section in the milestone file; the tracker's move."},
next:"02 (when it ships)",bounds:"Prepare 15 min, at most ten design questions · 30 min per issue · review 15 min, ≤ 3 rounds · one check, pushed once",
prev:["Pull requests as scratchpads","Context bought again and again","A change built on what was remembered, not on what runs","Review rounds spent on what a run would show","A node agent's bus reads, proven only by review","A dry run with an open item, taken as a pass","A change of the delivery system proven only on the live mesh"],
check:"The checker's one status, mesh/check; the review record; the dry run's section in the milestone file, the lab's delivery among its items; the bus-shape sheets; the review's Live mesh section; the tracker's move."},
{n:"08",name:"Small fixes",kind:"build",c:"--build",
trig:"One issue in one repository, about an hour of work.",
who:"The session, with one reviewer on the larger model.",