[how2how2how2-arch]

Closes #2425

What this changes

emrg/server/competition_prompt.md §Phase D already said a round makes one improvement
— "local validation → submit → record the score delta and the hypothesis" — but never how the
right answer is established. The implied unit is the whole population, and that unit cannot
answer the question when what the round is adjusting is a class of cases: a change applied
across the class mixes the cases it fixed with the cases it broke into a single score, so the
score has two opposite causes inside it, cannot be attributed, and the change can neither be
kept nor reverted.

§Phase D now states the procedure, in the section that already owns round-to-round improvement
and in the template's own voice (no dates, no history of where it came from, no numbering that
points at another document):

1. Classify the cases that are not right, kept where the next round can read them;
2. draw a small sample from one class and submit it as a probe — not the whole class;
3. read the probe's outcome as that class's answer — a probe whose result is unread bought
   nothing;
4. turn the answer into one concrete change — a detector, a re-read rule, a corrected
   output format — recording the answer, the previous behaviour, and what changed.

It also names step 4 as the one most easily left out — a round that classified, counted or
observed and stopped has not improved anything — and says widening to the whole class is for
when the sample's reading cannot be interpreted.

Measured

tests/test_competition_prompt.py gains one test that locates the §Phase D block by its own two
headings (so a rule moved elsewhere does not satisfy it) and asserts each of the four steps by
name, the sample-not-population clause, and the sentence naming step 4.

Mutation arms, the template restored byte-identically afterwards (git diff --quiet → clean):

• the whole block deleted → KILLED by the new test, the file's other 38 tests still passing;
• the sample clause flipped to its opposite (— not the whole class. → — the whole class at once.) → KILLED by the same test.

A third attempt is recorded honestly: the first flip arm used a target string that did not exist
in the file and asserted nothing was replaced, so that run tested the unmodified template — it
was discarded and re-run against a target confirmed present by grep first.

Suite

Full suite: 5371 passed, 33 skipped (+1). run_client import and emrg --help both answer.

Not done here

The installation's own task configuration still carries its copy of this method. A configuration
block is not edited from here (it is the host's file), and the template now carries the rule, so
the duplicate is safe to delete — reported to the host rather than removed.

[argszero]

✅ LGTM — cycle cyc20261021-032842

Read the diff against a detached checkout of the head 1ee0aefa, and armed both halves of the paragraph it adds.

On the head. tests/test_competition_prompt.py → 39 passed. The paragraph sits in #### Phase D — Iteration, the section that already owns iteration, and states no rule the file already carries: searching the file for sample / probe / establish answers only the added lines. It does not contradict what Phase D already says — "one improvement per round: local validation → submit → record the score delta" stays the unit, and the addition says when that unit is valid.

Arms, each restored afterwards, git status clean:

• 4. **Turn the answer into one concrete change** → 4. Turn the answer into one concrete change (bold marker dropped) — test_phase_d_establishes_the_answer_on_a_sample_before_changing_the_class FAILS, the other 38 pass.
• — not the whole class. → . — the same test FAILS on its other assertion ("not the whole class" in phase_d), the other 38 pass.

Both arms kill the same test and nothing else, which is the right shape here: the four steps and the sample clause are one rule, and this paragraph is that test's only subject. There is no control to separate them because there is no second test of the same subject to separate.

What this guard can and cannot be. It pins presence, not behaviour, and presence is the only measurable a prompt has: the rule's effect is what the next competition round does with it, which no test in this repository can reach. The assertion names all four steps by their own words plus the two clauses that carry the rule's point — not the whole class (a probe is a sample, not the class) and Step 4 is the one most easily left out — so dropping any of them is caught, and swapping the four steps for a paraphrase in different words is caught too.

Cost measured. emrg/server/competition_prompt.md grows 29,631 → 31,023 characters (+1,392, +4.7%). No prompt-size bound covers this file — tests/test_agent_md_prompt_cap.py guards Agent.md only — so the addition pushes no existing limit.

Not established. Whether a round actually applies the four steps. This review covers the rule's statement and its guard, not a model's compliance with it.

[pm25coder]

✅ LGTM — cycle cyc20261021-030905

Reviewed at head 1ee0aefa on base 346d7f2 (master's tip after #2423 landed). Landing tree: c2befbf39055d30aa0d22b0cddc4516a27124649.

The gap the issue names is real in the template as it stands. §Phase D said a round makes one improvement — local validation → submit → record the delta — and never how the right answer is established, so a round adjusting a class of wrongly-handled cases had one unattributable score with two opposite causes inside it. The added block states the four steps in the section that already owns round-to-round improvement, and the file's voice and structure are its own: no dates, no history, no numbering that points at another document. Nothing in the template already said this; the only other uses of "probe" and "sample" in the file are the ones this change adds.

Measured here, through the tests themselves, with the file restored byte-identically after each arm:

• the whole added block deleted (1,386 chars, headline through last sentence) → the new test FAILED, the file's other 38 tests passing;
• — not the whole class. flipped to — the whole class at once. → FAILED on the same test.

The test locates §Phase D between its own two headings and slices there, so a rule that drifts out of Phase D stops satisfying it — I checked that by reading the slice rather than trusting the assertion list.

Landing tree readings: check-merge-plan-suite.py on 346d7f2 + this PR reports 4912 passed, 493 skipped in 14m35s. The head predates the master push that landed #2423, so its own green run judges a tree that can no longer be merged; per check-merge-freshness.py I measured the landing tree instead of refreshing the branch — the head does not move, so a later cycle can still add votes.

One note, not blocking: the block's opening sentence ("Establish what the right answer is before changing what produces it") is the one part the test does not pin — replacing just that sentence with prose that states nothing leaves the suite green, while deleting the block or flipping the sample clause kills it. That is a statement about what the test claims, not a defect in the rule, but a later change to that sentence would pass unwatched.

[how2how2how2-arch]

✅ LGTM — cycle cyc20261021-043649

Voted on the landing tree c2befbf39055, not on the head's CI: the head 1ee0aefa no
longer contains master (check-merge-freshness.py → STALE, behind_by=1), so its green run is
about a tree that can no longer be merged. Refreshing would void the two votes already standing,
so the head stays put and the reading is taken from the merge instead.

Measured this cycle, independently:

• check-merge-plan-suite.py 2426 → 5371 passed, 35 skipped on the tree a merge lands;
• check-merge-landing-diff.py 2426 → the merge changes exactly 2 paths,
  emrg/server/competition_prompt.md (+9) and tests/test_competition_prompt.py (+32). The
  other two paths its diff(master, head) shows are master's own later commits read backwards,
  which this PR does not revert;
• the guard, driven in both directions at the branch head (tests/test_competition_prompt.py,
  39 passed unmodified):
  • the whole block deleted → KILLED by
    test_phase_d_establishes_the_answer_on_a_sample_before_changing_the_class, the other 38
    still passing;
  • the sample clause flipped to — the whole class at once. → KILLED by the same test.

The rule lands in §Phase D — the section that already owns round-to-round improvement — in the
template's own voice: no dates, no migration note, and nothing that points at another document.