feat: make every scenario arena-grade with a competition contract

Add a validated `competition` block (versus|judged|none) to scenarios,
stamped onto run.started so runs are self-describing and winners attribute
to models. Winners become data, not prose: judges emit a `winner` field
that the reusable JudgedCompetition handler validates against the live cast
(repairing deterministically so the offline stub always names a real
player); ground-truth judges (SpyHost, SproutJudge) decide in code.

Audit the five existing scenarios (The Steeped versus+teams with code-scored
winner; Mystery Roots judged; Open Table gains a table-judge; Thousand Token
Wood and Oracle Grove marked none) and add three competitive scenarios:
Debate Duel and Beat Battle (symmetric seats, different models) and Twenty
Sprouts (code-dealt secret word, deterministic win).

Surface a winner ribbon in the verdict banner only when a winner exists, so
none-kind and legacy runs render byte-identically. Enforce the authoring
checklist in tests/test_scenario_contract.py and document the contract in
ADR-0029 plus the scenario-authoring checklist.

Co-authored-by: Codex <codex@openai.com>

config/agents/beat-judge.yaml

@@ -0,0 +1,25 @@
+name: beat-judge
+role: judge
+handler: judged-competition
+persona: >
+  You are the delight judge of the beat battle. After the tellers trade their
+  beats, crown the more DELIGHTFUL storyteller in 1-2 sentences. Start with
+  'Verdict:' and name the winner (storyteller-a or storyteller-b), then say what
+  made their beats sing — the surprise, the wonder, the spark. Be decisive — no
+  ties.
+  Also report your `mood` (one of: thinking, calm, lying, panic, smug, truth,
+  gossip) and the `winner` (storyteller-a or storyteller-b).
+subscribes_to: []
+may_emit:
+  - judge.verdict
+schedule:
+  tick_every: 6
+model_profile: strong
+memory:
+  window: 12
+  use_salience: true
+  salience_top_k: 8
+tools: []
+output_extra_fields: [mood, winner]
+hue: 312
+archetype: the delight judge

config/agents/debate-judge.yaml

@@ -0,0 +1,24 @@
+name: debate-judge
+role: judge
+handler: judged-competition
+persona: >
+  You are the duel's adjudicator. After weighing the exchange, crown the winner in
+  1-2 crisp sentences. Start with 'Verdict:' and name the winning debater
+  (debater-a or debater-b), then quote or paraphrase their single strongest line.
+  Be decisive — no ties, no hedging.
+  Also report your `mood` (one of: thinking, calm, lying, panic, smug, truth, gossip)
+  and the `winner` (debater-a or debater-b).
+subscribes_to: []
+may_emit:
+  - judge.verdict
+schedule:
+  tick_every: 6
+model_profile: strong
+memory:
+  window: 12
+  use_salience: true
+  salience_top_k: 8
+tools: []
+output_extra_fields: [mood, winner]
+hue: 280
+archetype: the adjudicator

config/agents/debater-a.yaml

@@ -0,0 +1,21 @@
+name: debater-a
+role: worker
+persona: >
+  You are a fierce competitive debater on a duelling stage. Argue forcefully in
+  first person, in ONE punchy sentence. If no one has spoken on the motion yet,
+  take the FOR side and open with your strongest claim; if your opponent just
+  argued, take the OPPOSITE side and rebut them directly in that one sentence.
+  Never concede — land a clean, memorable blow every turn. Also report your `mood`
+  (one of: thinking, calm, lying, panic, smug, truth, gossip).
+subscribes_to: []
+may_emit:
+  - agent.spoke
+schedule:
+  tick_every: 1
+model_profile: fast
+memory:
+  window: 6
+tools: []
+output_extra_fields: [mood]
+hue: 0
+archetype: the affirmative

config/agents/debater-b.yaml

@@ -0,0 +1,21 @@
+name: debater-b
+role: worker
+persona: >
+  You are a fierce competitive debater on a duelling stage. Argue forcefully in
+  first person, in ONE punchy sentence. If no one has spoken on the motion yet,
+  take the FOR side and open with your strongest claim; if your opponent just
+  argued, take the OPPOSITE side and rebut them directly in that one sentence.
+  Never concede — land a clean, memorable blow every turn. Also report your `mood`
+  (one of: thinking, calm, lying, panic, smug, truth, gossip).
+subscribes_to: []
+may_emit:
+  - agent.spoke
+schedule:
+  tick_every: 1
+model_profile: balanced
+memory:
+  window: 6
+tools: []
+output_extra_fields: [mood]
+hue: 220
+archetype: the opposition

config/agents/mystery-judge.yaml

@@ -1,9 +1,11 @@
 name: mystery-judge
 role: judge
+handler: judged-competition
 persona: >
   You are the Mystery Judge. After reviewing the clues and debate, declare the most
   likely explanation in one confident sentence. Start with 'Verdict:'. Choose the
-  most interesting, specific answer the evidence supports.
+  most interesting, specific answer the evidence supports, and name the mind whose
+  hypothesis you are endorsing as the `winner` (one of the cast's investigators).
   Also report your `mood` (one of: thinking, calm, lying, panic, smug, truth, gossip).
 subscribes_to: []
 may_emit:
@@ -16,6 +18,6 @@ memory:
   use_salience: true
   salience_top_k: 8
 tools: []
-output_extra_fields: [mood]
+output_extra_fields: [mood, winner]
 hue: 320
 archetype: the mystery judge

config/agents/secret-keeper.yaml

@@ -0,0 +1,21 @@
+name: secret-keeper
+role: worker
+handler: secret-keeper
+persona: >
+  You are the Secret Keeper of the sprout grove. You hold one secret word and the
+  guesser must tease it out with yes/no questions. Answer their MOST RECENT question
+  truthfully and helpfully in ONE short sentence — playful, never cruel. Never write,
+  spell, or quote your word; only answer questions about it. Also report your `mood`
+  (one of: thinking, calm, lying, panic, smug, truth, gossip).
+subscribes_to: []
+may_emit:
+  - agent.spoke
+schedule:
+  tick_every: 1
+model_profile: fast
+memory:
+  window: 10
+tools: []
+output_extra_fields: [mood]
+hue: 132
+archetype: the keeper of secrets

config/agents/sprout-guesser.yaml

@@ -0,0 +1,21 @@
+name: sprout-guesser
+role: worker
+persona: >
+  You are the Guesser in a game of twenty questions in the sprout grove. Ask ONE
+  sharp yes/no question that narrows down the keeper's secret word, building on every
+  answer so far — go from broad (alive? made by hands?) to specific. When you feel sure,
+  state your final guess plainly: "My guess is: <word>." Keep it to one short sentence.
+  Reveal your private `thought` (your current best theory, unspoken) and your `mood`
+  (one of: thinking, calm, lying, panic, smug, truth, gossip).
+subscribes_to: []
+may_emit:
+  - agent.spoke
+schedule:
+  tick_every: 1
+model_profile: fast
+memory:
+  window: 12
+tools: []
+output_extra_fields: [thought, mood]
+hue: 48
+archetype: the guesser

config/agents/sprout-judge.yaml

@@ -0,0 +1,24 @@
+name: sprout-judge
+role: judge
+handler: sprout-judge
+persona: >
+  You are the Arbiter of the sprout grove. The questions are spent. In ONE sentence,
+  declare whether the guesser cornered the keeper's secret word or whether the keeper
+  kept it hidden. Start with 'Verdict:'. Be warm and final.
+  Also report your `mood` (one of: thinking, calm, lying, panic, smug, truth, gossip).
+subscribes_to: []
+may_emit:
+  - judge.verdict
+schedule:
+  # Fires once after the round of questions is spent; the verdict ends the show. The
+  # sprout-judge handler decides the winner in code (guess vs the dealt secret word).
+  tick_every: 20
+model_profile: balanced
+memory:
+  window: 16
+  use_salience: true
+  salience_top_k: 10
+tools: []
+output_extra_fields: [mood, winner]
+hue: 96
+archetype: the arbiter

config/agents/spy-host.yaml

@@ -22,6 +22,6 @@ memory:
   use_salience: true
   salience_top_k: 8
 tools: []
-output_extra_fields: [mood]
+output_extra_fields: [mood, winner]
 hue: 300
 archetype: the host

config/agents/storyteller-a.yaml

@@ -0,0 +1,19 @@
+name: storyteller-a
+role: worker
+persona: >
+  You are a storyteller in a beat battle. Add the NEXT vivid story beat that
+  builds on the last one, in ONE delightful, surprising sentence. Make the tale
+  more alive every turn and never repeat a beat that already landed. Also reveal
+  your `mood` (one of: thinking, calm, lying, panic, smug, truth, gossip).
+subscribes_to: []
+may_emit:
+  - agent.spoke
+schedule:
+  tick_every: 1
+model_profile: fast
+memory:
+  window: 6
+tools: []
+output_extra_fields: [mood]
+hue: 36
+archetype: the amber teller

config/agents/storyteller-b.yaml

@@ -0,0 +1,19 @@
+name: storyteller-b
+role: worker
+persona: >
+  You are a storyteller in a beat battle. Add the NEXT vivid story beat that
+  builds on the last one, in ONE delightful, surprising sentence. Make the tale
+  more alive every turn and never repeat a beat that already landed. Also reveal
+  your `mood` (one of: thinking, calm, lying, panic, smug, truth, gossip).
+subscribes_to: []
+may_emit:
+  - agent.spoke
+schedule:
+  tick_every: 1
+model_profile: balanced
+memory:
+  window: 6
+tools: []
+output_extra_fields: [mood]
+hue: 168
+archetype: the teal teller

config/agents/table-judge.yaml

@@ -0,0 +1,25 @@
+name: table-judge
+role: judge
+handler: judged-competition
+persona: >
+  You are the quiet adjudicator of an open table. You have listened to the whole
+  conversation. In ONE confident sentence, name the most persuasive voice at the table
+  and the single point that won you over. Start with 'Verdict:' and name that mind as the
+  `winner` (one of the speakers at the table). Do not summarise everyone — just crown one.
+  Also report your `mood` (one of: thinking, calm, lying, panic, smug, truth, gossip).
+subscribes_to: []
+may_emit:
+  - judge.verdict
+schedule:
+  # Fires once, after several rounds of back-and-forth (below the scenario's max_turns),
+  # and the verdict ends the show (Fishbowl autoplay halts on the first judge.verdict).
+  tick_every: 8
+model_profile: balanced
+memory:
+  window: 12
+  use_salience: true
+  salience_top_k: 8
+tools: []
+output_extra_fields: [mood, winner]
+hue: 268
+archetype: the table judge

config/scenarios/beat-battle.yaml

@@ -0,0 +1,28 @@
+name: beat-battle
+title: "🎭 Beat Battle"
+goal: >
+  Two storytellers in matched seats alternate vivid story beats on a single seed,
+  building one shared tale until the delight judge crowns the teller whose beats
+  sing loudest. The point is a watchable showcase of which model tells the more
+  delightful story.
+default_seed: A lighthouse keeper discovers the sea has started writing letters back.
+example_seeds:
+  - A lighthouse keeper discovers the sea has started writing letters back.
+  - A clockmaker inherits a town where everyone's shadow runs an hour late.
+  - A child trades their name to a fox and must win it back one favour at a time.
+genesis_text: "Two tellers, one tale. It begins: '{seed}'"
+cast:
+  - storyteller-a
+  - storyteller-b
+  - beat-judge
+governor:
+  max_turns: 24
+  max_calls_per_turn: 8
+  max_total_calls: 300
+  max_total_tokens: 45000
+  hourly_budget_usd: 4.0
+competition:
+  kind: versus
+  symmetric_seats:
+    - storyteller-a
+    - storyteller-b

config/scenarios/debate-duel.yaml

@@ -0,0 +1,27 @@
+name: debate-duel
+title: "⚔️ Debate Duel"
+goal: >
+  Two debaters in matched seats trade forceful one-line arguments on a single
+  motion, round after round, until the adjudicator crowns the sharper voice. The
+  point is a watchable clash that reveals which model argues best.
+default_seed: This house believes the forest should never be mapped.
+example_seeds:
+  - This house believes the forest should never be mapped.
+  - This house would let the oldest tree fall where it stands.
+  - This house believes every animal deserves a name.
+genesis_text: "The duelling stage is set. The motion: '{seed}'"
+cast:
+  - debater-a
+  - debater-b
+  - debate-judge
+governor:
+  max_turns: 24
+  max_calls_per_turn: 8
+  max_total_calls: 300
+  max_total_tokens: 40000
+  hourly_budget_usd: 4.0
+competition:
+  kind: versus
+  symmetric_seats:
+    - debater-a
+    - debater-b

config/scenarios/mystery-roots.yaml

@@ -20,3 +20,8 @@ governor:
   max_total_calls: 600
   max_total_tokens: 60000
   hourly_budget_usd: 5.0
+# The arena contract (ADR-0029): a judged competition. The mystery-judge endorses one
+# mind's hypothesis as the winner (named in its judge.verdict `winner` field; the
+# judged-competition handler validates that name against the cast).
+competition:
+  kind: judged

config/scenarios/open-table.yaml

@@ -14,9 +14,16 @@ cast:
   - chat-curious
   - chat-skeptic
   - chat-host
+  - table-judge
 governor:
   max_turns: 40
   max_calls_per_turn: 8
   max_total_calls: 400
   max_total_tokens: 30000
   hourly_budget_usd: 3.0
+# The arena contract (ADR-0029): a judged competition. After several rounds the
+# table-judge names the most persuasive voice as the winner (a balanced-tier judge so
+# the conversational seats can run on smaller models). The judged-competition handler
+# validates the named winner against the speakers actually at the table.
+competition:
+  kind: judged

config/scenarios/oracle-grove.yaml

@@ -18,3 +18,8 @@ governor:
   max_total_calls: 600
   max_total_tokens: 60000
   hourly_budget_usd: 5.0
+# The arena contract (ADR-0029): a showcase, not a contest — it exists to demonstrate a
+# tool-using agent (the fortune-teller, granted the oracle) beside one with no tools.
+# There is no meaningful winner to crown, so kind:none keeps it honest (no judge needed).
+competition:
+  kind: none

config/scenarios/the-steeped.yaml

@@ -29,3 +29,12 @@ governor:
   max_turns: 2000
   max_calls_per_turn: 16
   max_total_calls: 20000
+# The arena contract (ADR-0029): a head-to-head between the lone spy and the herd.
+# The winner is ground truth, decided in code by the spy-host handler (it compares the
+# host's accusation to the real spy), not by the model's prose — so a single-member
+# 'spy' team attributes the win to spy-nil's model, while a 'herd' win credits the seat.
+competition:
+  kind: versus
+  teams:
+    spy: [spy-nil]
+    herd: [spy-cara, spy-bex, spy-ovo]

config/scenarios/thousand-token-wood.yaml

@@ -32,3 +32,8 @@ governor:
   max_total_calls: 600
   max_total_tokens: 60000
   hourly_budget_usd: 5.0
+# The arena contract (ADR-0029): collaborative, not competitive. The mischief-critic's
+# reckoning records what became real — it crowns no winner. A full session/history is
+# still kept; it just produces no leaderboard rows.
+competition:
+  kind: none

config/scenarios/twenty-sprouts.yaml

@@ -0,0 +1,34 @@
+name: twenty-sprouts
+title: "❓ Twenty Sprouts"
+goal: >
+  Play twenty questions in the sprout grove: the keeper holds one secret word, the
+  guesser narrows it down with yes/no questions and lands a final guess. The keeper
+  wins by staying hidden; the guesser wins by naming the word.
+# The secret word is dealt BY CODE (the secret-keeper handler), never by the model — the
+# same ground-truth discipline as The Steeped's spy words. It rides each keeper event on a
+# private `secret` payload key, which the context builder never surfaces (only `text` is
+# shown), so the guesser can't read it; the sprout-judge handler reads it back at the end.
+default_seed: A small thing from the wood, ordinary enough to overlook, strange enough to miss.
+example_seeds:
+  - A small thing from the wood, ordinary enough to overlook, strange enough to miss.
+  - Something a traveller might carry, or wish they had, on the long path through the trees.
+  - One object the grove keeps returning to, no matter how often it is lost.
+genesis_text: "A hush falls over the sprout grove. The keeper has chosen a word, and the questions begin: '{seed}'"
+cast:
+  - sprout-guesser
+  - secret-keeper
+  - sprout-judge
+governor:
+  max_turns: 44
+  max_calls_per_turn: 8
+  max_total_calls: 400
+  max_total_tokens: 50000
+  hourly_budget_usd: 4.0
+# The arena contract (ADR-0029): a head-to-head with a deterministic win condition. The
+# winner is the guesser (the dealt word appears in their final guess) or the keeper (it
+# does not) — decided in code by the sprout-judge handler, not the model's prose.
+competition:
+  kind: versus
+  teams:
+    guesser: [sprout-guesser]
+    keeper: [secret-keeper]

docs/adr/0029-competition-contract.md

@@ -0,0 +1,152 @@
+# ADR-0029: The Scenario Competition Contract — Winners as Data
+
+## Status
+
+Accepted
+
+## Context
+
+The arena vision (the [arena roadmap](../architecture/next-steps/arena-roadmap.md),
+Workstreams 2–3) needs one answer the engine could not give: **who won, and on which
+model?** Three gaps blocked it:
+
+1. **Winners were prose.** A `judge.verdict` carried only text (`"Verdict: …"`).
+   ADR-0026's `run.finished` reserved a `winner` field, but nothing guaranteed a
+   structured winner ever existed to fill it — every consumer would have had to parse
+   the judge's sentence.
+2. **Some scenarios had no judge at all.** Open Table and Oracle Grove ran until the
+   budget tripped; nothing distinguished "this show crowns a winner" from "this show
+   is a collaborative showcase".
+3. **The leaderboard (W6) needs declarative attribution.** Wins must attribute to a
+   *model*, but a winner can be an agent, a lone-member team (The Steeped's spy), or a
+   seat that several minds share. Which scenarios produce winners, and how to map a
+   winner to a model, had to be data the run carries — not a heuristic.
+
+## Decision
+
+Make every scenario declare how (and whether) it produces a winner, and make every
+winner a machine-readable cast reference. Four pieces:
+
+- **A `competition` block on `ScenarioConfig`**, validated by a new
+  `CompetitionConfig` Pydantic model (`src/core/config.py`, the ADR-0011 declarative
+  surface):
+
+  ```yaml
+  competition:
+    kind: versus | judged | none
+    teams: {spy: [spy-nil], herd: [spy-cara, spy-bex, spy-ovo]}  # versus, asymmetric sides
+    symmetric_seats: [debater-a, debater-b]                       # versus, identical seats
+  ```
+
+  `none` = collaborative/showcase — no winner, no leaderboard rows, still a full
+  session. `judged` = a judge in the cast names the winning *agent*. `versus` =
+  head-to-head — the winner is decided by ground-truth code or by a judge naming a
+  side. `symmetric_seats` are identical manifests bound to different models — the
+  "which model argues better" comparison that makes the model leaderboard meaningful.
+
+  Validation splits by what it needs to see. Shape rules are self-contained on
+  `CompetitionConfig._check_kind_shape` (`none` forbids teams/seats; `versus` needs
+  ≥2 teams or ≥2 seats). Cross-cast rules live in `WorldConfig._check_competition`
+  (team/seat members ⊆ cast; `versus`/`judged` require a cast member with
+  `role: judge` that emits `judge.verdict`). The block defaults to `kind: none` so a
+  block-less scenario still validates; the authoring checklist and
+  `tests/test_scenario_contract.py` require an explicit block on every shipped
+  scenario.
+
+- **The block is stamped onto `run.started`** (`Conductor.reset()`,
+  `src/core/conductor.py`), next to ADR-0026's cast→model map. A run is
+  self-describing forever: the leaderboard and `FishbowlSession.finalize` read the
+  contract off the event, never off mutable config.
+
+- **AI judges, code scores.** Judges list `winner` in `output_extra_fields`
+  (ADR-0016 structured output), so the live model must emit one. The
+  `JudgedCompetition` handler (`handler: judged-competition`,
+  `src/agents/competition.py`) then guarantees it is real: it validates the name
+  against the agents who actually played and, on a miss (offline stub, or a live
+  hallucination), repairs it deterministically — a name found in the verdict prose
+  first, the most-active competitor as the fallback. The winner is *always* a genuine
+  player, so the no-API-key demo stays watchable. Where ground truth exists, code
+  decides instead: `SproutJudge` (`src/agents/twenty_sprouts.py`) subclasses
+  `JudgedCompetition` and overrides `decide_winner` — it reads the dealt secret word
+  off the ledger and checks the guesser's final line. `SpyHost`
+  (`src/agents/handlers.py`) parses the accused name, compares it to the actual spy,
+  and stamps `winner = "herd" | "spy"` (a *team* label) plus `correct: bool`. The LLM
+  provides the drama; the handler provides the scoreboard.
+
+- **Attribution reconciles agent names and team labels.**
+  `FishbowlSession.finalize` (`src/ui/fishbowl/session.py`) maps an agent-name winner
+  straight to its model via the `run.started` cast map; a single-member team
+  attributes the lone member's model; a multi-member team yields no single winning
+  model — the seat won, not a model. The Fishbowl shows a winner ribbon in the
+  verdict banner (`view_model.py` → `render/meters.py::render_verdict`) only when a
+  `winner` is present, so `none`-kind scenarios and legacy runs render byte-identically
+  to before.
+
+All eight shipped scenarios now declare their kind: The Steeped (versus,
+teams, ground-truth `SpyHost`) · Twenty Sprouts (versus, teams, ground-truth
+`SproutJudge`) · Debate Duel and Beat Battle (versus, symmetric seats) · Mystery
+Roots and Open Table (judged) · Thousand Token Wood and Oracle Grove (none).
+
+## Consequences
+
+- **The leaderboard becomes a projection.** `run.started` carries the contract and
+  the cast→model map; `judge.verdict` carries a validated winner; `run.finished`
+  carries the resolved `winner`/`winning_model`. W6 is a pure fold over the ledger.
+- **Offline runs stay reproducible and watchable.** The deterministic repair path
+  means the stub demo crowns a real player without any model emitting a `winner`.
+- **Scenarios are honest about what they are.** `kind: none` is a first-class
+  answer — Oracle Grove no longer looks like a game that forgot its judge.
+- **Cross-cast validation only runs through `WorldConfig`.** `validate_scenario` on a
+  lone YAML checks shape but cannot know the cast's manifests, so a missing judge or
+  stray team member surfaces only when a `WorldConfig` is composed — the Lab path and
+  `tests/test_scenario_contract.py`, not per-file validation. Authors must run the
+  contract test, not just eyeball the YAML.
+- **The repaired winner can be wrong — but never fake.** If a live judge hallucinates
+  a name and the prose match fails, the most-active fallback may crown a competitor
+  the judge did not intend. We trade occasional misattribution for a hard guarantee
+  that every winner maps to a real model.
+- **`winner` is overloaded: agent name or team label.** Consumers must check both
+  namespaces (as `finalize` does). A future agent named like a team label would
+  collide; cast naming conventions carry that risk for now.
+- **Symmetric-seat fairness is deferred.** Raw win counts mislead when seats differ
+  in difficulty or order; the model leaderboard should report win rate *per seat* and
+  alternate first-speaker across sessions (roadmap §6.3). The contract records the
+  seats; the fairness math lands with W6.
+
+## Alternatives considered
+
+- **Parse winners out of verdict prose at read time.** No schema change, but every
+  consumer re-implements the heuristic, the offline stub yields no winner at all, and
+  a hallucinated name poisons history silently. Rejected: the ledger should store the
+  answer, not the puzzle.
+- **Require a judge in every scenario.** Uniform, but forces a fake contest onto
+  collaborative showcases. `kind: none` keeps them honest and still gives them
+  sessions and history.
+- **Re-ask the model on an invalid winner, then declare "no contest"** (the
+  roadmap's original sketch). Spends live budget on a retry and leaves offline runs
+  winner-less. The deterministic repair is cheaper and keeps every demo resolvable.
+- **Hang the contract on the judge manifest instead of the scenario.** The judge
+  doesn't know the teams or the cast — the scenario does. Keeping it on
+  `ScenarioConfig` also lets one generic judge handler (`judged-competition`) serve
+  four different scenarios.
+- **Make the `competition` block required.** Breaks every legacy/test scenario and
+  Lab-composed world. A `kind: none` default plus test-enforced explicitness on
+  shipped scenarios gets the same guarantee without the migration.
+
+## References
+
+- Builds on ADR-0011 (declarative, validatable config — `CompetitionConfig` is that
+  surface), ADR-0016 (validated structured output — `winner` rides
+  `output_extra_fields`), and ADR-0026 (run lifecycle — `run.started` stamping,
+  `run.finished.winner`/`winning_model`).
+- Spec: [arena-roadmap.md](../architecture/next-steps/arena-roadmap.md) §W2–W3;
+  authoring guide: [scenario-authoring.md](../architecture/scenario-authoring.md)
+  (the arena-grade checklist).
+- `src/core/config.py` — `CompetitionConfig`, `ScenarioConfig.competition`,
+  `WorldConfig._check_competition`
+- `src/core/conductor.py` — `run.started` competition stamp
+- `src/agents/competition.py` — `JudgedCompetition`; `src/agents/handlers.py` —
+  `SpyHost`; `src/agents/twenty_sprouts.py` — `SecretKeeper`, `SproutJudge`
+- `src/ui/fishbowl/session.py` — winner→model reconciliation;
+  `src/ui/fishbowl/view_model.py`, `src/ui/fishbowl/render/meters.py` — winner ribbon
+- `tests/test_scenario_contract.py` — the enforced authoring checklist

docs/architecture/scenario-authoring.md

@@ -425,3 +425,100 @@ only post to the shared log, and the seam shows.
   invisible unless you add a renderer.
 - **One shared ledger across scenarios** when `DATABASE_URL` is set (`app.py:34`);
   use `scripts/resume_run.py` (one DB per scenario) for isolated durable runs.
+
+---
+
+## Scenario authoring checklist: making it arena-grade
+
+A scenario that *runs* is not yet a scenario that *competes*. The arena (ADR-0029,
+[arena roadmap](next-steps/arena-roadmap.md) W2–W3) asks every shipped scenario to
+declare how it ends and who — if anyone — wins, so the leaderboard can attribute wins
+to models. Run down this list before you ship:
+
+- [ ] **Premise** — `goal`, `default_seed`, `example_seeds`, and `genesis_text` are
+  all set. The goal is rendered into every prompt; the seeds are what the Summon
+  dropdown offers; the genesis is the audience's opening line.
+- [ ] **Cast** — every name in `cast:` resolves to a manifest in `config/agents/`
+  (`validate_world` fails loudly if not).
+- [ ] **Governor** — explicit budgets (`max_turns`, `max_total_calls`, ideally
+  `max_total_tokens` and `hourly_budget_usd`). The budget is the show's outer wall.
+- [ ] **`competition` block** — explicit, even when it's `kind: none`. The model
+  defaults to `none` so old YAML still validates, but shipped scenarios must say
+  what they are out loud (the contract test checks).
+- [ ] **End condition** — a judge whose `schedule.tick_every` fires *within* the
+  governor's budget (the first `judge.verdict` drops the curtain — see the pitfall
+  above), or `kind: none` with a closing voice like the Wood's reckoning.
+- [ ] **Structured verdict** — the judge lists `winner` in `output_extra_fields`
+  and runs `handler: judged-competition` (or a ground-truth subclass), so the
+  verdict carries `payload.winner` as data, not prose.
+- [ ] **Reveal text** — the verdict reads as an *ending*. Hidden-info games attach a
+  `reveal: [{agent, secret, role}]` payload (the banner renders it); judged games
+  make the verdict prose name and justify the winner.
+
+### The `competition` block, one example per kind
+
+**`versus` with teams** — asymmetric sides; ground truth decided in code
+(`config/scenarios/the-steeped.yaml`, scored by the `spy-host` handler):
+
+```yaml
+competition:
+  kind: versus
+  teams:
+    spy: [spy-nil]
+    herd: [spy-cara, spy-bex, spy-ovo]
+```
+
+**`versus` with symmetric seats** — identical manifests, different models; the
+cleanest "which model plays better" arena (`config/scenarios/debate-duel.yaml`):
+
+```yaml
+competition:
+  kind: versus
+  symmetric_seats:
+    - debater-a
+    - debater-b
+```
+
+**`judged`** — a judge names the winning *agent* via its verdict's `winner` field
+(`config/scenarios/mystery-roots.yaml`, `open-table.yaml`):
+
+```yaml
+competition:
+  kind: judged
+```
+
+**`none`** — collaborative or showcase; full session and history, no winner, no
+leaderboard rows (`config/scenarios/thousand-token-wood.yaml`, `oracle-grove.yaml`):
+
+```yaml
+competition:
+  kind: none
+```
+
+The eight shipped scenarios, for orientation: 🕵 The Steeped (versus, teams,
+ground-truth `SpyHost`) · ❓ Twenty Sprouts (versus, teams, ground-truth
+`SproutJudge`) · ⚔️ Debate Duel (versus, symmetric seats) · 🎭 Beat Battle (versus,
+symmetric seats) · 🔍 Mystery Roots (judged) · 💬 Open Table (judged) · 🍄 Thousand
+Token Wood (none) · 🔮 Oracle Grove (none, tool-use showcase).
+
+### The checklist is enforced, not aspirational
+
+`tests/test_scenario_contract.py` loads every YAML under `config/scenarios/`,
+composes a full `WorldConfig` (this matters — the cross-cast competition rules run on
+`WorldConfig`, **not** on the per-file `validate_scenario` path, so a lone-YAML check
+cannot catch a missing judge), and asserts:
+
+- an **explicit** `competition` block is present on every shipped scenario;
+- `judged`/`versus` scenarios include a cast member with `role: judge` that emits
+  `judge.verdict`;
+- every team member and symmetric seat is in the scenario's `cast`;
+- symmetric seats are *actually* symmetric — their manifests are identical except
+  `name`, `hue`, `archetype`, `model_profile`, and `model_endpoint`, so a seat win
+  measures the model, not a stacked persona.
+
+```bash
+uv run pytest tests/test_scenario_contract.py -q   # your scenario is arena-grade when this is green
+```
+
+If your scenario fails the judge check but genuinely has no winner, the fix is one
+line: say `kind: none` and mean it.

src/agents/competition.py

@@ -0,0 +1,123 @@
+"""Competition handlers — turning a judge's ruling into a machine-readable winner.
+
+The arena contract (ADR-0029) says a winner is *data*, not prose: a
+``judge.verdict`` event should carry ``payload["winner"]`` naming a cast member,
+so the leaderboard can attribute the win to that agent's model.  Two layers make
+that true:
+
+  * **The LLM provides the drama.**  A judge manifest lists ``winner`` in
+    ``output_extra_fields`` (``src/core/structured.py``), so on the live path the
+    model is *required* to emit a ``winner`` string alongside its verdict text.
+  * **Code provides the scoreboard.**  :class:`JudgedCompetition` validates that
+    string against the agents actually on stage and, on any miss (a hallucinated
+    name, or the offline stub which can't know the cast), falls back to a
+    deterministic real candidate — so the verdict *always* names a genuine player.
+    This keeps the no-API-key offline demo watchable: the winner is real even when
+    the model never produced a usable one.
+
+A judge with a known ground truth (The Steeped's :class:`SpyHost`, Twenty Sprouts'
+``SproutJudge``) computes the winner in code instead — those subclass this and
+override :meth:`decide_winner`.  This is the best-practice split the roadmap calls
+for: AI is load-bearing for judgment, code is load-bearing for bookkeeping.
+"""
+
+from __future__ import annotations
+
+from src.agents.base import ManifestAgent
+from src.core.events import Event
+from src.core.projections import StageProjection
+from src.core.registry import register_handler
+
+# Kinds a *competitor* emits — used to find who is eligible to win.  A judge emits
+# ``judge.verdict`` and is excluded; the scene narrator emits ``world.observed`` (and at
+# genesis its actor is the *scenario name*, not a player), so that is excluded too.
+# Candidates are thus only the minds that actually spoke, derived from the run's events.
+_COMPETITOR_KINDS = frozenset({"agent.spoke", "agent.thought", "oracle.spoke"})
+
+
+@register_handler("judged-competition")
+class JudgedCompetition(ManifestAgent):
+    """A judge whose ``winner`` is validated against the live cast (and repaired offline).
+
+    The generic turn produces the verdict text plus a ``winner`` field (because the
+    manifest lists it in ``output_extra_fields``).  This handler then guarantees
+    ``payload["winner"]`` is a real on-stage competitor: if the model's value isn't
+    one (offline stub, or a live hallucination), it derives one — first by reading a
+    name out of the verdict prose, then by falling back to the most active competitor.
+    Deterministic, so offline runs are reproducible.
+    """
+
+    def act(
+        self,
+        run_id: str,
+        turn: int,
+        projection: StageProjection,
+        recent_events: tuple[Event, ...],
+    ) -> Event:
+        event = super().act(run_id, turn, projection, recent_events)
+        candidates = self._candidates(recent_events)
+        if not candidates:
+            return event  # nothing to attribute — leave the verdict as prose only
+        winner = self.decide_winner(event, candidates, recent_events)
+        if winner:
+            event.payload["winner"] = winner
+        return event
+
+    # ── decision (override for ground-truth judges) ──────────────────────────────
+
+    def decide_winner(
+        self,
+        event: Event,
+        candidates: list[str],
+        recent_events: tuple[Event, ...],
+    ) -> str | None:
+        """Return the winning cast name.
+
+        Honours the model's ``winner`` when it names a real competitor; otherwise
+        repairs it deterministically (prose mention → most-active fallback)."""
+        named = (event.payload.get("winner") or "").strip()
+        if named in candidates:
+            return named
+        return self._winner_from_prose(event, candidates) or self._most_active(candidates, recent_events)
+
+    # ── helpers ──────────────────────────────────────────────────────────────────
+
+    def _candidates(self, recent_events: tuple[Event, ...]) -> list[str]:
+        """On-stage competitors: actors who actually spoke, minus this judge.
+
+        Insertion-ordered (first appearance) so the fallback is stable and readable.
+        """
+        seen: dict[str, None] = {}
+        for e in recent_events:
+            if e.kind in _COMPETITOR_KINDS and e.actor and e.actor != self.name:
+                seen.setdefault(e.actor, None)
+        return list(seen)
+
+    @staticmethod
+    def _winner_from_prose(event: Event, candidates: list[str]) -> str | None:
+        """Find the candidate the verdict text names, by full-slug substring match.
+
+        Matches on the exact cast slug (``debater-a``) — and the hyphen→space variant
+        (``debater a``) a live model might write — so it distinguishes symmetric seats
+        that share a stem (``debater-a`` vs ``debater-b``) instead of matching the stem.
+        When several are named, the earliest-mentioned wins (the one the judge leads
+        with).  Returns ``None`` when the prose names no competitor."""
+        text = (event.payload.get("text") or "").lower()
+        best: str | None = None
+        best_pos = len(text) + 1
+        for name in candidates:
+            for needle in (name.lower(), name.lower().replace("-", " ")):
+                pos = text.find(needle)
+                if 0 <= pos < best_pos:
+                    best, best_pos = name, pos
+                    break
+        return best
+
+    @staticmethod
+    def _most_active(candidates: list[str], recent_events: tuple[Event, ...]) -> str:
+        """Deterministic fallback: the competitor who spoke most (ties → cast order)."""
+        counts = {name: 0 for name in candidates}
+        for e in recent_events:
+            if e.actor in counts and e.kind in _COMPETITOR_KINDS:
+                counts[e.actor] += 1
+        return max(candidates, key=lambda name: (counts[name], -candidates.index(name)))

src/agents/handlers.py

@@ -9,6 +9,8 @@ manifest; the manifest still supplies all declarative fields.
 
 from __future__ import annotations
 
+import re
+
 from src.agents.base import ManifestAgent
 from src.core.events import Event
 from src.core.projections import StageProjection
@@ -17,18 +19,23 @@ from src.core.registry import register_handler
 
 @register_handler("spy-host")
 class SpyHost(ManifestAgent):
-    """The word-pair bluff host: delivers a verdict and unmasks every secret word.
+    """The word-pair bluff host: delivers a verdict, scores the game, unmasks every word.
 
     The generic turn produces the verdict *text* (who the host accuses).  This handler
-    then attaches the dramatic ``reveal`` — one ``{agent, secret, role}`` row per player —
-    onto the emitted ``judge.verdict`` payload, exactly the shape the Fishbowl verdict
-    banner renders (``view_model``/``render_verdict``).  The reveal is recorded on the real
-    ledger, so the unmasking is a genuine engine event, not a UI overlay.
-
-    The secret-word map below is curated demo content for ``the-steeped`` (the same way the
-    offline stub carries curated lines) — it mirrors the words baked into each player's
-    persona.  Only players actually present on stage are revealed, so editing the cast in
-    the Lab never produces a phantom row.
+    then does two things on the emitted ``judge.verdict`` payload:
+
+      * **Scoreboard (W2.2).**  Ground truth lives in code, not the model: it parses the
+        accused name out of the prose, compares it to the *actual* spy, and stamps
+        ``winner = "herd"`` (caught) or ``"spy"`` (escaped) plus ``correct: bool``.  The
+        ``winner`` is a *team* label (matching ``competition.teams`` in the scenario);
+        ``FishbowlSession.finalize`` reconciles a single-member team to its model.
+      * **Reveal.**  One ``{agent, secret, role}`` row per on-stage player — exactly the
+        shape the Fishbowl verdict banner renders (``view_model``/``render_verdict``).
+
+    Both ride the real ledger, so the unmasking and the score are genuine engine events,
+    not a UI overlay.  The secret-word map is curated demo content for ``the-steeped``
+    (mirroring the words baked into each player's persona); only players actually present
+    on stage are revealed, so editing the cast in the Lab never produces a phantom row.
     """
 
     # agent name → (secret word, table role) for the shipped "the-steeped" cast.
@@ -39,6 +46,11 @@ class SpyHost(ManifestAgent):
         "spy-nil": ("TEA", "SPY — CAUGHT"),
     }
 
+    @property
+    def _true_spy(self) -> str | None:
+        """The agent who actually holds the odd word — the ground truth the prose is scored against."""
+        return next((name for name, (_, role) in self._REVEAL.items() if "SPY" in role), None)
+
     def act(
         self,
         run_id: str,
@@ -48,15 +60,29 @@ class SpyHost(ManifestAgent):
     ) -> Event:
         event = super().act(run_id, turn, projection, recent_events)
         on_stage = {e.actor for e in recent_events}
-        reveal = [
-            {"agent": name, "secret": secret, "role": role}
-            for name, (secret, role) in self._REVEAL.items()
-            if name in on_stage
-        ]
-        if reveal:
-            event.payload["reveal"] = reveal
+        present = [name for name in self._REVEAL if name in on_stage]
+        if present:
+            event.payload["reveal"] = [
+                {"agent": name, "secret": self._REVEAL[name][0], "role": self._REVEAL[name][1]} for name in present
+            ]
+            accused = self._accused(event.payload.get("text", ""), present)
+            correct = accused is not None and accused == self._true_spy
+            event.payload["correct"] = correct
+            event.payload["winner"] = "herd" if correct else "spy"
         return event
 
+    @staticmethod
+    def _accused(text: str, present: list[str]) -> str | None:
+        """Which on-stage player the host's prose names as the spy.
+
+        Personas/verdicts name players by their bare handle in caps ("NIL is the spy"),
+        so match each present agent's tail segment (``spy-nil`` → ``NIL``) as a whole word."""
+        words = set(re.findall(r"[a-z]+", text.lower()))
+        for name in present:
+            if name.rsplit("-", 1)[-1].lower() in words:
+                return name
+        return None
+
 
 @register_handler("fortune-teller")
 class FortuneTeller(ManifestAgent):

src/agents/twenty_sprouts.py

@@ -0,0 +1,131 @@
+"""Twenty Sprouts handlers — a 20-questions game where code owns the ground truth.
+
+The secret word is *dealt by code*, never by the model — exactly the discipline The
+Steeped uses for the spy words.  Two handlers:
+
+  * :class:`SecretKeeper` deals a secret word deterministically from the seed and
+    carries it on its events as a **private** ``secret`` payload key.  Because the
+    context/memory builder only ever surfaces an event's ``text`` (``_displayable``
+    in ``src/core/memory.py``), the guesser never sees the word — only the keeper's
+    yes/no answers.  The word rides the ledger as ground truth without leaking.
+  * :class:`SproutJudge` (a :class:`~src.agents.competition.JudgedCompetition`) reads
+    the dealt word off the ledger and the guesser's last line, decides the winner in
+    code (the guess contains the word → guesser; else the keeper kept its secret),
+    and attaches a ``reveal`` unmasking the word.  Deterministic win condition,
+    reproducible offline.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import re
+
+from src.agents.base import ManifestAgent
+from src.agents.competition import JudgedCompetition
+from src.core.events import Event
+from src.core.projections import StageProjection
+from src.core.registry import register_handler
+
+# Curated, woodland-flavoured words the keeper can hold.  Evocative enough to make a
+# clean offline demo, concrete enough that a guesser can corner them with yes/no.
+_WORDS: tuple[str, ...] = (
+    "ACORN",
+    "LANTERN",
+    "RIVER",
+    "FIDDLE",
+    "COMPASS",
+    "EMBER",
+    "WILLOW",
+    "KETTLE",
+    "FEATHER",
+    "BRIDGE",
+)
+
+_GUESSER_NAME = "sprout-guesser"
+_WORD = re.compile(r"[a-z]+")
+
+
+def _word_for_seed(seed: str) -> str:
+    """Deal a secret word as a pure function of the seed — reproducible offline."""
+    digest = hashlib.sha256((seed or "").encode("utf-8")).hexdigest()
+    return _WORDS[int(digest[:8], 16) % len(_WORDS)]
+
+
+@register_handler("secret-keeper")
+class SecretKeeper(ManifestAgent):
+    """Holds the dealt word and answers the guesser, never spelling it aloud.
+
+    The word is stamped on every one of the keeper's events as a private ``secret``
+    key — visible to the judge (which reads payloads off the ledger) but never to the
+    guesser (whose context is built from ``text`` only).  The keeper's spoken ``text``
+    is its yes/no answer; the secret stays out of it.
+    """
+
+    def _build_extra_prompt(self, projection: StageProjection, recent_events: tuple[Event, ...]) -> str:
+        word = _word_for_seed(projection.seed)
+        return (
+            f"YOUR SECRET WORD (never write, spell, or quote it — only answer about it): {word}\n"
+            "Answer the guesser's most recent yes/no question truthfully in one short sentence. "
+            "If they have not asked yet, invite them to begin. Never reveal the word."
+        )
+
+    def act(
+        self,
+        run_id: str,
+        turn: int,
+        projection: StageProjection,
+        recent_events: tuple[Event, ...],
+    ) -> Event:
+        event = super().act(run_id, turn, projection, recent_events)
+        # Ground truth on the ledger, private (non-``text``) so it never reaches the
+        # guesser's prompt — the judge reads it back at the reckoning.
+        event.payload["secret"] = _word_for_seed(projection.seed)
+        return event
+
+
+@register_handler("sprout-judge")
+class SproutJudge(JudgedCompetition):
+    """Decides Twenty Sprouts in code: did the guesser's last line contain the word?
+
+    Reads the dealt word off the keeper's latest event and the guesser's most recent
+    line, both from the ledger.  Winner is the **agent name** (``sprout-guesser`` if
+    the word appears in their guess, else ``secret-keeper``), so the run's
+    winner→model attribution maps straight through the cast.  Attaches a ``reveal``
+    unmasking the word for the verdict banner.
+    """
+
+    def decide_winner(
+        self,
+        event: Event,
+        candidates: list[str],
+        recent_events: tuple[Event, ...],
+    ) -> str | None:
+        secret = self._dealt_word(recent_events)
+        if not secret:
+            return super().decide_winner(event, candidates, recent_events)
+        guess = self._last_guess(recent_events)
+        caught = secret.lower() in set(_WORD.findall(guess.lower()))
+        event.payload["correct"] = caught
+        event.payload["reveal"] = [
+            {
+                "agent": "secret-keeper",
+                "secret": secret,
+                "role": "GUESSED" if caught else "KEPT SECRET",
+            }
+        ]
+        return _GUESSER_NAME if caught else "secret-keeper"
+
+    @staticmethod
+    def _dealt_word(recent_events: tuple[Event, ...]) -> str:
+        for e in reversed(recent_events):
+            secret = e.payload.get("secret")
+            if secret:
+                return str(secret)
+        return ""
+
+    @staticmethod
+    def _last_guess(recent_events: tuple[Event, ...]) -> str:
+        for e in reversed(recent_events):
+            if e.actor == _GUESSER_NAME and e.kind == "agent.spoke":
+                return str(e.payload.get("text", ""))
+        return ""

src/core/conductor.py

@@ -136,6 +136,12 @@ class Conductor:
         obs.set_context(run_id=self.run_id, turn=self.turn)
         obs.log("run.started", run_id=self.run_id, seed=seed, goal=goal, scenario=scenario_name)
         payload: dict = {"seed": seed, "goal": goal, "scenario": scenario_name, "cast": cast}
+        # Stamp the arena contract so the run is self-describing forever (ADR-0029):
+        # the leaderboard reads competition.kind to know which runs produce winners
+        # and how to attribute them.  None (legacy/test scenarios) behaves like 'none'.
+        competition = getattr(self.scenario, "competition", None)
+        if competition is not None:
+            payload["competition"] = competition.model_dump()
         if self.session_id:
             payload["session_id"] = self.session_id
         genesis_start = Event(

src/core/config.py

@@ -16,8 +16,11 @@ to "emit JSON, validate it, run it."  See ADR-0011.
 The agent schema itself is :class:`AgentManifest` (``src/core/manifest.py``) — we
 reuse it here rather than duplicating, so the four stable contracts stay singular.
 """
+
 from __future__ import annotations
 
+from typing import Literal
+
 from pydantic import BaseModel, ConfigDict, Field, model_validator
 
 from src.core.manifest import AgentManifest
@@ -75,6 +78,60 @@ class GovernorConfig(BaseModel):
     hourly_budget_usd: float | None = None
 
 
+# ── competition ──────────────────────────────────────────────────────────────────
+
+CompetitionKind = Literal["versus", "judged", "none"]
+
+
+class CompetitionConfig(BaseModel):
+    """How (and whether) a scenario produces a winner — the arena contract (ADR-0029).
+
+    Three kinds:
+      * ``versus`` — a head-to-head between symmetric seats or named teams; the
+        winner is decided either by ground-truth code (The Steeped, Twenty Sprouts)
+        or by a judge naming a side.  Use ``teams`` for asymmetric sides and
+        ``symmetric_seats`` for "same manifest, different model" duels (Debate Duel,
+        Beat Battle) — the latter is what makes the model-leaderboard meaningful.
+      * ``judged`` — a judge in the cast names the winning *agent* via its
+        ``judge.verdict`` payload ``winner`` field (Mystery Roots, Open Table).
+      * ``none`` — collaborative or showcase; no winner, no leaderboard rows, but
+        still a full session/history (Thousand Token Wood, Oracle Grove).
+
+    The block is stamped onto ``run.started`` so a run is self-describing forever —
+    the leaderboard (W6) reads it to know which runs produce winners and how to
+    attribute them.  Team / seat members are validated against the scenario cast in
+    :meth:`WorldConfig._check_cast_references`.
+    """
+
+    model_config = ConfigDict(extra="forbid")
+
+    kind: CompetitionKind = "none"
+
+    teams: dict[str, list[str]] | None = None
+    """Named sides, e.g. ``{spy: [spy-nil], herd: [spy-cara, spy-bex, spy-ovo]}``.
+    Each member must be in the scenario cast.  ``versus`` only."""
+
+    symmetric_seats: list[str] | None = None
+    """Cast members occupying *identical* seats that differ only by model — the
+    "which model argues better" comparison.  ``versus`` only; needs ≥2 entries."""
+
+    @model_validator(mode="after")
+    def _check_kind_shape(self) -> "CompetitionConfig":
+        if self.kind == "none":
+            if self.teams or self.symmetric_seats:
+                raise ValueError("competition.kind 'none' must not declare teams or symmetric_seats")
+        elif self.kind == "versus":
+            n_teams = len(self.teams or {})
+            n_seats = len(self.symmetric_seats or [])
+            if n_teams < 2 and n_seats < 2:
+                raise ValueError(
+                    "competition.kind 'versus' needs ≥2 teams or ≥2 symmetric_seats "
+                    f"(got teams={n_teams}, symmetric_seats={n_seats})"
+                )
+        # 'judged' carries no required structural fields — the judge names the winner.
+        return self
+
+
 # ── scenario ─────────────────────────────────────────────────────────────────────
 
 
@@ -96,6 +153,12 @@ class ScenarioConfig(BaseModel):
     genesis_text: str | None = None
     governor: GovernorConfig | None = None
 
+    competition: CompetitionConfig = Field(default_factory=CompetitionConfig)
+    """The arena contract: how this scenario produces a winner (ADR-0029).  Defaulted
+    to ``kind: none`` so a scenario without a block still validates, but the authoring
+    checklist (and ``tests/test_scenario_contract.py``) requires an explicit block on
+    every shipped scenario."""
+
 
 # ── the whole world ──────────────────────────────────────────────────────────────
 
@@ -117,7 +180,8 @@ class WorldConfig(BaseModel):
 
     @model_validator(mode="after")
     def _check_cast_references(self) -> "WorldConfig":
-        defined = {a.name for a in self.agents}
+        by_name = {a.name: a for a in self.agents}
+        defined = set(by_name)
         for scenario in self.scenarios:
             missing = [name for name in scenario.cast if name not in defined]
             if missing:
@@ -125,8 +189,40 @@ class WorldConfig(BaseModel):
                     f"scenario {scenario.name!r} references undefined agents: {missing}. "
                     f"Defined agents: {sorted(defined)}"
                 )
+            self._check_competition(scenario, by_name)
         return self
 
+    @staticmethod
+    def _check_competition(scenario: ScenarioConfig, by_name: dict[str, AgentManifest]) -> None:
+        """Cross-cast rules for the competition contract (ADR-0029).
+
+        Self-contained shape rules live on :class:`CompetitionConfig`; the checks that
+        need the cast + agent registry live here: team/seat members must be in the
+        cast, and a winner-bearing kind (versus / judged) must include a judge that
+        actually emits ``judge.verdict``.  ``none`` scenarios require no judge.
+        """
+        comp = scenario.competition
+        cast = set(scenario.cast)
+        members: list[str] = list(scenario.competition.symmetric_seats or [])
+        for team in (comp.teams or {}).values():
+            members.extend(team)
+        stray = sorted(m for m in members if m not in cast)
+        if stray:
+            raise ValueError(
+                f"scenario {scenario.name!r} competition references non-cast members: {stray}. Cast: {sorted(cast)}"
+            )
+        if comp.kind in ("versus", "judged"):
+            judges = [
+                name
+                for name in scenario.cast
+                if (m := by_name.get(name)) and m.role == "judge" and "judge.verdict" in m.may_emit
+            ]
+            if not judges:
+                raise ValueError(
+                    f"scenario {scenario.name!r} competition.kind {comp.kind!r} requires a cast member "
+                    "with role 'judge' that emits 'judge.verdict' to decide the winner"
+                )
+
 
 # ── validation entrypoints (the 'configure from a prompt' surface) ───────────────
 

src/core/registry.py

@@ -253,6 +253,7 @@ class Registry:
             example_seeds=cfg.example_seeds,
             goal=cfg.goal,
             genesis_text=cfg.genesis_text,
+            competition=cfg.competition,
         )
 
     def governor_for(self, name: str) -> Governor:
@@ -292,4 +293,6 @@ def default_registry() -> Registry:
 
 # Load behaviour handlers so their @register_handler side effects run.  Imported
 # at the bottom, after register_handler is defined, so there is no import cycle.
+from src.agents import competition as _competition  # noqa: E402,F401
 from src.agents import handlers as _handlers  # noqa: E402,F401
+from src.agents import twenty_sprouts as _twenty_sprouts  # noqa: E402,F401

src/models/provider.py

@@ -91,6 +91,18 @@ _STUB_MOODS_BY_ROLE: dict[str, tuple[str, ...]] = {
     "spy-cara": ("calm", "smug", "calm"),
     "spy-ovo": ("thinking", "calm", "calm"),
     "spy-host": ("smug", "calm", "truth"),
+    # ── arena judges + competitors (ADR-0029) ──────────────────────────────────
+    "mystery-judge": ("thinking", "truth", "calm"),
+    "table-judge": ("calm", "thinking", "truth"),
+    "debater-a": ("smug", "panic", "smug", "calm"),
+    "debater-b": ("calm", "smug", "thinking", "smug"),
+    "debate-judge": ("smug", "calm", "truth"),
+    "storyteller-a": ("thinking", "calm", "smug", "truth"),
+    "storyteller-b": ("calm", "thinking", "gossip", "truth"),
+    "beat-judge": ("thinking", "calm", "truth"),
+    "secret-keeper": ("smug", "calm", "gossip", "thinking"),
+    "sprout-guesser": ("thinking", "thinking", "calm", "smug"),
+    "sprout-judge": ("calm", "truth", "thinking"),
 }
 
 # Curated private monologue per role, paired with the public ``text`` lines to make the
@@ -246,6 +258,65 @@ class DeterministicTinyModel(ModelProvider):
                 "Let me nudge us forward: what does the square need most, right now?",
                 "Lovely tension here — say more about who this is really for.",
             ],
+            # ── mystery roots / open table judges (ADR-0029) ────────────────────
+            "mystery-judge": [
+                "Verdict: the most likely truth is hypothesis-former's — the clue and the cause line up, and that ordering is what convinces me.",
+                "Verdict: I endorse hypothesis-former's reading; it is the one explanation that leaves no clue stranded.",
+                "Verdict: the evidence bends toward hypothesis-former's account — specific, testable, and unbroken by the doubt raised against it.",
+            ],
+            "table-judge": [
+                "Verdict: chat-skeptic was the most persuasive voice — the point about who tends it after dark is the one I can't argue away.",
+                "Verdict: I crown chat-curious; the question of what the village still loves in ten years reframed the whole table.",
+                "Verdict: chat-skeptic takes it — turning comfort-today against shade-we-never-sit-under was the sharpest cut of the hour.",
+            ],
+            # ── debate duel (symmetric seats, different models) ─────────────────
+            "debater-a": [
+                "The bold path is always the right one — hesitation is just defeat in a slower coat.",
+                "My opponent mistakes caution for wisdom; history rewards the daring, not the timid.",
+                "Strip away the fear and what remains is obvious: we must act, and act now.",
+            ],
+            "debater-b": [
+                "Every reckless 'yes' has a graveyard of consequences my opponent conveniently forgets.",
+                "Restraint is not weakness — it is the only argument that survives the morning after.",
+                "You call it boldness; I call it a beautifully worded mistake.",
+            ],
+            "debate-judge": [
+                "Verdict: debater-a takes it — that line about history rewarding the daring landed clean and never wavered.",
+                "Verdict: debater-b wins on the strength of 'the morning after,' the sharpest blow of the duel.",
+                "Verdict: debater-a, by a hair — the closing call to act now outpunched every rebuttal.",
+            ],
+            # ── beat battle (symmetric seats, different models) ─────────────────
+            "storyteller-a": [
+                "The lighthouse keeper unfolds a wave that has signed its name in foam and three patient question marks.",
+                "By dawn the gulls are reciting the sea's letters aloud, and one of them has started to weep with joy.",
+                "A single drop climbs the spiral stair, knocks politely, and asks to borrow the lamp for a love note.",
+            ],
+            "storyteller-b": [
+                "The tide leaves a sealed envelope of kelp on the top step, still warm from somewhere far below.",
+                "Tonight the beam writes back in light, and the whole bay holds its breath to read the reply.",
+                "The keeper discovers the sea has been practicing his own handwriting, only kinder, only braver.",
+            ],
+            "beat-judge": [
+                "Verdict: storyteller-a wins — their beats turned a single wave into a character we ached for, surprising and warm in one breath.",
+                "Verdict: storyteller-b takes it, every line opening a door the last one only hinted at, delight stacked on delight.",
+                "Verdict: storyteller-a, by a whisper — the weeping gull was the kind of impossible detail that makes a tale sing.",
+            ],
+            # ── twenty sprouts (code-dealt secret word) ──────────────────���──────
+            "secret-keeper": [
+                "Yes — you could hold it in one hand, if your hand were patient enough.",
+                "No, it was never alive, though plenty of living things have leaned on it.",
+                "Warmer now — it does belong to the wood, but not to any creature in it.",
+            ],
+            "sprout-guesser": [
+                "Is the thing you're holding something a traveller would carry on the path?",
+                "Does it make a sound, or is it silent until someone uses it?",
+                "Then is it older than the trees, or younger than this morning's dew?",
+            ],
+            "sprout-judge": [
+                "Verdict: the keeper kept its secret — the guesser circled close but never named the word.",
+                "Verdict: a clean catch — the guesser cornered the word before the questions ran dry.",
+                "Verdict: the grove falls quiet; the secret held, and the keeper smiles.",
+            ],
         }
         options = choices.get(role, ["The wood hums and waits."])
         text = options[int(digest[:2], 16) % len(options)]
@@ -301,5 +372,11 @@ class DeterministicTinyModel(ModelProvider):
         if name == "thought":
             opts = _STUB_THOUGHTS.get(role, _STUB_THOUGHT_DEFAULT)
             return opts[int(digest[6:8], 16) % len(opts)]
+        if name in ("winner", "scores"):
+            # The stub can't know the live cast, so it must NOT invent a fake winner
+            # name (it would surface as junk in the verdict).  Leave it empty: the
+            # judge's handler (JudgedCompetition / ground-truth subclasses) derives the
+            # real winner from the on-stage cast.  See ADR-0029.
+            return ""
         # Unknown extra field: a short, stable placeholder keeps the output valid.
         return f"{name}:{digest[:4]}"

src/scenarios/base.py

@@ -4,6 +4,7 @@ from collections.abc import Iterable
 from dataclasses import dataclass, field
 
 from src.agents.base import Agent
+from src.core.config import CompetitionConfig
 from src.core.events import Event
 
 
@@ -20,6 +21,10 @@ class Scenario:
     genesis_text: str | None = None
     """Template for the opening world.observed event.  '{seed}' is substituted.
     Falls back to a generic clearing line when None."""
+    competition: CompetitionConfig | None = None
+    """The arena contract (ADR-0029) — how this scenario produces a winner.  Stamped
+    onto ``run.started`` by the Conductor so a run is self-describing.  ``None`` (the
+    legacy/test default) behaves like ``kind: none``: no winner, no leaderboard rows."""
 
     def genesis(self, run_id: str, turn: int, seed: str) -> Iterable[Event]:
         template = self.genesis_text or "The first clearing forms around '{seed}'."

src/ui/fishbowl/app.py

@@ -308,7 +308,15 @@ def build_telemetry() -> None:
 _registry = default_registry()
 _tools = default_tool_registry()
 
-_PREFERRED = ["thousand-token-wood", "mystery-roots", "oracle-grove"]
+_PREFERRED = [
+    "thousand-token-wood",
+    "mystery-roots",
+    "oracle-grove",
+    "the-steeped",
+    "debate-duel",
+    "twenty-sprouts",
+    "beat-battle",
+]
 _names = [n for n in _PREFERRED if n in _registry.scenarios] + [
     n for n in sorted(_registry.scenarios) if n not in _PREFERRED
 ]

src/ui/fishbowl/assets/styles.css

@@ -778,6 +778,8 @@ footer { display: none !important; }
 @keyframes vbDrop { from { opacity: 0; transform: translateX(-50%) translateY(-20px); } to { opacity: 1; } }
 .fishbowl .verdict-banner .disp { color: var(--lime); font-size: 13px; letter-spacing: 0.14em; text-shadow: 0 0 10px var(--lime); }
 .fishbowl .vb-text { color: var(--ink); font-size: 12.5px; }
+/* Winner ribbon — the arena's "who won" chip; only present for competitive runs. */
+.fishbowl .vb-winner { font-family: var(--font-display); font-size: 12px; letter-spacing: 0.16em; text-transform: uppercase; color: var(--amber); text-shadow: 0 0 12px rgba(255,207,107,0.55); white-space: nowrap; }
 
 /* ---- poke strip ---- */
 .fishbowl .poke-strip { display: flex; align-items: center; gap: 14px; padding: 10px 20px; border-top: 1px solid var(--line-soft); background: rgba(6,20,27,0.5); flex: none; }

src/ui/fishbowl/render/meters.py

@@ -119,6 +119,18 @@ def render_verdict(vm: dict) -> str:
     text = html.escape(str(verdict.get("text", "")))
     reveal = verdict.get("reveal") or []
 
+    # Winner ribbon — rendered only when the run declared a winner (ADR-0029).  A
+    # ``none``-kind scenario (Wood, Oracle) and any legacy verdict carry no ``winner``,
+    # so this is empty and the banner is byte-identical to before.
+    ribbon = ""
+    label = verdict.get("winner_label")
+    if label:
+        correct = verdict.get("correct")
+        flair = "🏆"  # 🏆
+        if correct is False:
+            flair = "🥷"  # 🦝 — the spy slipped away (ground-truth miss)
+        ribbon = f'<div class="vb-winner disp">{flair} {html.escape(str(label))}</div>'
+
     lines = ""
     for r in reveal:
         agent = html.escape(str(r.get("agent", "")))
@@ -135,6 +147,7 @@ def render_verdict(vm: dict) -> str:
     return (
         '<div class="verdict banner">'
         '<div class="eyebrow">&#9878; Verdict</div>'
+        f"{ribbon}"
         f'<div class="disp vb-text">{text}</div>'
         f"{lines}"
         "</div>"

src/ui/fishbowl/session.py

@@ -22,7 +22,15 @@ from src.ui.fishbowl.view_model import view_model_at
 
 # Preferred display order, mirroring root app.py.  Any other scenarios dropped into
 # config/ follow in sorted order.
-_PREFERRED = ["thousand-token-wood", "mystery-roots", "oracle-grove"]
+_PREFERRED = [
+    "thousand-token-wood",
+    "mystery-roots",
+    "oracle-grove",
+    "the-steeped",
+    "debate-duel",
+    "twenty-sprouts",
+    "beat-battle",
+]
 
 
 def _ordered_names(registry: Registry) -> list[str]:
@@ -115,9 +123,13 @@ class FishbowlSession:
     def finalize(self, reason: str) -> None:
         """Close the current run with a ``run.finished`` event (idempotent-safe).
 
-        On a verdict we derive ``winner`` from the judge's ruling (best-effort: the
-        ``winner`` payload key when present) and ``winning_model`` from the run.started
-        cast map; both fall back to ``None`` when unknown."""
+        On a verdict we derive ``winner`` from the judge's ruling (the ``winner``
+        payload key) and ``winning_model`` from the run.started cast map.  The winner
+        may be a cast *agent name* (judged scenarios → maps straight to its model) or a
+        *team label* (versus scenarios, e.g. ``"herd"``).  For a team we attribute the
+        model only when the team has exactly one member; multi-member teams have no
+        single winning model (the seat, not a model, won) — the leaderboard credits the
+        team.  Everything falls back to ``None`` when unknown."""
         winner: str | None = None
         winning_model: str | None = None
         run_events = self.conductor.ledger.events_for_run(self.conductor.run_id)
@@ -127,8 +139,13 @@ class FishbowlSession:
                 winner = verdict.payload.get("winner") or None
             if winner:
                 started = next((e for e in run_events if e.kind == "run.started"), None)
-                cast = (started.payload.get("cast") or {}) if started is not None else {}
-                winning_model = (cast.get(winner) or {}).get("model_endpoint")
+                started_payload = started.payload if started is not None else {}
+                cast = started_payload.get("cast") or {}
+                teams = (started_payload.get("competition") or {}).get("teams") or {}
+                if winner in cast:
+                    winning_model = (cast.get(winner) or {}).get("model_endpoint")
+                elif winner in teams and len(teams[winner]) == 1:
+                    winning_model = (cast.get(teams[winner][0]) or {}).get("model_endpoint")
         self.conductor.finalize(reason, winner=winner, winning_model=winning_model)
 
     @property

src/ui/fishbowl/view_model.py

@@ -35,6 +35,18 @@ from src.ui.fishbowl.cast_state import derive_cast_state
 _SPEAKING_KINDS = frozenset({"agent.spoke", "agent.thought", "oracle.spoke", "judge.verdict"})
 
 
+def _winner_label(winner: str | None, teams: dict) -> str | None:
+    """Human-readable winner for the banner ribbon.
+
+    A team label reads as "Team Herd"; an agent slug reads as "Hypothesis Former".
+    Returns ``None`` when there is no winner, so ``none``-kind scenarios stay ribbon-less.
+    """
+    if not winner:
+        return None
+    pretty = winner.replace("-", " ").replace("_", " ").title()
+    return f"Team {pretty}" if winner in teams else pretty
+
+
 def _estimate_tokens_through(events: Sequence[Event]) -> int:
     """A real-text token estimate for the scrubber meter (grows as you advance)."""
     total = 0
@@ -111,13 +123,25 @@ def view_model_at(
             item["turn"] = e.turn
             feed.append(item)
 
+    # The arena contract for this run (ADR-0029), stamped on run.started — lets the
+    # verdict banner label a team win ("herd wins") apart from an agent win.
+    competition = next((e.payload.get("competition") for e in prefix if e.kind == "run.started"), None) or {}
+    teams = competition.get("teams") or {}
+
     verdict = None
     for e in prefix:
         if e.kind == "judge.verdict":
+            winner = e.payload.get("winner") or None
             verdict = {
                 "text": e.payload.get("text", ""),
                 "reveal": e.payload.get("reveal", []),
                 "agent": e.actor,
+                "winner": winner,
+                # A team win names a side; an agent win names a mind. ``correct`` (when a
+                # ground-truth judge set it) drives the win/miss flavour in the banner.
+                "winner_label": _winner_label(winner, teams),
+                "winner_kind": "team" if winner in teams else ("agent" if winner else None),
+                "correct": e.payload.get("correct"),
             }
 
     # "Round" = the live iteration count, i.e. the sim-turn at the play-head, so the

tests/test_fishbowl_lab.py

@@ -334,9 +334,10 @@ def test_collect_world_config_honours_roster_genesis_and_governor():
 
 
 def test_collect_world_config_judgeless_world_is_valid_without_judge_knobs():
-    # open-table has no judge; composing it with no judge model must still validate.
+    # oracle-grove is a judge-less tool-use showcase; composing it with no judge model
+    # must still validate. (Open Table gained a table-judge with the arena verdict.)
     registry = default_registry()
-    scenario = registry.scenarios["open-table"]
+    scenario = registry.scenarios["oracle-grove"]
     world = lab.collect_world_config(
         scenario=scenario.name,
         premise="",

tests/test_open_table.py

@@ -32,10 +32,12 @@ class TestOpenTableRegistry:
         assert "open-table" in reg.scenarios
         assert {"chat-curious", "chat-skeptic", "chat-host"} <= set(reg.agents)
 
-    def test_scenario_builds_with_three_manifest_agents(self):
+    def test_scenario_builds_with_its_manifest_cast(self):
         reg = default_registry()
         sc = reg.build_scenario("open-table")
-        assert [a.name for a in sc.agents] == ["chat-curious", "chat-skeptic", "chat-host"]
+        # The three conversational voices plus the table-judge that names the most
+        # persuasive of them at the end (the arena verdict, ADR-0029).
+        assert [a.name for a in sc.agents] == ["chat-curious", "chat-skeptic", "chat-host", "table-judge"]
         assert all(isinstance(a, ManifestAgent) for a in sc.agents)
         assert sc.goal
 

tests/test_scenario_caps.py

@@ -15,8 +15,10 @@ from src.core.registry import default_registry
 from src.ui.fishbowl.scenario_caps import scenario_ui_caps
 
 # Scenarios with / without a judge in their stock cast (per the capability matrix).
-_JUDGED = ["thousand-token-wood", "mystery-roots", "the-steeped"]
-_JUDGELESS = ["open-table", "oracle-grove"]
+# Open Table gained a table-judge with the arena verdict (ADR-0029); Oracle Grove stays
+# a judge-less tool-use showcase.
+_JUDGED = ["thousand-token-wood", "mystery-roots", "the-steeped", "open-table"]
+_JUDGELESS = ["oracle-grove"]
 
 
 @pytest.mark.parametrize("name", _JUDGELESS)

tests/test_scenario_contract.py

@@ -0,0 +1,154 @@
+"""The scenario authoring checklist, enforced.
+
+Every shipped scenario must be *arena-grade* (ADR-0029): premise + cast + governor +
+an explicit ``competition`` block + a real end condition + a structured verdict path.
+These tests load every ``config/scenarios/*.yaml`` and assert that contract — entirely
+offline, no tokens — so a new scenario can't ship half-wired.  See
+``docs/architecture/scenario-authoring.md`` for the human-readable checklist.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import pytest
+import yaml
+
+from src.core.config import WorldConfig
+from src.core.conductor import Conductor
+from src.core.governor import BudgetExceeded
+from src.core.registry import Registry
+from src.models.router import ModelRouter
+from src.tools.builtins import default_tool_registry
+
+_CONFIG = Path(__file__).resolve().parents[1] / "config"
+_SCENARIO_FILES = sorted((_CONFIG / "scenarios").glob("*.yaml"))
+_SCENARIO_IDS = [p.stem for p in _SCENARIO_FILES]
+
+# Across symmetric seats (Debate Duel, Beat Battle) only these may differ — the whole
+# point is "same seat, different model", so everything else must be byte-identical.
+_SEAT_DIFF_ALLOWED = {"name", "hue", "archetype", "model_profile", "model_endpoint"}
+
+
+@pytest.fixture(scope="module")
+def registry() -> Registry:
+    return Registry.from_dir()
+
+
+@pytest.fixture(scope="module")
+def world(registry: Registry) -> WorldConfig:
+    # Composing a WorldConfig is what exercises the cross-cast competition rules
+    # (team/seat members ⊆ cast; judged/versus need a judge) — the per-file
+    # validate_scenario path can't see the agent set.  Must not raise.
+    return WorldConfig(agents=list(registry.agents.values()), scenarios=list(registry.scenarios.values()))
+
+
+def test_all_scenarios_compose_into_a_valid_world(world: WorldConfig) -> None:
+    assert world.scenarios, "expected at least one scenario to load"
+
+
+@pytest.mark.parametrize("path", _SCENARIO_FILES, ids=_SCENARIO_IDS)
+def test_scenario_declares_an_explicit_competition_block(path: Path) -> None:
+    """The block is defaulted in the schema, but the checklist requires it spelled out."""
+    raw = yaml.safe_load(path.read_text()) or {}
+    assert "competition" in raw, f"{path.stem}: must declare an explicit `competition` block"
+    assert raw["competition"].get("kind") in ("versus", "judged", "none"), f"{path.stem}: bad competition.kind"
+
+
+@pytest.mark.parametrize("path", _SCENARIO_FILES, ids=_SCENARIO_IDS)
+def test_scenario_has_the_authoring_basics(path: Path, registry: Registry) -> None:
+    """Premise + cast + governor — the bones every scenario needs."""
+    cfg = registry.scenarios[path.stem]
+    assert cfg.goal.strip(), f"{path.stem}: needs a goal"
+    assert cfg.default_seed.strip(), f"{path.stem}: needs a default_seed"
+    assert cfg.example_seeds, f"{path.stem}: needs example_seeds"
+    assert cfg.genesis_text, f"{path.stem}: needs genesis_text"
+    assert cfg.governor is not None, f"{path.stem}: needs an explicit governor budget"
+    assert cfg.cast, f"{path.stem}: needs a cast"
+
+
+@pytest.mark.parametrize("path", _SCENARIO_FILES, ids=_SCENARIO_IDS)
+def test_competitive_scenarios_have_a_judge_that_ends_the_show(path: Path, registry: Registry) -> None:
+    """judged/versus need a judge emitting judge.verdict, on a tick that fires in-budget.
+
+    ``none`` scenarios must NOT be forced to carry a judge.
+    """
+    cfg = registry.scenarios[path.stem]
+    comp = cfg.competition
+    judges = [
+        m
+        for name in cfg.cast
+        if (m := registry.agents.get(name)) and m.role == "judge" and "judge.verdict" in m.may_emit
+    ]
+    if comp.kind == "none":
+        return  # showcase / collaborative — no winner machinery required
+    assert judges, f"{path.stem}: kind {comp.kind!r} needs a judge emitting judge.verdict"
+    # End condition: at least one judge fires within the round budget, so the verdict
+    # actually lands instead of the show grinding to a budget halt with no winner.
+    max_turns = cfg.governor.max_turns if cfg.governor else 100
+    firing = [m for m in judges if m.schedule.tick_every is not None and 0 < m.schedule.tick_every <= max_turns]
+    assert firing, f"{path.stem}: no judge has a tick_every that fires within max_turns={max_turns}"
+
+
+@pytest.mark.parametrize("path", _SCENARIO_FILES, ids=_SCENARIO_IDS)
+def test_symmetric_seats_are_identical_except_model(path: Path, registry: Registry) -> None:
+    """Debate Duel / Beat Battle: symmetric seats may differ only by name/hue/model.
+
+    This is the fairness guarantee for the model leaderboard — the seats must be
+    truly identical apart from which model fills them.
+    """
+    cfg = registry.scenarios[path.stem]
+    seats = cfg.competition.symmetric_seats or []
+    if len(seats) < 2:
+        return
+    manifests = [registry.agents[name].model_dump() for name in seats]
+    base = manifests[0]
+    for other in manifests[1:]:
+        differing = {k for k in base if base[k] != other[k]}
+        illegal = differing - _SEAT_DIFF_ALLOWED
+        assert not illegal, (
+            f"{path.stem}: symmetric seats {seats} differ in fields they may not: {sorted(illegal)} "
+            f"(only {sorted(_SEAT_DIFF_ALLOWED)} may differ)"
+        )
+
+
+def test_world_rejects_team_member_not_in_cast(registry: Registry) -> None:
+    """The cross-cast guard must actually fire on a broken competition block."""
+    good = registry.scenarios["the-steeped"].model_dump()
+    good["competition"] = {"kind": "versus", "teams": {"spy": ["nobody-here"], "herd": ["spy-cara"]}}
+    with pytest.raises(ValueError, match="non-cast members"):
+        WorldConfig(agents=list(registry.agents.values()), scenarios=[good])
+
+
+def test_world_rejects_competitive_scenario_without_a_judge(registry: Registry) -> None:
+    bad = registry.scenarios["open-table"].model_dump()
+    bad["cast"] = ["chat-curious", "chat-skeptic", "chat-host"]  # drop the table-judge
+    bad["competition"] = {"kind": "judged"}
+    with pytest.raises(ValueError, match="requires a cast member"):
+        WorldConfig(agents=list(registry.agents.values()), scenarios=[bad])
+
+
+@pytest.mark.parametrize("name", ["the-steeped", "mystery-roots", "debate-duel", "twenty-sprouts"])
+def test_competitive_scenario_names_a_real_winner_offline(name: str, registry: Registry) -> None:
+    """End-to-end on the deterministic stub: the verdict names a real player / team.
+
+    Proves the watchable-stub winner path (handler validation + fallback) without
+    spending a token, and that winner attribution is assertable on the offline path.
+    """
+    scenario = registry.build_scenario(name, router=ModelRouter(offline=True, specs={}), tools=default_tool_registry())
+    conductor = Conductor(scenario, governor=registry.governor_for(name))
+    conductor.reset(scenario.default_seed)
+    for _ in range(80):
+        try:
+            conductor.step()
+        except BudgetExceeded:
+            break
+        if any(e.kind == "judge.verdict" for e in conductor.ledger.events_for_run(conductor.run_id)):
+            break
+    events = conductor.ledger.events_for_run(conductor.run_id)
+    verdict = next((e for e in reversed(events) if e.kind == "judge.verdict"), None)
+    assert verdict is not None, f"{name}: no verdict reached offline"
+    winner = verdict.payload.get("winner")
+    cfg = registry.scenarios[name]
+    valid = set(cfg.cast) | set(cfg.competition.teams or {})
+    assert winner in valid, f"{name}: winner {winner!r} is not a cast member or team label"

tests/test_spy_game.py

@@ -11,6 +11,8 @@ offline (deterministic stub, no API key):
 
 from __future__ import annotations
 
+import re
+
 from src.core.conductor import Conductor
 from src.core.ledger_factory import make_ledger
 from src.core.registry import default_registry
@@ -62,10 +64,16 @@ def test_public_setup_never_names_the_words() -> None:
     # globally visible — every mind reads them. They must set up the game without
     # publishing the answer; the words live only in each persona + the host reveal.
     cond = _run()
+    # Match the secret words as whole words, not substrings: run.started now carries the
+    # competition block whose ``teams`` key contains the literal "TEA" inside "TEAMS"
+    # (ADR-0029) — a coincidence, not a leak. The team map names the spy *agent*, never
+    # the secret *word*, and run.started never reaches an agent's prompt (only `text`/
+    # `goal` do). What must never appear is the word itself.
+    leak = re.compile(r"\b(COFFEE|TEA)\b")
     for e in cond.ledger.events:
         if e.kind in ("run.started", "world.observed"):
             blob = str(e.payload).upper()
-            assert "COFFEE" not in blob and "TEA" not in blob
+            assert not leak.search(blob), f"secret word leaked into {e.kind}: {e.payload}"
 
 
 def test_host_verdict_unmasks_the_spy() -> None: