CB-REV-0001: the adversarial review, and it was not approvable

Thirteen challenges, five FATAL, all five conceded. Nothing had reached
ground-game, which is the only reason this is a correction and not a
retraction.

The worst: `Reactive` was not "greedy with one preference changed". It
differed in five, including SpendFreedom — ranked 95 unconditionally
against greedy's `95 if gated else 0` — so the seat burned its Freedom
token in round one of every game. A second change to the exact mechanism
under study, and every number in CB-EV-0031 was measuring it. The pass
claimed ADR-0018's one-varying-parameter discipline in its own workplan
while violating it. GreedyPolicy::rank is now public and the policy
delegates, overriding one match arm, so the control is structurally true.

Withdrawn entirely: "H1-B suppresses DARVO in the attacker". Disabling
H1-B under the corrected policy changes the arm count by exactly zero.
The pass hedged the wrong variable — it disclaimed "the number 2" and
defended "the direction", and the direction is what failed. The
supporting inference was invalid anyway: final Stress cannot show who
armed, because DarvoEnded resets the stage and REVERSE gives its owner -2.

Corrected: criterion 1 was failed on the greedy column while the pass's
own printed table showed 31-1000 arms in the other columns — the
selective-column move, in the file that names it. "Peak Stress was 1" was
a maximum over StressSet payloads, not held state (true: 2); the baseline
game count was 1,600 not 3,200; and "a reckless policy plays identically
to a careful one" is refuted by this repo's own rank-95 policy.

Inert controls replaced, each verified red against the reviewer's own
mutation: the baseline hash test compared two identically-constructed
states (serde(skip) on variant left 57/57 green); the `unchanged:` test
checked 3 of 7 entries and passed with SOLVE made illegal; H1-A's ordering
and H1-B's OU-cancel path had no test at all.

edition-check now covers catalog.yaml and rules_delta.yaml, whose digests
CB-WP-0038 claimed and never recorded — the review found it and reported
it unverified rather than absent, which was the right call.

Still open: H1-B on the DARVO extra-Attack path is untested, regulation.rs
still skips setup failures silently, and round-5 arms are counted though
they can never act.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

games/ground/examples/regulation.rs

@@ -40,31 +40,22 @@ impl Policy for Reactive {
             .players
             .get(&seat)
             .is_some_and(|p| p.stress >= 4 && !p.freedom_gate_lifted);
+        // ONE ARM OVERRIDDEN, THE REST DELEGATED.
+        //
+        // The first version re-typed greedy's ranking and changed one
+        // line of the copy. It differed in five places, and the review
+        // found it: `SpendFreedom` ranked 95 unconditionally instead of
+        // greedy's `95 if gated else 0`, so this seat spent its Freedom
+        // token in round one of every game — a second change to the very
+        // mechanism under study. Delegating makes "exactly one preference
+        // differs" structurally true instead of a claim in a comment.
         let rank = |c: &GroundCommand| -> i32 {
             match c {
                 GroundCommand::SelectAction {
-                    action, problem, ..
-                } => match action {
-                    // THE ONE LINE. Greedy has `Ground if gated => 100`.
-                    Action::Ground if gated => 5,
-                    Action::Solve
-                        if problem
-                            .and_then(|p| state.problems.get(&p))
-                            .is_some_and(|p| p.claimed_by.is_some()) =>
-                    {
-                        20
-                    }
-                    Action::Solve => 90,
-                    Action::Investigate => 80,
-                    Action::Support => 70,
-                    Action::Ground => 5,
-                    Action::Attack => 10,
-                },
-                GroundCommand::SpendFreedom => 95,
-                GroundCommand::ChooseGroundMode { .. } => 50,
-                GroundCommand::RespondToSupport { .. } => 90,
-                GroundCommand::ChooseDarvoTarget { .. } => 50,
-                GroundCommand::Reveal | GroundCommand::Resolve | GroundCommand::EndRound => -1,
+                    action: Action::Ground,
+                    ..
+                } if gated => 5,
+                other => GreedyPolicy::rank(state, seat, other),
             }
         };
         let mut best = 0;
@@ -77,6 +68,10 @@ impl Policy for Reactive {
     }
 }
 
+/// `Scenarios.csv`: "All players start at Stress 2." Named rather than
+/// inlined so the peak metric cannot silently disagree with setup.
+const START_STRESS: u8 = 2;
+
 struct Cell {
     games: u32,
     won: u32,
@@ -136,17 +131,28 @@ fn sweep(mode: ScoringMode, variant: Variant, players: u8, reactive: bool) -> Ce
                 c.atk += 1;
             }
         }
+        // Peak Stress **held**, not peak Stress *assigned*.
+        //
+        // The first version took a maximum over `StressSet` PAYLOADS.
+        // Starting Stress is 2 and is written by `setup`, never by an
+        // event, so a table that sat at 2 all game reported **1**, and a
+        // table with no `StressSet` at all would report 0. CB-EV-0031 §2
+        // built its headline claim on that number. Wrong subject: the
+        // metric answered "highest value ever assigned", the prose said
+        // "highest Stress reached".
+        let mut held: std::collections::BTreeMap<PlayerId, u8> =
+            g.state.players.keys().map(|s| (*s, START_STRESS)).collect();
+        c.peak_stress = c.peak_stress.max(START_STRESS);
         for e in &g.events {
             if matches!(e, games_ground::GroundEvent::DarvoTriggered { .. }) {
                 c.darvo += 1;
             }
-            // How close does Stress actually get to the arm at 5? That is
-            // the number H1's whole mechanism turns on, and CB-EV-0030
-            // had to infer it from a single game.
-            if let games_ground::GroundEvent::StressSet { stress, .. } = e {
+            if let games_ground::GroundEvent::StressSet { player, stress } = e {
+                held.insert(*player, *stress);
                 c.peak_stress = c.peak_stress.max(*stress);
             }
         }
+        let _ = held;
     }
     c
 }