CB-WP-0008-T02: cb-play — INTENT stage 0's CLI player

A human seat is a Policy like any bot, so the CLI adds no second driver:
HumanPolicy renders the projection, lists the legal commands and reads an
index or `pass`. `make play` runs it; `--all-bots` watches one.

K13's Project trait gains its first implementor after six passes with
none. Hidden: other seats' face-down selections until Reveal, hands and
deck (counts only), a face-down Problem's suit and value, and the seed —
not secret content, but a seat holding it can compute the deck.

A played session becomes an artifact: --record writes it as a scenario
the runner executes, --replay writes a .cbreplay bundle. record.rs is the
inverse of parse_command and its warrant is a round-trip test over every
command shape.

The acceptance test for the projection passed vacuously twice. First it
asserted the text contained "face-down", which every render does because
of Problems. Counted, it then reported zero inspected entries: seats are
asked in order, so a human at P1 is prompted before anyone has selected.
Seated at P3 it inspects ten entries and dies when the projection is
mutated to reveal everything. Counting what the harness examined caught
both, which is the second time that remedy has worked where a stronger
predicate would not have.

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

games/ground/src/record.rs

@@ -0,0 +1,364 @@
+//! Turn a played game back into a scenario (CB-WP-0008 T02).
+//!
+//! `ScenarioGame::parse_command` reads a `CommandStep` into a typed
+//! command. This is its inverse, so a game somebody played becomes a
+//! scenario the runner can re-execute and a `.cbreplay` bundle can carry.
+//!
+//! **The round trip is the test**, and it is the only reason this is
+//! trustworthy: `parse_command(to_step(actor, cmd)) == (actor, cmd)` for
+//! every command shape. An encoder checked only against hand-written
+//! expectations agrees with itself.
+
+use crate::{Action, GroundChoice, GroundCommand, GroundMode, SupportResponse};
+use cb_game_runtime::{CommandStep, Setup};
+use cb_kernel::{Actor, PlayerId};
+use std::collections::BTreeMap;
+
+fn seat(p: PlayerId) -> serde_yaml::Value {
+    serde_yaml::Value::String(format!("P{}", p.0 + 1))
+}
+
+fn num(n: u64) -> serde_yaml::Value {
+    serde_yaml::Value::Number(n.into())
+}
+
+fn text(s: &str) -> serde_yaml::Value {
+    serde_yaml::Value::String(s.to_string())
+}
+
+fn actor_name(actor: Actor) -> String {
+    match actor {
+        Actor::Player(p) => format!("P{}", p.0 + 1),
+        Actor::System => "SYSTEM".into(),
+    }
+}
+
+fn action_name(action: Action) -> &'static str {
+    match action {
+        Action::Investigate => "INVESTIGATE",
+        Action::Solve => "SOLVE",
+        Action::Support => "SUPPORT",
+        Action::Attack => "ATTACK",
+        Action::Ground => "GROUND",
+    }
+}
+
+fn mode_name(mode: GroundMode) -> &'static str {
+    match mode {
+        GroundMode::Gr => "GR",
+        GroundMode::Ou => "OU",
+        GroundMode::Nd => "ND",
+    }
+}
+
+fn response_name(r: SupportResponse) -> &'static str {
+    match r {
+        SupportResponse::AcceptBond => "accept_bond",
+        SupportResponse::DeclineBond => "decline_bond",
+        SupportResponse::FlipToBond => "flip_to_bond",
+        SupportResponse::BreakRivalry => "break_rivalry",
+    }
+}
+
+/// One issued command as a scenario step.
+pub fn to_step(actor: Actor, command: &GroundCommand) -> CommandStep {
+    let mut args: BTreeMap<String, serde_yaml::Value> = BTreeMap::new();
+    let cmd = match command {
+        GroundCommand::SelectAction {
+            action,
+            target,
+            problem,
+        } => {
+            args.insert("action".into(), text(action_name(*action)));
+            if let Some(t) = target {
+                args.insert("target".into(), seat(*t));
+            }
+            if let Some(p) = problem {
+                args.insert("problem".into(), num(u64::from(*p)));
+            }
+            "select_action"
+        }
+        GroundCommand::SpendFreedom => "spend_freedom",
+        GroundCommand::ChooseGroundMode { mode, choice } => {
+            args.insert("mode".into(), text(mode_name(*mode)));
+            match choice {
+                None => {}
+                Some(GroundChoice::RestoreProblem { problem }) => {
+                    args.insert("choice".into(), text("restore_problem"));
+                    args.insert("problem".into(), num(u64::from(*problem)));
+                }
+                Some(GroundChoice::ProtectProblem { problem }) => {
+                    args.insert("choice".into(), text("protect_problem"));
+                    args.insert("problem".into(), num(u64::from(*problem)));
+                }
+                Some(GroundChoice::CancelAttack { attacker }) => {
+                    args.insert("choice".into(), text("cancel_attack"));
+                    args.insert("seat".into(), num(u64::from(attacker.0)));
+                }
+                Some(GroundChoice::RemoveBlame { owner }) => {
+                    args.insert("choice".into(), text("remove_blame"));
+                    args.insert("seat".into(), num(u64::from(owner.0)));
+                }
+                Some(GroundChoice::BreakRelation { with }) => {
+                    args.insert("choice".into(), text("break_relation"));
+                    args.insert("seat".into(), num(u64::from(with.0)));
+                }
+                Some(GroundChoice::RejectReverse) => {
+                    args.insert("choice".into(), text("reject_reverse"));
+                }
+            }
+            "choose_ground_mode"
+        }
+        GroundCommand::RespondToSupport { response } => {
+            args.insert("response".into(), text(response_name(*response)));
+            "respond_to_support"
+        }
+        GroundCommand::ChooseDarvoTarget { target } => {
+            if let Some(p) = target.problem {
+                args.insert("problem".into(), num(u64::from(p)));
+            }
+            if let Some(t) = target.player {
+                args.insert("target".into(), seat(t));
+            }
+            "choose_darvo_target"
+        }
+        GroundCommand::Reveal => "reveal",
+        GroundCommand::Resolve => "resolve",
+        GroundCommand::EndRound => "end_round",
+    };
+    CommandStep {
+        actor: actor_name(actor),
+        cmd: cmd.into(),
+        args,
+    }
+}
+
+/// A whole played game as a scenario file.
+///
+/// `covers` is deliberately **empty**: a recorded game exercises whatever
+/// it happened to exercise, and claiming rule coverage from it would
+/// inflate AM-1 with rules nobody asserted. `expect.state_hash` carries
+/// the end-state hash, which is the assertion that a replay must satisfy.
+pub fn to_scenario(
+    name: &str,
+    seed: u64,
+    players: u8,
+    steps: &[(Actor, GroundCommand)],
+    end_state_hash: Option<String>,
+) -> cb_game_runtime::ScenarioFile {
+    cb_game_runtime::ScenarioFile {
+        scenario: name.to_string(),
+        description: "recorded by cb-play (CB-WP-0008 T02)".into(),
+        covers: vec![],
+        provisional: false,
+        provisional_owner: String::new(),
+        provisional_raised: String::new(),
+        seed,
+        setup: Setup {
+            players,
+            preset: format!("standard-{players}p"),
+            patch: BTreeMap::new(),
+        },
+        commands: steps.iter().map(|(a, c)| to_step(*a, c)).collect(),
+        expect: cb_game_runtime::scenario::Expect {
+            state_hash: end_state_hash,
+            ..Default::default()
+        },
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::{DarvoTarget, GroundState};
+    use cb_game_runtime::ScenarioGame;
+
+    /// A game somebody played becomes a scenario the runner re-executes
+    /// to the same hash. This is the acceptance clause "the same
+    /// transcript replays identically", taken through the *scenario
+    /// runner* rather than through a second call to the same driver —
+    /// which would only prove the driver is deterministic.
+    #[test]
+    fn a_recorded_bot_game_replays_as_a_scenario() {
+        use crate::bot::{play, GreedyPolicy, Policy};
+        use cb_events::state_hash_hex;
+        use cb_game_runtime::{run, RunOutcome, Setup};
+
+        let setup = Setup {
+            players: 3,
+            preset: "standard-3p".into(),
+            patch: BTreeMap::new(),
+        };
+        let game = play(
+            GroundState::setup(&setup, 42).expect("preset"),
+            &mut (0..3)
+                .map(|_| Box::new(GreedyPolicy) as Box<dyn Policy>)
+                .collect::<Vec<_>>(),
+        )
+        .expect("bot game");
+        let hash = state_hash_hex(&game.state);
+
+        let scenario = to_scenario(
+            "ground/recorded-bot-game",
+            42,
+            3,
+            &game.steps,
+            Some(hash.clone()),
+        );
+        assert_eq!(scenario.commands.len(), game.steps.len());
+        match run::<GroundState>(&scenario) {
+            RunOutcome::Passed { .. } => {}
+            RunOutcome::Failed { reason, .. } => {
+                panic!("recorded game did not replay: {reason}")
+            }
+        }
+
+        // Control: the recorded hash is what the replay is checked
+        // against, so a wrong hash must fail. Without this the pass above
+        // is satisfied by a scenario that asserts nothing.
+        let tampered = to_scenario(
+            "ground/recorded-bot-game",
+            42,
+            3,
+            &game.steps,
+            Some("0".repeat(hash.len())),
+        );
+        assert!(
+            matches!(run::<GroundState>(&tampered), RunOutcome::Failed { .. }),
+            "a tampered end-state hash must fail the replay"
+        );
+    }
+
+    /// Every command shape must survive encode → parse unchanged. This is
+    /// the whole warrant for the encoder: nothing else compares it to the
+    /// reader it must agree with.
+    #[test]
+    fn every_command_shape_round_trips() {
+        let p2 = PlayerId(1);
+        let cases: Vec<(Actor, GroundCommand)> = vec![
+            (
+                Actor::Player(PlayerId(0)),
+                GroundCommand::SelectAction {
+                    action: Action::Investigate,
+                    target: None,
+                    problem: Some(3),
+                },
+            ),
+            (
+                Actor::Player(PlayerId(0)),
+                GroundCommand::SelectAction {
+                    action: Action::Attack,
+                    target: Some(p2),
+                    problem: None,
+                },
+            ),
+            (
+                Actor::Player(PlayerId(2)),
+                GroundCommand::SelectAction {
+                    action: Action::Ground,
+                    target: None,
+                    problem: None,
+                },
+            ),
+            (Actor::Player(PlayerId(0)), GroundCommand::SpendFreedom),
+            (
+                Actor::Player(PlayerId(0)),
+                GroundCommand::ChooseGroundMode {
+                    mode: GroundMode::Gr,
+                    choice: None,
+                },
+            ),
+            (
+                Actor::Player(PlayerId(0)),
+                GroundCommand::ChooseGroundMode {
+                    mode: GroundMode::Ou,
+                    choice: Some(GroundChoice::RestoreProblem { problem: 2 }),
+                },
+            ),
+            (
+                Actor::Player(PlayerId(0)),
+                GroundCommand::ChooseGroundMode {
+                    mode: GroundMode::Ou,
+                    choice: Some(GroundChoice::ProtectProblem { problem: 1 }),
+                },
+            ),
+            (
+                Actor::Player(PlayerId(0)),
+                GroundCommand::ChooseGroundMode {
+                    mode: GroundMode::Ou,
+                    choice: Some(GroundChoice::CancelAttack { attacker: p2 }),
+                },
+            ),
+            (
+                Actor::Player(PlayerId(0)),
+                GroundCommand::ChooseGroundMode {
+                    mode: GroundMode::Nd,
+                    choice: Some(GroundChoice::RemoveBlame { owner: p2 }),
+                },
+            ),
+            (
+                Actor::Player(PlayerId(0)),
+                GroundCommand::ChooseGroundMode {
+                    mode: GroundMode::Nd,
+                    choice: Some(GroundChoice::BreakRelation { with: p2 }),
+                },
+            ),
+            (
+                Actor::Player(PlayerId(0)),
+                GroundCommand::ChooseGroundMode {
+                    mode: GroundMode::Nd,
+                    choice: Some(GroundChoice::RejectReverse),
+                },
+            ),
+            (
+                Actor::Player(PlayerId(1)),
+                GroundCommand::RespondToSupport {
+                    response: SupportResponse::AcceptBond,
+                },
+            ),
+            (
+                Actor::Player(PlayerId(1)),
+                GroundCommand::RespondToSupport {
+                    response: SupportResponse::BreakRivalry,
+                },
+            ),
+            (
+                Actor::Player(PlayerId(0)),
+                GroundCommand::ChooseDarvoTarget {
+                    target: DarvoTarget {
+                        problem: Some(2),
+                        player: None,
+                    },
+                },
+            ),
+            (
+                Actor::Player(PlayerId(0)),
+                GroundCommand::ChooseDarvoTarget {
+                    target: DarvoTarget {
+                        problem: None,
+                        player: Some(p2),
+                    },
+                },
+            ),
+            (Actor::System, GroundCommand::Reveal),
+            (Actor::System, GroundCommand::Resolve),
+            (Actor::System, GroundCommand::EndRound),
+        ];
+
+        for (actor, command) in &cases {
+            let step = to_step(*actor, command);
+            let parsed = GroundState::parse_command(&step)
+                .unwrap_or_else(|e| panic!("{step:?} does not parse back: {e}"));
+            assert_eq!(parsed, (*actor, command.clone()), "round trip: {step:?}");
+        }
+
+        // Positive control: the case list must cover every variant. A
+        // shape added to GroundCommand and forgotten here would encode
+        // untested — the failure this test exists to prevent.
+        let shapes: std::collections::BTreeSet<String> = cases
+            .iter()
+            .map(|(_, c)| to_step(Actor::System, c).cmd)
+            .collect();
+        assert_eq!(shapes.len(), 8, "every GroundCommand variant must appear");
+    }
+}