Novox Playbooks

Step 0 · what the lead writes before any agent starts

• newThe milestone part of the design is the only input: the prepare maps each design line onto code (a build map per repository, each row citing its line) and lists every design question, what the design does not answer. It writes no findings or rulings of its own.
• newDesign complete: the operator answers each question, or the design writer one of internal form only (no change to what the operator sees, no permission, no data kept or removed), read by the reviewers by architectural domain; the answer is written into the milestone part, and only then does develop start. Nobody else answers one.
• newWhat exists today, read from the code and the live mesh, never from memory: every effect of a part removed or moved (bus writes, files, credentials, plans, processes, calls answered), every reader relying on each, what happens to each after the change and its test. It opens each build map; no code before it is complete, and the review refuses work without it.
• newSubtasks ordered so a user starts from the commit that adds its contract; one writer per file; one placement of the siblings for every agent.
• Into each issue: every file and test it touches (file:line), how it is checked and delivered, a group's merge order.
• newEvery other reader and writer of each value the change touches, each with a criterion.
• Acceptance criteria: given / when / then, each naming its test level and the design line it comes from.
• Every part the change reaches is an issue of the milestone; their order is the assigner's rules', never a cut.
• Fixtures copied from what the other side really writes, never from memory.
• An issue sized over an hour is split before work starts.

Step 1 · the fixing agent's brief

• newBuild each design line as written and nothing it does not say; every commit names its lines (Builds: design NN M §n).
• newA question the design does not answer stops that subtask and goes to the lead for the operator; never guessed or built around.
• One commit per subtask, naming its issue; tests cite their criterion (// 1217/AC3).
• newA test fails first on what the code does. A compile error is no failure: take out the change's effect and see an assertion fail.
• The whole unit suite before every commit; each test well under a second.
• newIntegration tests compiled whole; once per head reported, those of the touched packages and their importers run against an embedded bus (by name where the importers are many); never a whole module's run.
• Never push, open or merge; never move an issue; never ssh.
• Code that differs from the build map: stop that subtask and report, file:line.
• newStart a subtask only with room to finish it; stop between subtasks, never inside one.

What a round may ask

Only what makes the change wrong against its issues, their acceptance criteria and its decisions. Anything more (hardening, a further case, a nicer form) becomes a new issue, and the round does not wait for it.

What every round reads

• Every criterion against its test: a test at its level that would fail without the change.
• Every new integration test traced through the code by reading it: a local run of the touched packages shows only that it passed.
• That each integration test enters by the path the live trigger takes.
• Where each piece of state lives and how each seam travels: anything but bus state, a stream or a seat's verb is a finding, even if a record put it there.
• That no repository holds this mesh's setup (node names, placement, settings): repositories are mesh-agnostic.