CB-WP-0008: ship stage 0 — a GROUND game you can actually play

INTENT stage 0 lists CLI player and simple bots. Everything else on that
list exists: the engine is correct, measured and replayable, and nothing
can play it. Six passes and $236 in, GROUND has never been played end to
end by a human or a machine.

kind: product — the first pass under InnerLoop v1.5's soft 25% meta
budget, which should read comfortably under the line.

Worth more than stage 0: a bot is the kernel's first SECOND consumer.
INTENT says a concept becomes canonical only after surviving a second
concrete use, and every abstraction here has survived exactly one. A bot
driving the same aggregate through the same validate/fold path is the
cheapest second use available, and it is what would tell us whether
CommitWindow (provisional, delete-by 2026-12-31) and the LogStore port are
the right shapes.

T02 makes the per-player projection (K13) its first real consumer — the
rule is implemented and used by nothing. T03 tests the 2-6 player range
GR-O01 states, where every scenario in the corpus is 3-player: a rule
stated for a range and tested at one point is the shape this project keeps
finding, and discovering that 2p or 6p does not work is a legitimate
outcome rather than a reason to narrow the rule.

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

workplans/CB-WP-0008-ship-stage-0.md

@@ -0,0 +1,122 @@
+---
+id: CB-WP-0008
+kind: product
+title: "Ship INTENT stage 0: a GROUND game you can actually play"
+status: proposed
+---
+
+# Purpose
+
+INTENT stage 0 is *"Headless GROUND — full authoritative state, 2–6
+players, commit/reveal, relationships, DARVO, GROUND practice, **CLI
+player**, replay and scenario tests, **simple bots**."*
+
+Everything on that list exists except the two in bold. The engine is
+correct, measured, replayable — and **nothing can play it**. Six passes
+and $236 in, GROUND has never been played end to end by a human or a
+machine.
+
+This workplan is **`kind: product`** and is the first pass under
+InnerLoop v1.5's soft 25% meta budget. The budget should read comfortably
+under the line; if it does not, the evidence file says so and names what
+was displaced.
+
+**A note on what this is worth beyond stage 0.** A bot is the loop's first
+*second consumer* of the kernel. INTENT says a concept becomes canonical
+only after surviving a second concrete use — every abstraction here has
+survived exactly one. A bot driving the same aggregate through the same
+commands is the cheapest second use available, and it is the thing that
+would tell us whether `CommitWindow` (provisional, delete-by 2026-12-31)
+and the `LogStore` port are the right shapes.
+
+## Task: a bot that can finish a game
+
+```task
+id: CB-WP-0008-T01
+status: todo
+priority: high
+```
+
+Deliver a `Policy` trait in `games/ground` and at least two impls — a
+**random** policy (seeded, so games stay deterministic and replayable) and
+a **greedy** one that prefers a stated heuristic. Both drive `GroundState`
+through the ordinary `validate`/`fold` path; a bot that reaches into state
+directly would prove nothing about the kernel.
+
+**The positive control this needs:** a bot that cannot find a legal move
+must **fail loudly**, not stall or pass. The synthetic bench already
+carries this shape after an earlier harness spun forever on the GR-R03
+stress gate — the same failure is available here and would be worse,
+because a stalled bot looks like a finished game.
+
+**Acceptance:** a 3-player all-bot game runs to `GameEnded` (GR-R09, five
+rounds) with every command legal, and two runs at the same seed produce
+identical state hashes (K8).
+
+## Task: `cb-play` — the CLI player
+
+```task
+id: CB-WP-0008-T02
+status: todo
+priority: high
+```
+
+A binary that lets a human play GROUND against bots, headless.
+
+- renders the **per-player projection** (K13) for the seat to move —
+  which is the first real consumer of that rule, currently implemented and
+  used by nothing;
+- lists the legal commands for that seat and reads one from stdin;
+- fills remaining seats from `--bot <policy>`;
+- `--seed` for reproducibility, and writes a `.cbreplay` bundle on demand
+  so any game becomes an artifact (K10, shipped in CB-WP-0006 T06).
+
+**Stated non-goal:** no TUI, no colour, no interactive niceties. Stage 1
+is the inspectable 2D table; this is the smallest thing that makes the
+rules playable, and dressing it up now would be inventing a UI before a
+player has used one.
+
+**Acceptance:** a scripted stdin transcript plays a full 3-player game to
+`GameEnded`; the same transcript replays identically; and a seat's
+projection never contains another seat's hidden selection.
+
+## Task: prove the 2–6 player range
+
+```task
+id: CB-WP-0008-T03
+status: todo
+priority: medium
+```
+
+GR-O01 says 2–6 players. `setup` derives its preset from the seat count
+and looks generic, but **every scenario in the corpus is 3-player** and
+the only presets exercised are `standard-3p`. A rule stated for a range
+and tested at one point is the shape this project keeps finding.
+
+Deliver scenarios at the **2-player and 6-player** boundaries, plus an
+all-bot game at each, and report what breaks. Finding that 2p or 6p does
+*not* work is a legitimate and likely outcome — record it rather than
+quietly narrowing GR-O01.
+
+## Task: evidence and retrospective
+
+```task
+id: CB-WP-0008-T04
+status: todo
+priority: high
+```
+
+Commit `evidence/CB-EV-0007-stage-0.md`:
+
+1. **Is stage 0 shipped?** Each INTENT stage-0 item, met or not.
+2. **What did the second consumer reveal?** The bot is the kernel's first
+   non-scenario user. Name every abstraction it had to work around, and
+   every one that fitted — that is the evidence INTENT's second-use rule
+   was waiting for.
+3. **Meta share** under InnerLoop v1.5, and whether a product pass
+   actually reads under 25%.
+4. **Cost per unit of product**, against the $0.122–$0.359 per-response
+   range the spend review established.
+
+Then the retrospective the maintainer asked for: **six passes in, is the
+loop earning its keep?** Answer with the spend curve, not with argument.