feat: Implement audience-only secret badge for Twenty Sprouts game

- Added `_secret_badge` function to render a hidden-word run's secret for the audience.
- Updated `_core` function to include the secret badge in the HTML output.
- Introduced `peek_next_actor_name` method in `FishbowlSession` to provide the next actor's name without advancing the run.
- Modified `ReplaySession` to handle `peek_next_actor_name` appropriately.
- Refactored `build_show` to simplify the show controls, removing unnecessary buttons and adding play/restart functionality.
- Enhanced `view_model_at` to include the secret and its holder for the audience's view.
- Added tests for the new functionality, ensuring the secret is handled correctly and does not leak into agent prompts.
- Created a new test suite for Twenty Sprouts gameplay to validate the secret handling and game mechanics.

config/agents/clue-gatherer.yaml

@@ -2,18 +2,21 @@ name: clue-gatherer
 role: worker
 persona: >
   You are a careful Clue Gatherer. Extract exactly one new, concrete clue from the
-  current scene that has not yet been named. State it plainly in one sentence.
-  Start with 'Clue:'. Do not speculate.
-  Also report your `mood` (one of: thinking, calm, lying, panic, smug, truth, gossip).
+  current scene that has not yet been named. State it plainly in one sentence so the
+  others can build on it. Start with 'Clue:'. Do not speculate.
+  Reveal your private `thought` (a hunch you keep to yourself) and your `mood`
+  (one of: thinking, calm, lying, panic, smug, truth, gossip).
 subscribes_to: []
+# Speaks the clue ALOUD (agent.spoke): the hypothesis-former reasons "based on the clues
+# gathered" and the judge weighs them, so a clue must be public, not a private thought.
 may_emit:
-  - agent.thought
+  - agent.spoke
 schedule:
   tick_every: 1
 model_profile: fast
 memory:
   window: 8
 tools: []
-output_extra_fields: [mood]
+output_extra_fields: [thought, mood]
 hue: 188
 archetype: the clue-gatherer

config/agents/devils-advocate.yaml

@@ -3,15 +3,18 @@ role: worker
 persona: >
   You are the Devil's Advocate. Challenge the most recent hypothesis with one sharp
   counter-argument or overlooked fact. Start with 'But:'. Be brief and specific.
-  Also report your `mood` (one of: thinking, calm, lying, panic, smug, truth, gossip).
+  Reveal your private `thought` (what you suspect but won't say) and your `mood`
+  (one of: thinking, calm, lying, panic, smug, truth, gossip).
 subscribes_to:
   - agent.spoke
+# Speaks the rebuttal ALOUD (agent.spoke) so the table and the judge actually hear the
+# challenge — a private thought would leave the hypothesis unchallenged on the record.
 may_emit:
-  - agent.thought
+  - agent.spoke
 model_profile: fast
 memory:
   window: 8
 tools: []
-output_extra_fields: [mood]
+output_extra_fields: [thought, mood]
 hue: 12
 archetype: the devil's advocate

config/agents/secret-keeper.yaml

@@ -3,10 +3,11 @@ 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). Do not reveal your secret word and do not ask questions.
+  guesser must tease it out with yes/no questions. You ANSWER — you never ask. Reply to
+  their MOST RECENT question truthfully and helpfully in ONE short sentence beginning with
+  "Yes" or "No" — playful, never cruel, never contradicting an earlier answer. Never write,
+  spell, or quote your word, and never end your line with a question. Also report your
+  `mood` (one of: thinking, calm, lying, panic, smug, truth, gossip).
 subscribes_to: []
 may_emit:
   - agent.spoke

config/agents/sprout-guesser.yaml

@@ -1,12 +1,14 @@
 name: sprout-guesser
 role: worker
+handler: sprout-guesser
 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).
+  answer so far — go from broad (alive? made by hands?) to specific. NEVER ask a question
+  you have already asked, and never reword an old one — always probe something new. When
+  the answers point to one word, 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

docs/adr/0023-resilient-loop-and-shared-blackboard.md

@@ -193,6 +193,58 @@ A later live run surfaced three more leaks/quality issues, each fixed at its lay
   now demands a genuinely new angle. **Live only** — the offline stub's curated catalogue is
   reproducible by design, and de-duplicating its small line set would starve demos and tests.
 
+## Follow-up: recall the whole discussion, and let judges rule on all of it
+
+The original fix shared peers' lines *within a round* (the `WHAT'S BEEN SAID` blackboard,
+the last ~6 of `projection.agent_notes`). A later audit — "are we passing good context
+about the discussion for **every** scenario?" — found two gaps that the blackboard tail
+hid:
+
+- **Memory never carried the discussion.** `agent.spoke` was not in `_GLOBALLY_VISIBLE`,
+  so an agent's recall (episodic *and* salience) contained only its own lines plus world
+  beats/verdicts — never a peer's spoken line. The blackboard's recent tail was the
+  *only* window onto the conversation.
+- **Judges ruled on a 6-line tail.** A judge fires late and has no own-events yet, so its
+  salience candidates were just the globally-visible kinds — i.e. **zero** of the
+  discussion. Measured across the shipped casts, every judge recalled `0` spoken lines and
+  saw only the last 6 via the blackboard: `open-table` 6 of 18, `the-steeped` 6 of 16
+  (missing half the clues that locate the seam), and so on.
+
+Three changes, each at the layer that owns the concern:
+
+1. **Public speech is recallable; private thought is not.** `_GLOBALLY_VISIBLE` gains
+   `agent.spoke` and `oracle.spoke` (`src/core/memory.py`). A spoken line is the shared
+   table — every mind can recall it across the whole run, not just this round. `agent.thought`
+   stays out (the mind-reader's alone), secrets ride non-`text` payload keys, and
+   `_displayable` shows `text` only — so sharing speech leaks nothing (verified: the spy
+   word and the sprout word never appear in a peer's prompt). Reflection cadence is kept on
+   a separate, narrower `_REFLECTION_VISIBLE` set so a chatty table doesn't change how often
+   an agent compacts memory.
+
+2. **The discussion block is role-aware** (`ContextBuilder`, ADR-0006's "builder owns
+   assembly"). Workers still get `WHAT'S BEEN SAID` — the recent table to react to.
+   **Judges get `THE EXCHANGE TO JUDGE` — the complete, ordered public transcript**, so a
+   ruling weighs the whole debate, not its tail. `YOUR MEMORY` is deduped against whichever
+   block is shown (it holds the *earlier* arc + world/verdict beats; a line is never
+   printed twice), and shows a short pointer when the transcript already covers it. After
+   the change every judge sees 100% of the discussion (`18/18`, `16/16`, …).
+
+3. **A mis-wired scenario, and a cascade guardrail.** Mystery Roots' `clue-gatherer` and
+   `devils-advocate` emitted private `agent.thought` — so the hypothesis-former reasoning
+   "based on the clues gathered" saw none, and the judge saw nothing. Their personas are
+   plainly public contributions, so they now `agent.spoke` (keeping a private `thought` for
+   the mind-reader). That exposed a latent footgun: an agent that both subscribes to and
+   emits `agent.spoke` re-triggered itself, cascading until the per-turn call cap tripped
+   *before the judge fired*. `Conductor._notify_subscribers` now never queues an agent for
+   its **own** event — self-reaction is never intended, and a subscriber still reacts to
+   every peer's event.
+
+Consequences: judges rule on the whole exchange; workers reason over the full arc (recent
+table + recallable earlier lines) instead of a 6-line window; Mystery Roots' convergence is
+real on the live path, not hollow; and the cast can't self-cascade a turn to death. All
+additive and offline-reproducible — `agent.thought` privacy is preserved and the
+deterministic stub path is unchanged.
+
 ## References
 
 - `src/core/context.py` — `ContextBuilder._blackboard_block`
@@ -200,5 +252,10 @@ A later live run surfaced three more leaks/quality issues, each fixed at its lay
 - `src/core/memory.py` — index degradation, `_displayable`
 - `src/core/structured.py` — reasoning strip, balanced-object scan, salvage
 - `config/scenarios/the-steeped.yaml`, `config/agents/spy-*.yaml`
+- Follow-up (recall the whole discussion): `src/core/memory.py` (`_GLOBALLY_VISIBLE` /
+  `_REFLECTION_VISIBLE`), `src/core/context.py` (role-aware discussion block + dedup),
+  `src/core/conductor.py` (`_notify_subscribers` no self-trigger), `config/agents/clue-gatherer.yaml`,
+  `config/agents/devils-advocate.yaml`; tests in `test_memory.py` / `test_context.py` /
+  `test_salience_memory.py`.
 - Builds on ADR-0006 (ContextBuilder owns prompt assembly), ADR-0016 (Instructor structured
   output), ADR-0018 (memory index is a derived lens).

docs/architecture/fishbowl-ui.md

@@ -218,6 +218,8 @@ renderer binds to**. It is a pure function of `events[:k]`. Top-level keys:
 | `voice` | `str` | the active narrator key |
 | `voice_meta` | `{name, desc}` | the resolved narrator persona |
 | `speaking_id` | `str \| None` | the head event's actor, when it just spoke |
+| `secret` | `str \| None` | audience-only ground truth for a hidden-word run (Twenty Sprouts); `None` otherwise. Rendered on the stage core, never placed in an agent prompt |
+| `secret_holder` | `str \| None` | the actor holding `secret` (e.g. `secret-keeper`), or `None` |
 | `verdict` | `{text, reveal, agent} \| None` | the latest `judge.verdict` |
 | `rounds` | `int` | `1 + count(user.injected)` |
 | `max_rounds` | `int \| None` | the round ceiling, if set |

docs/architecture/scenario-authoring.md

@@ -259,43 +259,41 @@ declarative field still comes from the YAML.
 
 `gossip` and `fact-checker` both `subscribe_to: rumor.whispered` — so the conductor
 *wakes* them when a rumour is whispered. **But subscribing does not grant reading.**
-Today an agent's memory is `own events ∪ _GLOBALLY_VISIBLE` (a hardcoded five-kind
-set in `src/core/memory.py:56`); `subscribes_to` is *not* part of it
-(`conductor.py:190` only uses it for triggering). So `gossip` is woken by a rumour it
-**cannot see** — it embellishes a void.
+An agent's memory is `own events ∪ _GLOBALLY_VISIBLE` (`src/core/memory.py`);
+`subscribes_to` is *not* part of it (the conductor only uses it for triggering). So
+`gossip`, woken by a custom `rumor.whispered` kind it cannot see, would embellish a void.
 
-You have two options:
+**If your agents just talk, there is no gotcha.** `_GLOBALLY_VISIBLE` includes the public
+speech kinds — `agent.spoke` and `oracle.spoke` — alongside `world.observed`,
+`judge.verdict`, `user.injected`, `run.started`, `agent.reflected` (ADR-0023 follow-up). So
+any agent that **speaks** is heard by every peer (recalled across the whole run) and by the
+judge (which gets the complete transcript). The gotcha bites only for a **custom,
+non-speech kind** like `rumor.whispered`. Two options:
 
-**(a) Make it collaborate today, no engine edit** — emit on a globally-visible kind.
-Change both rumour producers to `may_emit: [world.observed]` and have `gossip` /
-`fact-checker` subscribe to `world.observed`. The scene becomes the shared
-blackboard (the Thousand Token Wood trick). Cost: you lose the custom-kind clarity
-and each whisper overwrites `current_scene`.
+**(a) No engine edit** — emit the shared content on a globally-visible kind. Easiest: have
+the producers `may_emit: [agent.spoke]` (now globally visible) so the rumour is ordinary
+public speech the whole cast recalls. (Or `world.observed` for narration — the Thousand
+Token Wood trick — at the cost that each line overwrites `current_scene`.)
 
-**(b) Fix the root cause (recommended)** — make visibility declarative. This is
-finding #1 in the review; it's ~5 lines and it makes *every* future scenario's
-custom kinds collaborate:
+**(b) Make a custom kind first-class** — fold subscriptions into the visibility filter so a
+subscribed custom kind is also *readable*:
 
 ```python
-# src/core/memory.py — fold the agent's subscriptions into the visibility filter.
-# Pass `reads: frozenset[str]` (the manifest's subscribes_to) into EpisodicMemory /
-# SalienceMemory, then at each filter site (lines ~76, ~153, ~236):
+# src/core/memory.py — pass `reads: frozenset[str]` (the manifest's subscribes_to) into
+# EpisodicMemory / SalienceMemory, then at each visibility filter site:
 if e.actor == self.agent_name or e.kind in _GLOBALLY_VISIBLE or e.kind in self.reads:
 ```
 
-…and pass `reads=frozenset(self.manifest.subscribes_to)` where `base.py` constructs
-the memory layers (`_recall`, `_emit_reflection`). After that, an agent woken by a
-kind can read that kind — `gossip` builds on the rumour, the chain actually
-converges, and your custom kinds are first-class. (Optionally add a scenario-level
-`shared_kinds: [...]` so a whole cast can see a working kind without subscribing.)
+…wiring `reads=frozenset(self.manifest.subscribes_to)` where `base.py` builds the memory
+layers. Then `gossip` recalls the rumour it was woken by. (A scenario-level
+`shared_kinds: [...]` could let a whole cast see a custom kind without subscribing.)
 
-Peer content is now injected (this was review finding #2, fixed in ADR-0023):
-`ContextBuilder` surfaces `projection.agent_notes` as a **WHAT'S BEEN SAID** block
-alongside `current_scene`, the agent's own memory, and visitor lines
-(`src/core/context.py`). So within a round the cast already reasons over what its
-peers just said — the gap that made small models loop on one line. The `subscribes_to`
-visibility fix above still matters for cross-*round* recall via memory; the blackboard
-covers the live table.
+**Within a round, peers' lines are also injected directly.** `ContextBuilder` surfaces the
+recent table as a **WHAT'S BEEN SAID** block for workers, and the **complete ordered
+transcript** (`THE EXCHANGE TO JUDGE`) for judges (`src/core/context.py`, role-aware). A
+private `agent.thought` is never shared either way — it rides the mind-reader alone. So:
+make a contributor **speak** (`agent.spoke`) if peers/the judge must build on it; reserve
+`agent.thought` for genuinely private reasoning (the mind-reader UI).
 
 ### Step 7 — Rendering: free for text, custom for shapes
 
@@ -375,6 +373,34 @@ techniques:
   the same "decorate the emitted event" move `FortuneTeller` uses for `omen`. Riding the
   real ledger, the reveal scrubs and replays like any other event.
 
+### Variant: code-dealt secret, asymmetric roles (❓ Twenty Sprouts)
+
+The Steeped puts the secret in the *persona*; Twenty Sprouts shows the other end of the
+spectrum — the secret is **dealt by code** and the two seats play *different jobs*. It's
+the reference for a hidden-word game with a ground-truth answer (`src/agents/twenty_sprouts.py`):
+
+- **Code owns the word; it rides the ledger privately.** `SecretKeeper` deals a word as a
+  pure function of the seed and stamps it on every keeper event under a `secret` payload
+  key. Memory/context only ever surface an event's `text` (`_displayable`), so the word is
+  ground truth on the shared log that the guesser's prompt never sees — the same discipline
+  as the spy words, but enforced in code rather than trusted to a persona.
+- **Asymmetric handlers shape the play.** The keeper is an *answerer* that never leaks: its
+  handler hands the model the guesser's exact open question, re-asks once if the reply asks a
+  question or spells the word, and — as an absolute guarantee — scrubs the word from the
+  spoken line before it ships (a small model *will* sometimes write "a glowing ember…", so
+  code, not the prompt, is what keeps the secret). The guesser is an *asker* whose handler
+  mines the ledger into a CONFIRMED / RULED OUT / ALREADY ASKED dossier so it never repeats —
+  and it is forced to **commit a guess between questions** (when the facts converge, every few
+  questions once it knows enough, and as a hard stop near the round's end) so it actually
+  names the word instead of interrogating forever. Two handlers, one shared ledger — neither
+  agent calls the other.
+- **The audience sees the secret; the cast never does.** `view_model_at` lifts the latest
+  `secret` off the ledger into a `secret` / `secret_holder` field, which the stage core
+  renders as a dashed "🔒 only you can see" badge. It's a director's-eye peek for the human
+  watching — it is never placed in any agent's prompt (verified in
+  `tests/test_twenty_sprouts.py`). Use this field for any future hidden-information run
+  where the watcher should be in on the secret.
+
 - **Ground truth gets a code-stamped scoreboard.** The scenario declares a
   [`competition:` block](../schema/scenario-config.md#competition-who-can-win-and-who-decides)
   (`kind: versus`, ADR-0029) naming the teams — `spy: [spy-nil]` vs the herd. The
@@ -415,12 +441,15 @@ only post to the shared log, and the seam shows.
 
 ## Common pitfalls
 
-- **Subscribing ≠ reading.** The #1 surprise. An agent woken by a kind cannot read
-  that kind until the visibility fix lands (Step 6). Until then, lean on
-  globally-visible kinds for collaboration.
-- **A judge that sees nothing.** A `strong` judge emitting `judge.verdict` only sees
-  globally-visible kinds + its own. If your workers emit `agent.thought` /
-  `agent.spoke`, the judge is blind to them — same root cause as above.
+- **Subscribing ≠ reading (custom kinds only).** An agent woken by a *custom* kind
+  (e.g. `rumor.whispered`) cannot read it until you make it visible (Step 6). Public
+  speech (`agent.spoke` / `oracle.spoke`) is globally visible, so talking agents need no
+  fix.
+- **Make contributors speak, not think.** A worker that emits `agent.thought` is invisible
+  to peers and the judge (thoughts ride the mind-reader alone). If its contribution should
+  be built on or judged — a clue, a rebuttal, an argument — it must `agent.spoke`. Reserve
+  `agent.thought` for genuinely private reasoning. (This is exactly what Mystery Roots'
+  clue-gatherer / devils-advocate got wrong before the ADR-0023 follow-up.)
 - **The first `judge.verdict` ends the show.** The Fishbowl autoplay loop pauses the
   moment a verdict lands at the head (`FishbowlSession.has_verdict`). So a judge that
   `subscribes_to: [world.observed]` fires on the *genesis* event and resolves the run

src/agents/base.py

@@ -156,6 +156,9 @@ class ManifestAgent(Agent):
             all_events=recent_events,
             memory_window=mem_cfg.window,
             memory_text=memory_text,  # FIX: salience/episodic recall is now actually used
+            # A judge gets the COMPLETE exchange to rule on; workers get the recent table to
+            # react to (ContextBuilder picks the discussion block by role — ADR-0023 follow-up).
+            role=self.manifest.role,
         )
         extra = self._build_extra_prompt(projection, recent_events)
         tools_block = self._tools_block()

src/agents/twenty_sprouts.py

@@ -1,18 +1,31 @@
 """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:
+Steeped uses for the spy words.  Three handlers shape the round:
 
   * :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.
+    yes/no answers.  The keeper *answers* the guesser's most recent question and never
+    asks one back, and — crucially — never spells the word: the handler hands the model
+    the exact question to answer, re-asks once if the reply asks a question or leaks the
+    word, and scrubs the word from the spoken line as an absolute last-resort guarantee.
+  * :class:`SproutGuesser` plays the asker.  It mines the ledger for every prior
+    question and the keeper's answers, builds a running dossier (CONFIRMED / RULED
+    OUT / ALREADY ASKED), asks ONE genuinely new question that narrows the field, and
+    is forced to *commit a guess between questions* — when the facts converge, every few
+    questions once it has learned enough, and as a hard stop before the round runs out —
+    so it stops repeating itself and actually names the word instead of interrogating forever.
   * :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.
+
+The word also rides into the *view model* (``src/ui/fishbowl/view_model.py``) so the
+human audience can watch the keeper hold it — visible on stage, never in any agent's
+prompt.
 """
 
 from __future__ import annotations
@@ -20,11 +33,13 @@ from __future__ import annotations
 import hashlib
 import re
 
+from src import observability as obs
 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
+from src.core.structured import AgentOutputError
 
 # 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.
@@ -42,8 +57,21 @@ _WORDS: tuple[str, ...] = (
 )
 
 _GUESSER_NAME = "sprout-guesser"
+_KEEPER_NAME = "secret-keeper"
 _WORD = re.compile(r"[a-z]+")
 
+# A keeper's reply is an *answer*, never a question.  The cheapest reliable tell that a
+# small model slipped back into asking is a line that ends on a question mark — we reject
+# those and re-ask (see :meth:`SecretKeeper.act`).
+_ENDS_QUESTION = re.compile(r"\?\s*$")
+# Lead-word classification of a yes/no answer, used to sort the guesser's dossier into
+# CONFIRMED vs RULED OUT.  Anything else is a flavour/hint line and stays unsorted.
+_YES_LEAD = re.compile(r"^\W*(yes|yep|yeah|yup|indeed|aye|mostly|sometimes|often|usually|kind of|sort of)\b", re.I)
+_NO_LEAD = re.compile(r"^\W*(no|nope|nah|nay|never|not\b|hardly|rarely)\b", re.I)
+# A final guess looks like "My guess is: LANTERN" — recognised so the dossier lists it as
+# a committed guess (don't repeat it) rather than as another open question.
+_FINAL_GUESS = re.compile(r"\bmy guess is\b", re.I)
+
 
 def _word_for_seed(seed: str) -> str:
     """Deal a secret word as a pure function of the seed — reproducible offline."""
@@ -51,22 +79,153 @@ def _word_for_seed(seed: str) -> str:
     return _WORDS[int(digest[:8], 16) % len(_WORDS)]
 
 
+def _word_re(word: str) -> re.Pattern[str]:
+    """Whole-word matcher for a secret word and its commonest inflections.
+
+    Catches the bare word plus simple plural/verb endings (EMBER → embers, embered…) so the
+    keeper's spoken line can be checked — and, if it leaks, scrubbed — without tripping on a
+    word that merely *contains* the secret as a substring (e.g. RIVER inside "rivers" yes,
+    but not "driver")."""
+    return re.compile(rf"\b{re.escape(word)}(?:s|es|ed|ing)?\b", re.I)
+
+
+def _contains_word(text: str, word: str) -> bool:
+    """True when the keeper's line spells the secret word out (any case/inflection)."""
+    return bool(word) and bool(_word_re(word).search(text or ""))
+
+
+def _redact_word(text: str, word: str) -> str:
+    """Mask any spelled-out secret word so it can never reach the stage.
+
+    The guarantee of last resort: even if the model ignores every instruction and writes the
+    word, this replaces it with the neutral noun ``thing`` before the line is shown, so the
+    audience-facing feed (and the guesser's blackboard) never carry the answer — and the
+    masked sentence still reads ("a glowing thing can emerge"). A no-op when the word is
+    absent, which is always the case on the deterministic offline path."""
+    return re.sub(r"\s{2,}", " ", _word_re(word).sub("thing", text or "")).strip()
+
+
+def _answer_violation(text: str, word: str) -> str | None:
+    """Why a keeper reply is unacceptable, for a corrective re-ask — or ``None`` if it's fine.
+
+    Two ways a keeper stops being an *answerer*: it spells the secret word, or it asks a
+    question instead of answering one."""
+    if _contains_word(text, word):
+        return "you spelled out the secret word — never write or hint its letters"
+    if _ENDS_QUESTION.search(text or ""):
+        return "you asked a question instead of answering — you must only answer"
+    return None
+
+
+def _trim(text: str, limit: int = 120) -> str:
+    """One-line, length-bounded rendering of a ledger line for a dossier bullet."""
+    line = " ".join(str(text).split())
+    return line if len(line) <= limit else line[: limit - 1].rstrip() + "…"
+
+
+def _classify_answer(text: str) -> str:
+    """Sort a keeper answer into ``"yes"`` / ``"no"`` / ``"hint"`` by its lead word."""
+    if _YES_LEAD.match(text or ""):
+        return "yes"
+    if _NO_LEAD.match(text or ""):
+        return "no"
+    return "hint"
+
+
+def _qa_history(recent_events: tuple[Event, ...]) -> list[tuple[str, str | None]]:
+    """Pair each guesser line with the keeper answer that followed it, in order.
+
+    Walks the run's spoken events once: a guesser ``agent.spoke`` opens a new
+    ``(question, None)`` pair; the next keeper ``agent.spoke`` fills its answer.  The
+    result is the spine of the guesser's dossier and of the keeper's "what was just
+    asked" — both read straight off the shared ledger, no side state.
+    """
+    pairs: list[tuple[str, str | None]] = []
+    for e in recent_events:
+        if e.kind != "agent.spoke":
+            continue
+        text = str(e.payload.get("text", "")).strip()
+        if not text:
+            continue
+        if e.actor == _GUESSER_NAME:
+            pairs.append((text, None))
+        elif e.actor == _KEEPER_NAME and pairs and pairs[-1][1] is None:
+            q, _ = pairs[-1]
+            pairs[-1] = (q, text)
+    return pairs
+
+
+def _questions_since_guess(pairs: list[tuple[str, str | None]]) -> int:
+    """How many questions the guesser has asked since its last committed guess.
+
+    Counts guesser lines from the end back to the most recent ``My guess is: …`` (or the
+    start if it has never guessed). Drives the "guess at least every N questions" cadence so
+    the guesser commits between questions instead of interrogating forever."""
+    count = 0
+    for q, _ in reversed(pairs):
+        if _FINAL_GUESS.search(q):
+            break
+        count += 1
+    return count
+
+
+def _bullets(lines: list[str]) -> str:
+    return "\n".join(f"- {_trim(line)}" for line in lines)
+
+
 @register_handler("secret-keeper")
 class SecretKeeper(ManifestAgent):
-    """Holds the dealt word and answers the guesser, never spelling it aloud.
+    """Holds the dealt word and answers the guesser, never spelling it aloud, never asking.
 
     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.
+    key — visible to the judge and the UI (which read 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.
+
+    Three disciplines keep the keeper an *answerer* that never leaks (the prior version
+    both drifted into asking the guesser's questions back *and* spelled the word aloud):
+
+      * the prompt names the guesser's most recent question and demands a truthful
+        Yes/No answer about the held word;
+      * a reply that asks a question or spells the word is re-asked once (with the reason
+        fed back), then on a still-asking reply the turn is skipped; and
+      * as an absolute guarantee, the spoken line is scrubbed of the word before it ships,
+        so the secret can never reach the stage even if the model ignores every rule.
     """
 
     def _build_extra_prompt(self, projection: StageProjection, recent_events: tuple[Event, ...]) -> str:
         word = _word_for_seed(projection.seed)
+        pairs = _qa_history(recent_events)
+        # The guesser's most recent *open* question (the one awaiting this answer).
+        question = next((q for q, a in reversed(pairs) if a is None), "")
+        already = [a for _, a in pairs if a]
+        guard = (
+            "\n\nSTRICT RULES: You ANSWER, you never ask. Begin with 'Yes' or 'No' (then one short, "
+            "truthful, playful clause). Answer ONLY about your secret word, and answer the SAME way "
+            "every time about the same property — never contradict an earlier answer. Do NOT end your "
+            f"line with a question mark. NEVER write the word '{word}' or any form of it — describe it, "
+            "never name it; that instantly loses the game."
+        )
+        # On a corrective re-ask (set by ``act`` after a rejected reply), tell the model
+        # exactly what it did wrong so the retry actually fixes it.
+        reason = getattr(self, "_retry_reason", None)
+        correction = f"\n\nCORRECTION: your previous reply was rejected because {reason}. Try again." if reason else ""
+        if not question:
+            return (
+                f"YOUR SECRET WORD (never write, spell, or quote it — only answer about it): {word}\n"
+                "The guesser has not asked yet. In ONE short sentence, invite them to begin asking "
+                "yes/no questions. Do not reveal anything about the word yet." + guard + correction
+            )
+        consistency = (
+            ("\n\nYour earlier answers (stay consistent with these):\n" + _bullets(already[-6:])) if already else ""
+        )
         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."
+            f'The guesser just asked: "{_trim(question)}"\n'
+            "Answer THAT question about your word, truthfully, in ONE short sentence."
+            + consistency
+            + guard
+            + correction
         )
 
     def act(
@@ -76,13 +235,125 @@ class SecretKeeper(ManifestAgent):
         projection: StageProjection,
         recent_events: tuple[Event, ...],
     ) -> Event:
+        offline = bool(getattr(self.router, "offline", False))
+        word = _word_for_seed(projection.seed)
         event = super().act(run_id, turn, projection, recent_events)
+        usage_total = dict(self.last_usage)
+        text = str(event.payload.get("text", ""))
+
+        # Live quality pass: if the keeper asked a question or spelled the word, re-ask once
+        # with the reason fed back. Offline lines are curated, leak-free answers, so this
+        # never fires there — the deterministic path is identical. The retry's tokens are
+        # summed so the governor still meters both calls (mirrors base ``_verify_verdict``).
+        if not offline and _answer_violation(text, word):
+            self._retry_reason = _answer_violation(text, word)
+            try:
+                retry = super().act(run_id, turn, projection, recent_events)
+            finally:
+                self._retry_reason = None
+            usage_total = self._sum_usage(usage_total, dict(self.last_usage))
+            self.last_usage = usage_total
+            event, text = retry, str(retry.payload.get("text", ""))
+
+        # Absolute guarantee: scrub any spelled-out word before it ships. A no-op offline
+        # and on a clean reply; the safety net when the model leaks anyway (as it did with
+        # "a glowing ember…"). Logged so a persistent leak is visible in the run.
+        scrubbed = _redact_word(text, word)
+        if scrubbed != text:
+            obs.log("twenty_sprouts.redacted_keeper_leak", agent=self.name, turn=turn)
+            text = scrubbed
+            event.payload["text"] = text
+
+        # The keeper must answer, not ask: a reply still ending in a question after the
+        # re-ask is skipped (live only) rather than shown asking. Redaction above can't fix
+        # an asked question, so this is the final gate.
+        if not offline and _ENDS_QUESTION.search(text):
+            raise AgentOutputError(f"{self.name}: keeper asked a question instead of answering — skipped")
+
         # 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)
+        # guesser's prompt — the judge reads it back at the reckoning, the UI shows it
+        # to the human audience only.
+        event.payload["secret"] = word
         return event
 
 
+@register_handler("sprout-guesser")
+class SproutGuesser(ManifestAgent):
+    """Asks the questions — building on the ledger so it never repeats and always narrows.
+
+    The base agent already sees the blackboard, but a small model left to itself loops on
+    near-identical questions and forgets what it learned (the transcript that prompted this
+    handler).  So we hand it an explicit dossier mined from the run's own Q&A:
+
+      * CONFIRMED — questions the keeper answered *yes* (the shape of the word so far);
+      * RULED OUT — questions answered *no* (dead ends to avoid);
+      * ALREADY ASKED — every prior question, which it is told never to repeat or reword.
+
+    With the facts in front of it the model is asked for ONE new splitting question — but
+    it must also *commit guesses between questions* rather than interrogating forever (the
+    failure the second transcript showed: twenty questions, never a guess). So the handler
+    forces a committed ``My guess is: <word>`` when the facts converge, periodically once
+    it has learned enough, and as a hard stop before the round runs out. A wrong guess just
+    rolls into the ALREADY GUESSED list and play continues.
+    """
+
+    _COMMIT_AFTER = 12  # hard stop: this many questions in, stop asking and commit
+    _GUESS_WHEN_CONFIRMED = 5  # this many YES facts ⇒ you almost certainly know it — guess now
+    _MIN_FACTS_TO_GUESS = 3  # never force a guess before the word has real shape
+    _GUESS_EVERY = 4  # once warmed up, take a guess at least every N questions
+
+    def _build_extra_prompt(self, projection: StageProjection, recent_events: tuple[Event, ...]) -> str:
+        pairs = _qa_history(recent_events)
+        if not pairs:
+            return (
+                "You are opening a game of twenty questions. Ask ONE broad yes/no question that "
+                "splits the space of possible woodland words roughly in half (e.g. alive vs. made, "
+                "natural vs. crafted). One short sentence, ending in a question mark."
+            )
+        confirmed = [q for q, a in pairs if a and _classify_answer(a) == "yes"]
+        ruled_out = [q for q, a in pairs if a and _classify_answer(a) == "no"]
+        asked = [q for q, _ in pairs if not _FINAL_GUESS.search(q)]
+        guessed = [q for q, _ in pairs if _FINAL_GUESS.search(q)]
+
+        blocks: list[str] = ["YOUR DOSSIER on the keeper's secret word (read it before you ask):"]
+        if confirmed:
+            blocks.append("CONFIRMED — the keeper said YES to these (build on them):\n" + _bullets(confirmed))
+        if ruled_out:
+            blocks.append("RULED OUT — the keeper said NO to these (don't go back here):\n" + _bullets(ruled_out))
+        if asked:
+            blocks.append("ALREADY ASKED — never ask any of these again, or a reworded version:\n" + _bullets(asked))
+        if guessed:
+            blocks.append("ALREADY GUESSED (wrong) — never repeat these guesses:\n" + _bullets(guessed))
+
+        if self._should_commit(asked, confirmed, pairs):
+            differ = " Your earlier guess was wrong, so pick a DIFFERENT word." if guessed else ""
+            task = (
+                "TIME TO GUESS. Do NOT ask a question this turn. Read the CONFIRMED facts and name the "
+                'single word they point to, written EXACTLY as: "My guess is: <word>."' + differ
+            )
+        else:
+            task = (
+                "Ask ONE genuinely NEW yes/no question that builds on the CONFIRMED facts and rules out "
+                "more of the field. Go broad → specific. One short sentence ending in a question mark. "
+                "Do NOT repeat or reword anything ALREADY ASKED."
+            )
+        return "\n\n".join(blocks) + "\n\n" + task
+
+    def _should_commit(self, asked: list[str], confirmed: list[str], pairs: list[tuple[str, str | None]]) -> bool:
+        """Decide whether this turn must be a guess rather than another question.
+
+        Commit when any of: the round is nearly spent (``_COMMIT_AFTER`` questions), the word
+        has plainly taken shape (``_GUESS_WHEN_CONFIRMED`` confirmed facts), or we have learned
+        enough and have gone too long without guessing (``_GUESS_EVERY`` questions since the
+        last guess) — the last is what *interleaves* guesses so the guesser stops interrogating
+        forever."""
+        if len(asked) >= self._COMMIT_AFTER:
+            return True
+        if len(confirmed) >= self._GUESS_WHEN_CONFIRMED:
+            return True
+        return len(confirmed) >= self._MIN_FACTS_TO_GUESS and _questions_since_guess(pairs) >= self._GUESS_EVERY
+
+
 @register_handler("sprout-judge")
 class SproutJudge(JudgedCompetition):
     """Decides Twenty Sprouts in code: did the guesser's last line contain the word?

src/core/conductor.py

@@ -300,6 +300,29 @@ class Conductor:
         self._maybe_snapshot()
         return True
 
+    def peek_next_actor_name(self) -> str | None:
+        """Best-effort name of the agent the next :meth:`step_one` will run.
+
+        A pure read (it never mutates the queue or the turn) used by the UI to show a
+        "who's thinking…" hint while a model call is in flight.  Mirrors ``step_one``'s
+        own pull order: an already-queued agent first, then a subscription-triggered
+        one, then — when the queue is empty and the next call would open a fresh turn —
+        the first tick-scheduled agent for ``turn + 1``.  Returns ``None`` when nothing
+        is queued and no agent ticks on the next turn (the show is effectively idle)."""
+        if self._pending:
+            return getattr(self._pending[0], "name", None)
+        if self._trigger_queue:
+            return getattr(self._trigger_queue[0][0], "name", None)
+        next_turn = self.turn + 1
+        for agent in self.scenario.agents:
+            manifest = getattr(agent, "manifest", None)
+            if manifest is None:
+                continue
+            tick_every = manifest.schedule.tick_every
+            if tick_every is not None and (tick_every == 0 or next_turn % tick_every == 0):
+                return getattr(agent, "name", None)
+        return None
+
     def force_verdict(self) -> Event | None:
         """Cut the show short and have the judge rule *now*, on the whole run.
 
@@ -441,10 +464,17 @@ class Conductor:
         return appended
 
     def _notify_subscribers(self, event: Event) -> None:
-        """Queue agents that subscribe to this event kind."""
+        """Queue agents that subscribe to this event kind — but never an agent for its OWN
+        event.
+
+        An agent that both subscribes to and emits a kind (e.g. the devil's-advocate
+        subscribes to ``agent.spoke`` and now speaks one) would otherwise re-trigger itself
+        on its own line, cascading until the per-turn call cap trips — starving later
+        agents (the judge) of their turn. Self-reaction is never intended, so we skip it;
+        a subscriber still reacts to every *peer's* event."""
         for agent in self.scenario.agents:
             manifest = getattr(agent, "manifest", None)
-            if manifest and event.kind in manifest.subscribes_to:
+            if manifest and event.kind in manifest.subscribes_to and event.actor != getattr(agent, "name", None):
                 self._trigger_queue.append((agent, event))
 
     def _tick_scheduled_agents(self) -> list["Agent"]:

src/core/context.py

@@ -5,8 +5,12 @@ Layering order (innermost → outermost, smallest → largest prompt budget):
   1. IDENTITY        — pinned persona (permanent cost, never drops)
   2. SHARED GOAL     — the scenario objective (only when set; from the projection)
   3. CURRENT SCENE   — world state from the stage projection
-  4. WHAT'S BEEN SAID— the shared blackboard: peers' recent lines (ADR-0023)
-  5. YOUR MEMORY     — episodic recall from the ledger (windowed or salience-ranked)
+  4. THE DISCUSSION  — role-aware (ADR-0023 + follow-up):
+                         · workers see WHAT'S BEEN SAID — the recent table to react to;
+                         · judges see THE EXCHANGE TO JUDGE — the *complete* ordered
+                           transcript, so a ruling weighs the whole discussion, not its tail.
+  5. YOUR MEMORY     — episodic/salience recall (the earlier arc + world beats/verdicts;
+                         deduped against block 4 so no line is printed twice)
   6. VISITOR         — recent user injections (always salient)
   [7. EXTRA]         — injected by ManifestAgent subclass for scenario-specific context
   [8. OUTPUT FORMAT] — JSON constraint block (appended by structured.py)
@@ -22,10 +26,25 @@ from src.core.events import Event
 from src.core.memory import EpisodicMemory
 from src.core.projections import StageProjection
 
+# Public speech — the lines that constitute "the discussion" everyone can hear. A private
+# ``agent.thought`` is deliberately excluded: it rides only its own event (the mind-reader),
+# so a judge rules on what was *said*, and peers never read another mind.
+_PUBLIC_SPEECH_KINDS = frozenset({"agent.spoke", "oracle.spoke"})
+
 
 class ContextBuilder:
     """Assembles a compact, role-scoped prompt for a single agent turn."""
 
+    # How many recent peer lines a *worker's* "react now" blackboard shows. The longer arc
+    # of the discussion is carried by YOUR MEMORY (recall now includes peers' spoken lines —
+    # ADR-0023 follow-up), so this stays small: it's the immediate table to react to.
+    _BLACKBOARD_WINDOW = 8
+
+    # How many lines a *judge's* full transcript shows (most recent, if it overflows). Judges
+    # fire infrequently and must weigh the whole exchange, so this is generous — it comfortably
+    # covers every shipped scenario's discussion length.
+    _TRANSCRIPT_LIMIT = 80
+
     def build(
         self,
         *,
@@ -35,6 +54,7 @@ class ContextBuilder:
         all_events: tuple[Event, ...],
         memory_window: int = 8,
         memory_text: str | None = None,
+        role: str = "worker",
     ) -> str:
         """Build a prompt string from layered context.
 
@@ -42,70 +62,147 @@ class ContextBuilder:
             agent_name:    Used to filter visible events for memory.
             persona:       Fixed identity text (IDENTITY block).
             projection:    Current world-state view.
-            all_events:    Full ledger tail for memory retrieval.
+            all_events:    Full ledger tail (this run) — drives memory recall AND a judge's
+                           full transcript.
             memory_window: How many events to include (for EpisodicMemory).
             memory_text:   Pre-computed memory string (pass to override the default
                            EpisodicMemory computation, e.g. when using SalienceMemory).
+            role:          The agent's role. ``"judge"`` gets the complete exchange to rule
+                           on; everyone else gets the recent blackboard to react to.
         """
         if memory_text is None:
             memory_text = EpisodicMemory(agent_name, max_recent=memory_window).format_for_prompt(all_events)
 
-        # The latest world line is shown in full under CURRENT SCENE; echoing it again as
-        # the tail of YOUR MEMORY wastes a small model's context and primes it to repeat.
-        memory_text = self._dedup_memory(memory_text, projection.current_scene)
+        # Block 4 is role-aware: a judge needs the WHOLE exchange to rule fairly; a worker
+        # needs the recent table to react to. Both return the set of discussion texts they
+        # already show, so YOUR MEMORY can drop those exact lines — the union an agent sees
+        # is unchanged, we just never print a line twice (blackboard/transcript hold the
+        # discussion, memory holds the earlier arc + world beats/verdicts).
+        discussion_block, shown_texts = self._discussion(role, projection, all_events)
+        shown_texts = set(shown_texts) | {(projection.current_scene or "").strip()}
+        memory_text = self._dedup_memory(memory_text, shown_texts)
 
         visitor_lines = "\n".join(f"- {a}" for a in projection.user_artifacts[-3:]) or "(quiet)"
 
         goal_block = f"SHARED GOAL\n{projection.goal}\n\n" if projection.goal else ""
 
+        # When dedup leaves nothing (common for a judge whose recall is fully covered by the
+        # transcript above), show a short pointer instead of a blank or a duplicate block.
+        memory_block = (
+            f"YOUR MEMORY (recent events you witnessed)\n{memory_text}"
+            if memory_text.strip()
+            else "YOUR MEMORY\n(nothing beyond the exchange above)"
+        )
+
         prompt = (
             f"IDENTITY\n{persona}\n\n"
             f"{goal_block}"
             f"CURRENT SCENE\n{projection.current_scene}\n\n"
-            f"{self._blackboard_block(projection.agent_notes)}"
-            f"YOUR MEMORY (recent events you witnessed)\n{memory_text}\n\n"
+            f"{discussion_block}"
+            f"{memory_block}\n\n"
             f"VISITOR DISTURBANCES\n{visitor_lines}"
         )
         # Structure + size of the assembled context (the full prompt is logged by the
         # agent layer as ``agent.prompt``; here we record which sections were present).
-        sections = ["IDENTITY", "CURRENT SCENE", "BLACKBOARD", "MEMORY", "VISITOR"]
+        discussion_section = "TRANSCRIPT" if role == "judge" else "BLACKBOARD"
+        sections = ["IDENTITY", "CURRENT SCENE", discussion_section, "MEMORY", "VISITOR"]
         if goal_block:
             sections.insert(1, "SHARED GOAL")
         obs.log(
             "context.build",
             level="debug",
             agent=agent_name,
+            role=role,
             sections=sections,
             prompt_chars=len(prompt),
             memory_chars=len(memory_text),
         )
         return prompt
 
+    # ── the discussion block (role-aware) ─────────────────────────────────────────
+
+    def _discussion(
+        self, role: str, projection: StageProjection, all_events: tuple[Event, ...]
+    ) -> tuple[str, set[str]]:
+        """The discussion block + the set of texts it shows (for memory dedup).
+
+        Judges get the full ordered transcript (rule on everything); everyone else gets the
+        recent blackboard (react to the table)."""
+        if role == "judge":
+            lines = self._public_lines(all_events)
+            return self._transcript_block(lines), {self._note_text(line) for line in lines}
+        shown_notes = [n for n in projection.agent_notes if n][-self._BLACKBOARD_WINDOW :]
+        return self._blackboard_block(shown_notes), {self._note_text(n) for n in shown_notes}
+
+    @staticmethod
+    def _public_lines(all_events: tuple[Event, ...]) -> list[str]:
+        """Every public spoken line in the run, oldest → newest, as ``"actor: text"``.
+
+        This is the discussion a judge rules on. Private thoughts are excluded (see
+        ``_PUBLIC_SPEECH_KINDS``); a line with no text is skipped."""
+        out: list[str] = []
+        for e in all_events:
+            if e.kind in _PUBLIC_SPEECH_KINDS:
+                text = str(e.payload.get("text", "")).strip()
+                if text:
+                    out.append(f"{e.actor}: {text}")
+        return out
+
+    @classmethod
+    def _transcript_block(cls, lines: list[str]) -> str:
+        """A judge's view: the complete exchange, in order, with a 'weigh all of it' nudge."""
+        if not lines:
+            return "THE EXCHANGE TO JUDGE\n(no one has spoken yet)\n\n"
+        shown = lines[-cls._TRANSCRIPT_LIMIT :]
+        head = (
+            f"(showing the last {cls._TRANSCRIPT_LIMIT} of {len(lines)} lines)\n"
+            if len(lines) > cls._TRANSCRIPT_LIMIT
+            else ""
+        )
+        body = "\n".join(f"- {line}" for line in shown)
+        return (
+            "THE EXCHANGE TO JUDGE (every spoken line, in order — weigh ALL of it, not just the last few):\n"
+            f"{head}{body}\n\n"
+        )
+
+    @staticmethod
+    def _note_text(note: str) -> str:
+        """The spoken text of a discussion line, stripped of its ``actor:`` prefix.
+
+        Lines read ``"actor: text"``, ``"actor [kind]: text"``, or ``"💭 actor believes:
+        text"`` — all carry the content after the first ``": "``. Used to match the same
+        line where it appears in a memory entry (``[turn NNN][kind] text``)."""
+        _, _, text = note.partition(": ")
+        return (text or note).strip()
+
     @staticmethod
-    def _dedup_memory(memory_text: str, current_scene: str) -> str:
-        """Drop memory lines that merely repeat the CURRENT SCENE.
-
-        Memory lines are ``[turn NNN][kind] <text>``; the most-recent ``world.observed``
-        is also the ``current_scene``, so its line appears in both blocks.  We drop any
-        memory line that ends with the current scene's text, keeping the rest of the
-        recall intact (and leaving the block untouched if that would empty it)."""
-        scene = (current_scene or "").strip()
-        if not scene:
+    def _dedup_memory(memory_text: str, shown_texts: set[str]) -> str:
+        """Drop memory lines already shown in the discussion block or CURRENT SCENE.
+
+        Memory lines are ``[turn NNN][kind] <text>``. The most-recent ``world.observed`` is
+        also the CURRENT SCENE, and (now that peers' spoken lines are recallable) the
+        discussion lines also appear in block 4. We drop any memory line ending with one of
+        those already-shown texts — so the agent reads each line once: the blackboard/
+        transcript holds the discussion, memory holds the earlier arc + world/verdict beats.
+        Returns the empty string if every line was a duplicate — the caller then shows a
+        short pointer rather than a blank or a re-print of the discussion."""
+        shown = {s for s in shown_texts if s}
+        if not shown:
             return memory_text
-        kept = [line for line in memory_text.splitlines() if not line.rstrip().endswith(scene)]
-        return "\n".join(kept) if kept else memory_text
+        kept = [line for line in memory_text.splitlines() if not any(line.rstrip().endswith(s) for s in shown)]
+        return "\n".join(kept)
 
     @staticmethod
-    def _blackboard_block(agent_notes: list[str], window: int = 6) -> str:
+    def _blackboard_block(shown_notes: list[str]) -> str:
         """The shared blackboard: what the rest of the cast just said or did.
 
         Without this an agent sees only the world text and its own past lines, so a
         small model loops on the same clue and never reacts to anyone (the "shared
-        blackboard isn't shared" gap — ADR-0023).  ``agent_notes`` already carries
-        only the public ``text`` of each peer event (never their private thought),
-        so surfacing it shares the conversation without leaking minds.
+        blackboard isn't shared" gap — ADR-0023).  ``shown_notes`` is the already-sliced
+        recent tail and carries only the public ``text`` of each peer event (never their
+        private thought), so surfacing it shares the conversation without leaking minds.
         """
-        notes = [n for n in agent_notes if n][-window:]
+        notes = [n for n in shown_notes if n]
         if not notes:
             return "WHAT'S BEEN SAID\n(you go first — set the tone)\n\n"
         lines = "\n".join(f"- {n}" for n in notes)

src/core/memory.py

@@ -2,8 +2,10 @@
 
 Memory architecture (three layers):
 
-  1. EpisodicMemory — filtered view over the ledger; agents see only events
-     they witnessed.  This is the simplest and always-on layer.
+  1. EpisodicMemory — filtered view over the ledger; an agent sees its own events
+     plus the public record everyone witnesses: world beats, verdicts, visitor
+     pokes, reflections, and peers' spoken lines (``agent.spoke`` / ``oracle.spoke``).
+     Private ``agent.thought`` stays out — minds aren't read by peers.  Always-on.
 
   2. SalienceMemory — ranks visible events by a composite score:
        salience(e) = w_rel·relevance(e,query) + w_rec·recency(e,turn) + w_imp·importance(e.kind)
@@ -61,6 +63,7 @@ _KIND_IMPORTANCE: dict[str, float] = {
     "run.started": 0.3,
     "world.observed": 0.7,
     "agent.spoke": 0.5,
+    "oracle.spoke": 0.5,  # a custom public-speech kind (oracle-grove); ranks like agent.spoke
     "agent.thought": 0.4,
     "agent.reflected": 0.85,  # reflections are high-value compact memories
     "judge.verdict": 0.9,
@@ -70,7 +73,33 @@ _KIND_IMPORTANCE: dict[str, float] = {
     "verdict.final": 1.0,
 }
 
+# What an agent can RECALL of others: globally-visible kinds (plus its own events).
+# The split is public vs. private SPEECH. A spoken line (``agent.spoke`` / the custom
+# ``oracle.spoke``) is table talk — every mind hears it, so it must be recallable across
+# the whole run, not just this round's blackboard tail. Without this a judge that fires
+# late (it has no own events yet) recalls *none* of the discussion it must rule on, and a
+# worker forgets every peer line older than the 6-line blackboard window. A private
+# ``agent.thought`` is deliberately NOT here: it rides only its own event payload (the
+# mind-reader UI), so peers never read another mind's thinking. Secrets ride non-``text``
+# payload keys and ``_displayable`` shows ``text`` only, so sharing speech leaks nothing.
 _GLOBALLY_VISIBLE: frozenset[str] = frozenset(
+    {
+        "world.observed",
+        "judge.verdict",
+        "user.injected",
+        "run.started",
+        "agent.reflected",
+        "agent.spoke",
+        "oracle.spoke",
+    }
+)
+
+# What COUNTS toward an agent's reflection cadence (ReflectionTracker). Deliberately the
+# narrower set *without* peer speech: reflection compacts "what I have been through" —
+# my own arc plus the world beats — so its rhythm shouldn't lurch just because the table
+# got chatty this round. Keeping it separate from _GLOBALLY_VISIBLE leaves reflection
+# timing exactly as tuned while recall gains the shared discussion.
+_REFLECTION_VISIBLE: frozenset[str] = frozenset(
     {"world.observed", "judge.verdict", "user.injected", "run.started", "agent.reflected"}
 )
 
@@ -81,8 +110,10 @@ _GLOBALLY_VISIBLE: frozenset[str] = frozenset(
 class EpisodicMemory:
     """Per-agent filtered view over the ledger — the always-on memory layer.
 
-    An agent sees its own events plus globally-visible event kinds.
-    The window is capped at max_recent to stay within small-model context budgets.
+    An agent sees its own events plus globally-visible kinds (the public record —
+    world beats, verdicts, visitor pokes, reflections, and peers' *spoken* lines;
+    never peers' private thoughts).  The window is capped at max_recent to stay
+    within small-model context budgets.
     """
 
     agent_name: str
@@ -291,7 +322,7 @@ class ReflectionTracker:
 
     def observe(self, events: tuple[Event, ...]) -> bool:
         """Return True when a reflection should be emitted this turn."""
-        visible_count = sum(1 for e in events if e.actor == self.agent_name or e.kind in _GLOBALLY_VISIBLE)
+        visible_count = sum(1 for e in events if e.actor == self.agent_name or e.kind in _REFLECTION_VISIBLE)
         due = visible_count > 0 and visible_count != self._seen_count and visible_count % self.threshold == 0
         self._seen_count = visible_count
         return due

src/ui/fishbowl/app.py

@@ -18,6 +18,7 @@ from __future__ import annotations
 
 import os
 import socket
+import uuid
 
 # Import `spaces` before anything that could initialise CUDA: on ZeroGPU the package
 # raises if torch's CUDA is touched first (our torch is lazy via mem0, so this stays
@@ -379,14 +380,34 @@ def _fishbowl(inner: str, *, role: str) -> str:
     return f'<div class="fishbowl {role}">{inner}</div>'
 
 
+def _thinking_strip(label: str) -> str:
+    """A broadcast-style "lower third" overlaid on the stage while a model call runs.
+
+    LLM calls take seconds; without a cue the theater reads as frozen.  This strip names
+    who we're waiting on ("scene-whisperer is thinking…") with a pulsing orb + animated
+    ellipsis, anchored to the *always-visible* stage so it never hides under the feed's
+    scroll.  Pure string; rendered only while a generation is in flight."""
+    import html as _html
+
+    text = _html.escape(label or "the cast is thinking")
+    return (
+        '<div class="thinking-strip" role="status" aria-live="polite">'
+        '<span class="ts-orb"></span>'
+        f'<span class="ts-label">{text}</span>'
+        '<span class="ts-dots"><i></i><i></i><i></i></span>'
+        "</div>"
+    )
+
+
 def render_show_html(
-    vm: dict, *, layout: str = "constellation", mind_reader: bool = False
+    vm: dict, *, layout: str = "constellation", mind_reader: bool = False, thinking: str | None = None
 ) -> tuple[str, str, str, str]:
     """Compose the Show's four HTML panes from a view-model snapshot.
 
     Returns ``(stage, feed, meters, verdict)``.  The stage honours the layout radio:
     *constellation* (MindCards), *split* (omniscient table), or *feed* (feed-only).  Each
-    pane is wrapped in a ``.fishbowl`` scope root so the theater stylesheet applies."""
+    pane is wrapped in a ``.fishbowl`` scope root so the theater stylesheet applies.  When
+    ``thinking`` is set, a "who's thinking…" strip is overlaid on the stage pane."""
     cards_html_by_id: dict[str, str] = {}
     for card in vm.get("cast", []):
         cards_html_by_id[card.get("id", card.get("name", ""))] = render_mindcard(card, mind_reader=mind_reader)
@@ -398,6 +419,11 @@ def render_show_html(
     else:  # constellation (default)
         stage = render_constellation(vm, cards_html_by_id)
 
+    if thinking:
+        # Prepend so the badge is the FIRST child of the stage pane: with position:sticky
+        # it then pins to the top and stays in view without any scrolling.
+        stage = _thinking_strip(thinking) + stage
+
     feed = render_feed(vm, mind_reader=mind_reader)
     meters = render_meters(vm)
     # The sober ruling (banner) and its cheerful counterpart (champion celebration) share
@@ -412,10 +438,14 @@ def render_show_html(
     )
 
 
-def _render_at(session: FishbowlSession | None, k: int, *, layout: str, mind_reader: bool) -> tuple[str, str, str, str]:
-    """Render the Show at play-head *k* (pure prefix view), or empty if no session."""
+def _render_at(
+    session: FishbowlSession | None, k: int, *, layout: str, mind_reader: bool, thinking: str | None = None
+) -> tuple[str, str, str, str]:
+    """Render the Show at play-head *k* (pure prefix view), or empty if no session.
+
+    ``thinking`` (a "who's thinking…" label) overlays the stage while a model call runs."""
     vm = session.snapshot(k) if session is not None else _empty_vm()
-    return render_show_html(vm, layout=layout, mind_reader=mind_reader)
+    return render_show_html(vm, layout=layout, mind_reader=mind_reader, thinking=thinking)
 
 
 def advance_one_tick(session: FishbowlSession | None, k: int, ticks: int, *, max_auto_ticks: int = _MAX_AUTO_TICKS):
@@ -460,8 +490,8 @@ def _stopped_banner_html(reason: str) -> str:
 
     text = _html.escape(reason or "budget exceeded")
     return _fishbowl(
-        '<div class="verdict banner">'
-        '<div class="eyebrow">&#9940; Stopped</div>'
+        '<div class="verdict banner stopped">'
+        '<div class="eyebrow">&#9209; The show has ended</div>'
         f'<div class="disp vb-text">{text}</div>'
         "</div>",
         role="fb-verdict",
@@ -532,6 +562,7 @@ def build_app() -> gr.Blocks:
         blank_state = gr.State("")  # stand-in input when a leaf widget is absent
         stopped_state = gr.State(False)  # set once the run halts (budget/backstop/verdict)
         tick_count_state = gr.State(0)  # consecutive autoplay ticks (the 40-tick backstop)
+        play_active_state = gr.State(False)  # is autoplay running? (drives the Play/Pause label)
         # Per-user session id: resolved from the browser's localStorage on load (see
         # _SESSION_ID_JS) so it survives reloads.  Stamped onto run.started so the
         # Archive can list "my sessions only"; a hidden carrier, never shown.
@@ -583,6 +614,7 @@ def build_app() -> gr.Blocks:
             blank_state=blank_state,
             stopped_state=stopped_state,
             tick_count_state=tick_count_state,
+            play_active_state=play_active_state,
             session_id_box=session_id_box,
         )
 
@@ -617,6 +649,7 @@ def _wire(
     blank_state: gr.State,
     stopped_state: gr.State,
     tick_count_state: gr.State,
+    play_active_state: gr.State,
     session_id_box: gr.Textbox | None = None,
 ) -> None:
     """Connect Lab/Show component handles to session transport + HTML re-render.
@@ -630,20 +663,54 @@ def _wire(
     verdict_out = _h(show_handles, "verdict", "verdict_html")
     show_outs = [c for c in (stage_out, feed_out, meters_out, verdict_out) if c is not None]
 
-    # Transport controls (looked up early so output lists can include the timer).
+    # Transport controls (looked up early so output lists can include the timer + the
+    # single Play/Pause hero button — its label travels in the tails so it reverts to
+    # "▶ Play" the instant the show stops on its own).
     timer = _h(show_handles, "timer")
-    # The "halt tail" appended to advancing handlers' outputs: stop the timer (when one
-    # exists) + record the stopped flag.  ``_halt_tail``/``_run_tail`` keep the returned
-    # tuple aligned to whichever of these outputs are wired.
-    _tail_outs = ([timer] if timer is not None else []) + [stopped_state]
+    play_btn = _h(show_handles, "play", "play_btn")
+
+    _PLAY_LABEL = "▶ Play"
+    _PAUSE_LABEL = "❚❚ Pause"
+
+    # The tail appended to advancing handlers' outputs, in order:
+    #   (timer?, stopped_state, play_active_state, play_btn?)
+    # ``_halt_tail``/``_run_tail`` keep the returned tuple aligned to whichever are wired.
+    _tail_outs = (
+        ([timer] if timer is not None else [])
+        + [stopped_state, play_active_state]
+        + ([play_btn] if play_btn is not None else [])
+    )
 
     def _halt_tail() -> tuple:
-        """Tail values that STOP autoplay: (timer active=False?, stopped=True)."""
-        return ((gr.update(active=False),) if timer is not None else ()) + (True,)
+        """Tail values that STOP autoplay and reset the hero button to ▶ Play."""
+        return (
+            ((gr.update(active=False),) if timer is not None else ())
+            + (True, False)
+            + ((gr.update(value=_PLAY_LABEL),) if play_btn is not None else ())
+        )
 
-    def _run_tail(stopped: bool = False) -> tuple:
-        """Tail values that leave the timer untouched: (timer no-op?, stopped flag)."""
-        return ((gr.update(),) if timer is not None else ()) + (stopped,)
+    def _run_tail(play_active: bool = False, stopped: bool = False) -> tuple:
+        """Tail values that leave autoplay running: keep the timer + button as-is."""
+        return (
+            ((gr.update(),) if timer is not None else ())
+            + (stopped, bool(play_active))
+            + ((gr.update(),) if play_btn is not None else ())
+        )
+
+    # Outputs/values that (re)set the play state when a fresh run begins — shared by
+    # Summon (auto-start) and Restart.  Order: (timer?, play_active_state, play_btn?).
+    _start_outs = (
+        ([timer] if timer is not None else []) + [play_active_state] + ([play_btn] if play_btn is not None else [])
+    )
+
+    def _start_tail(active: bool) -> tuple:
+        """Arm (or idle) the transport for a new run: timer, play_active, button label."""
+        label = _PAUSE_LABEL if active else _PLAY_LABEL
+        return (
+            ((gr.update(active=active),) if timer is not None else ())
+            + (active,)
+            + ((gr.update(value=label),) if play_btn is not None else ())
+        )
 
     def _stopped_panes(session, k: int, *, layout: str, mind_reader: bool, reason: str) -> tuple:
         """Render the Show at *k* but swap the verdict pane for the STOPPED banner.
@@ -659,15 +726,17 @@ def _wire(
             panes[1] = banner
         return _pad_values(tuple(panes), show_outs)
 
-    # Show transport controls.
+    # Show transport controls.  The scrubber/step/back handles no longer exist on the
+    # slimmed transport (one Play/Pause button); the lookups stay defensive so any wiring
+    # that references them is simply skipped.
     scrubber = _h(show_handles, "scrubber", "slider", "scrub", "step_slider")
-    play_btn = _h(show_handles, "play", "play_btn")
     step_btn = _h(show_handles, "step", "step_btn", "next", "advance", "fwd_btn")
     back_btn = _h(show_handles, "rewind", "back", "to_start", "first", "back_btn")
     judge_btn = _h(show_handles, "judge_btn", "start_judging", "judge_now", "judge")
     speed_radio = _h(show_handles, "speed", "speed_radio")
     layout_radio = _h(show_handles, "layout", "layout_radio")
     mind_toggle = _h(show_handles, "mind_reader", "read_minds", "minds")
+    restart_btn = _h(show_handles, "restart_btn", "restart", "reset_btn")
     poke_send = _h(show_handles, "poke_send", "poke_btn", "poke")
     poke_text = _h(show_handles, "poke_text", "poke_input")
     poke_buttons = show_handles.get("poke_buttons") or show_handles.get("poke_btns") or []
@@ -809,9 +878,22 @@ def _wire(
         else:
             k = 0
         out = _render_at(session, k, layout=layout, mind_reader=mind_reader)
-        # Summon starts a fresh run: clear the stopped flag and the autoplay backstop.
-        return (session, k, title, gr.update(selected="show"), *_pad_values(out, show_outs), False, 0)
+        # Summon starts a fresh run AND begins playing immediately: clear the stopped
+        # flag, reset the autoplay backstop, arm the timer, and flip the hero button to
+        # "❚❚ Pause" so the show comes alive the moment the visitor hits Summon.
+        return (
+            session,
+            k,
+            title,
+            gr.update(selected="show"),
+            *_pad_values(out, show_outs),
+            False,
+            0,
+            *_start_tail(True),
+        )
 
+    summon_evt = None  # the Summon click event — chained to the kickoff so the show
+    # plays its first line immediately on Summon (set below when the button exists).
     if summon_btn is not None:
         summon_inputs = [
             scenario_in if scenario_in is not None else scenario_state,
@@ -836,10 +918,53 @@ def _wire(
             mind_reader_state,
             session_id_box if session_id_box is not None else blank_state,
         ]
-        summon_btn.click(
+        # The start tail (timer?, play_active, play_btn?) mirrors on_summon's return so the
+        # show auto-plays the instant it is summoned.
+        summon_evt = summon_btn.click(
             on_summon,
             inputs=summon_inputs,
-            outputs=[session_state, k_state, scenario_state, tabs, *show_outs, stopped_state, tick_count_state],
+            outputs=[
+                session_state,
+                k_state,
+                scenario_state,
+                tabs,
+                *show_outs,
+                stopped_state,
+                tick_count_state,
+                *_start_outs,
+            ],
+        )
+
+    # ── ↺ Restart → wipe the run and begin a *fresh context* on the same cast ────
+    # Unlike a scrub-to-start (pure replay), Restart opens a brand-new run: a fresh seed
+    # gives a genuinely different conversation (the deterministic stub is seed-driven), a
+    # new run_id isolates it in the ledger, and the play state re-arms so the new context
+    # starts playing at once.  No tab switch (we're already on the Show) and no cast
+    # rebuild — it reuses the session the visitor composed.  ``restart_evt`` is chained to
+    # the kickoff below so the first line lands immediately, just like Summon.
+    restart_evt = None
+    if restart_btn is not None and show_outs:
+
+        def on_restart(session, layout, mind_reader, session_id):
+            if session is None or getattr(session, "replay", False):
+                # Nothing live to restart (no Summon yet, or a read-only replay): leave
+                # the Show as-is and idle the transport rather than erroring.
+                out = _render_at(session, 0, layout=layout, mind_reader=mind_reader)
+                return (0, *_pad_values(out, show_outs), False, 0, *_start_tail(False))
+            session.reset(uuid.uuid4().hex[:8], session_id=(session_id or "").strip() or None)
+            k = session.head
+            out = _render_at(session, k, layout=layout, mind_reader=mind_reader)
+            return (k, *_pad_values(out, show_outs), False, 0, *_start_tail(True))
+
+        restart_evt = restart_btn.click(
+            on_restart,
+            inputs=[
+                session_state,
+                layout_state,
+                mind_reader_state,
+                session_id_box if session_id_box is not None else blank_state,
+            ],
+            outputs=[k_state, *show_outs, stopped_state, tick_count_state, *_start_outs],
         )
 
     # ── Scenario picked → re-seed the dependent Lab fields from the registry ─────
@@ -968,12 +1093,31 @@ def _wire(
     # ticks (the hard backstop).  The cap tracks the scenario budget so a long show that
     # ends on a late Judge verdict is never cut off early.  Returns (k, *show_outs,
     # *halt-tail, tick_count).
-    def on_tick(session, k, layout, mind_reader, tick_count):
+    # A *generator*: when a tick is about to GENERATE a new line (vs. cheaply replay the
+    # existing prefix), it first yields a frame with a "who's thinking…" strip on the
+    # stage, then runs the (seconds-long) model call, then yields the result.  So the
+    # theater shows who we're waiting on instead of freezing silently.
+    def on_tick(session, k, layout, mind_reader, tick_count, play_active):
+        kk = int(k or 0)
         cap = session.autoplay_tick_cap if session is not None else _MAX_AUTO_TICKS
-        new_k, new_ticks, stop_reason = advance_one_tick(session, k, tick_count, max_auto_ticks=cap)
+        will_generate = (
+            session is not None
+            and not getattr(session, "replay", False)
+            and not session.has_verdict()
+            and kk >= session.head
+            and int(tick_count or 0) < cap
+        )
+        if will_generate and show_outs:
+            who = session.peek_next_actor_name()
+            phrase = f"{who} is thinking" if who else "the cast is thinking"
+            hint = _render_at(session, kk, layout=layout, mind_reader=mind_reader, thinking=phrase)
+            yield (kk, *_pad_values(hint, show_outs), *_run_tail(play_active), tick_count)
+
+        new_k, new_ticks, stop_reason = advance_one_tick(session, kk, tick_count, max_auto_ticks=cap)
         if stop_reason is None:
             out = _render_at(session, new_k, layout=layout, mind_reader=mind_reader)
-            return (new_k, *_pad_values(out, show_outs), *_run_tail(), new_ticks)
+            yield (new_k, *_pad_values(out, show_outs), *_run_tail(play_active), new_ticks)
+            return
         # The cast's run is over (budget/turn cap, a reached verdict, or replay end). If a
         # judge can still rule and hasn't, bring it on — the limit is the curtain call, so
         # the show ends on a verdict + winner rather than a silent STOPPED banner.
@@ -987,15 +1131,16 @@ def _wire(
         if session is not None and session.has_verdict():
             # Render the ruling itself (the verdict pane), timer halted.
             out = _render_at(session, new_k, layout=layout, mind_reader=mind_reader)
-            return (new_k, *_pad_values(out, show_outs), *_halt_tail(), new_ticks)
+            yield (new_k, *_pad_values(out, show_outs), *_halt_tail(), new_ticks)
+            return
         # No judge to rule (or a replay reaching its end): halt visibly with the banner.
         panes = _stopped_panes(session, new_k, layout=layout, mind_reader=mind_reader, reason=stop_reason)
-        return (new_k, *panes, *_halt_tail(), new_ticks)
+        yield (new_k, *panes, *_halt_tail(), new_ticks)
 
     if timer is not None and show_outs:
         timer.tick(
             on_tick,
-            inputs=[session_state, k_state, layout_state, mind_reader_state, tick_count_state],
+            inputs=[session_state, k_state, layout_state, mind_reader_state, tick_count_state, play_active_state],
             outputs=[k_state, *show_outs, *_tail_outs, tick_count_state],
         )
 
@@ -1008,16 +1153,45 @@ def _wire(
         speed_radio.change(on_speed, inputs=[speed_radio], outputs=[timer])
 
     if play_btn is not None and timer is not None:
-        # A tiny state tracks timer activity so the same button toggles play/pause.
-        play_active = gr.State(False)
-
+        # The single hero control: the same button plays and pauses, its label flipping
+        # between "▶ Play" and "❚❚ Pause".  Each fresh ▶ resets the autoplay backstop so
+        # the next run gets a full tick budget rather than inheriting the old one.
         def on_play(active):
-            # Toggle play/pause; each fresh ▶ resets the autoplay backstop counter so the
-            # next run gets a full _MAX_AUTO_TICKS budget rather than inheriting the old one.
             new = not bool(active)
-            return new, gr.update(active=new), 0
+            label = _PAUSE_LABEL if new else _PLAY_LABEL
+            return new, gr.update(active=new), 0, gr.update(value=label)
+
+        play_evt = play_btn.click(
+            on_play,
+            inputs=[play_active_state],
+            outputs=[play_active_state, timer, tick_count_state, play_btn],
+        )
 
-        play_btn.click(on_play, inputs=[play_active], outputs=[play_active, timer, tick_count_state])
+        if show_outs:
+            # Don't make the visitor wait a whole timer interval for the first line: the
+            # instant Play is pressed (play_active just flipped True), advance one step
+            # right away — reusing the tick path so the "who's thinking…" hint shows while
+            # the model runs.  On pause (play_active now False) we simply re-render the
+            # current frame without stepping.  Chained after the toggle so it reads the
+            # freshly-updated play_active/tick_count.
+            def kickoff(session, k, layout, mind_reader, tick_count, play_active):
+                if not play_active:
+                    out = _render_at(session, int(k or 0), layout=layout, mind_reader=mind_reader)
+                    yield (int(k or 0), *_pad_values(out, show_outs), *_run_tail(False), int(tick_count or 0))
+                    return
+                yield from on_tick(session, k, layout, mind_reader, tick_count, play_active)
+
+            _kickoff_io = dict(
+                inputs=[session_state, k_state, layout_state, mind_reader_state, tick_count_state, play_active_state],
+                outputs=[k_state, *show_outs, *_tail_outs, tick_count_state],
+            )
+            play_evt.then(kickoff, **_kickoff_io)
+            # Summon and Restart both auto-start a fresh run; kick their first line off
+            # immediately too, instead of waiting a whole timer interval.
+            if summon_evt is not None:
+                summon_evt.then(kickoff, **_kickoff_io)
+            if restart_evt is not None:
+                restart_evt.then(kickoff, **_kickoff_io)
 
     # ── layout radio + "Read their minds" → re-render the stage HTML ─────────────
     if layout_radio is not None and show_outs:
@@ -1045,29 +1219,36 @@ def _wire(
         )
 
     # ── poke buttons / poke_send → inject then render at the new head ────────────
-    # Injecting steps the conductor, so a poke can trip the governor too — wrap it.
-    def _poke_after(session, text, label_value, layout, mind_reader):
+    # Injecting steps the conductor (a full turn of model calls), so a poke can trip the
+    # governor too — wrap it.  A *generator*: yield a "the wood stirs…" hint first so the
+    # disturbance feels alive while the cast reacts, then the result (or the STOPPED card).
+    def _poke_after(session, text, label_value, layout, mind_reader, play_active):
         if session is None:
             out = _render_at(None, 0, layout=layout, mind_reader=mind_reader)
-            return (0, *_pad_values(out, show_outs), *_run_tail())
+            yield (0, *_pad_values(out, show_outs), *_run_tail(play_active))
+            return
+        if show_outs:
+            hint = _render_at(session, session.head, layout=layout, mind_reader=mind_reader, thinking="the wood stirs")
+            yield (session.head, *_pad_values(hint, show_outs), *_run_tail(play_active))
         try:
             session.inject((text or ""), label=label_value)
         except BudgetExceeded as exc:
             reason = getattr(exc, "reason", None) or str(exc)
             panes = _stopped_panes(session, session.head, layout=layout, mind_reader=mind_reader, reason=reason)
-            return (session.head, *panes, *_halt_tail())
+            yield (session.head, *panes, *_halt_tail())
+            return
         k = session.head
         out = _render_at(session, k, layout=layout, mind_reader=mind_reader)
-        return (k, *_pad_values(out, show_outs), *_run_tail())
+        yield (k, *_pad_values(out, show_outs), *_run_tail(play_active))
 
     if poke_send is not None and poke_text is not None and show_outs:
         # Free-text poke: the textbox supplies the text; a neutral label.
-        def on_poke_send(session, text, layout, mind_reader):
-            return _poke_after(session, text, None, layout, mind_reader)
+        def on_poke_send(session, text, layout, mind_reader, play_active):
+            yield from _poke_after(session, text, None, layout, mind_reader, play_active)
 
         poke_send.click(
             on_poke_send,
-            inputs=[session_state, poke_text, layout_state, mind_reader_state],
+            inputs=[session_state, poke_text, layout_state, mind_reader_state, play_active_state],
             outputs=[k_state, *show_outs, *_tail_outs],
         )
 
@@ -1079,14 +1260,14 @@ def _wire(
         label = str(getattr(btn, "value", None) or "DISTURBANCE")
 
         def make_preset(label_value: str):
-            def _on_preset(session, layout, mind_reader):
-                return _poke_after(session, label_value, label_value, layout, mind_reader)
+            def _on_preset(session, layout, mind_reader, play_active):
+                yield from _poke_after(session, label_value, label_value, layout, mind_reader, play_active)
 
             return _on_preset
 
         btn.click(
             make_preset(label),
-            inputs=[session_state, layout_state, mind_reader_state],
+            inputs=[session_state, layout_state, mind_reader_state, play_active_state],
             outputs=[k_state, *show_outs, *_tail_outs],
         )
 

src/ui/fishbowl/assets/styles.css

@@ -654,6 +654,11 @@ footer { display: none !important; }
 @keyframes coreFloat { 0%,100% { transform: translateY(0); } 50% { transform: translateY(-6px); } }
 .fishbowl .core-title { font-size: 16px; letter-spacing: 0.1em; color: var(--ink); }
 .fishbowl .core-round { font-size: 9px; color: var(--ink-dim); }
+/* Audience-only secret peek (Twenty Sprouts) — a dashed "director's view" chip the cast
+   never sees. Dimmed by default so it reads as a backstage aside, brightening the held
+   word so the human can actually read it at a glance. */
+.fishbowl .core-secret { margin-top: 4px; font-size: 9px; color: var(--ink-faint); border: 1px dashed var(--ink-faint); border-radius: 999px; padding: 3px 9px; background: color-mix(in srgb, var(--cyan) 6%, transparent); pointer-events: auto; }
+.fishbowl .core-secret-word { color: var(--cyan); letter-spacing: 0.14em; text-shadow: var(--glow-hot); }
 .fishbowl .ring { display: contents; }
 .fishbowl .ring-slot { display: grid; place-items: center; z-index: 2; }
 .fishbowl .show-constellation .ring-slot:nth-child(1) { grid-area: 1 / 2; }
@@ -1433,3 +1438,118 @@ footer { display: none !important; }
   line-height: 1.5;
   max-width: 46ch;
 }
+
+/* ============================================================
+   ✦ LIVE-SHOW UX — auto-start cue, single-control transport, loud end-card
+   ------------------------------------------------------------
+   Three small surfaces, big clarity wins:
+     1. a broadcast "lower third" naming who we're waiting on — model calls
+        take seconds, and silence reads as a freeze;
+     2. the lone Play/Pause hero button reads as the one thing to press;
+     3. the end-of-show card is impossible to miss (it used to inherit as ~12px
+        text with no card of its own).
+   ============================================================ */
+
+/* ---- 1 · "who's thinking" badge — pinned to the TOP of the stage so it's in view
+   the instant a model starts working, no scrolling required (it used to sit at the
+   bottom of a tall stage and slip below the fold) ---- */
+.fishbowl.fb-stage { position: relative; }
+.fishbowl .thinking-strip {
+  position: sticky; top: 10px; z-index: 40; pointer-events: none;
+  width: fit-content; max-width: calc(100% - 24px); margin: 2px auto 12px;
+  display: flex; align-items: center; gap: 11px;
+  padding: 9px 17px 9px 14px;
+  font-family: var(--font-display); font-size: 11.5px; letter-spacing: 0.06em;
+  color: var(--cyan);
+  background: rgba(6, 20, 27, 0.94);
+  border: 1px solid var(--line-hot, rgba(79, 230, 210, 0.5));
+  border-radius: 999px;
+  box-shadow: 0 10px 34px -12px rgba(0, 0, 0, 0.85), 0 0 22px rgba(79, 230, 210, 0.3);
+  backdrop-filter: blur(8px);
+  animation: tsIn 0.35s ease both;
+}
+@keyframes tsIn { from { opacity: 0; transform: translateY(-8px); } to { opacity: 1; transform: none; } }
+.fishbowl .thinking-strip .ts-orb {
+  width: 9px; height: 9px; border-radius: 50%; flex: none;
+  background: var(--cyan); box-shadow: 0 0 10px var(--cyan), inset 0 0 4px #fff;
+  animation: tsPulse 1.1s ease-in-out infinite;
+}
+@keyframes tsPulse { 0%, 100% { opacity: 0.45; transform: scale(0.8); } 50% { opacity: 1; transform: scale(1.15); } }
+.fishbowl .thinking-strip .ts-label {
+  white-space: nowrap; overflow: hidden; text-overflow: ellipsis;
+  text-shadow: 0 0 10px rgba(79, 230, 210, 0.4);
+}
+.fishbowl .thinking-strip .ts-dots { display: inline-flex; gap: 3px; flex: none; }
+.fishbowl .thinking-strip .ts-dots i {
+  width: 4px; height: 4px; border-radius: 50%; background: var(--cyan); opacity: 0.3;
+  animation: tsDot 1.1s ease-in-out infinite;
+}
+.fishbowl .thinking-strip .ts-dots i:nth-child(2) { animation-delay: 0.18s; }
+.fishbowl .thinking-strip .ts-dots i:nth-child(3) { animation-delay: 0.36s; }
+@keyframes tsDot { 0%, 100% { opacity: 0.25; } 50% { opacity: 1; } }
+
+/* ---- 2 · single Play/Pause hero button — the obvious thing to press, up in the
+   showbar (native gr.Button → reach it via the container, not the .fishbowl scope) ---- */
+.gradio-container .play-hero,
+.gradio-container .play-hero button {
+  min-width: 132px !important;
+  padding: 10px 22px !important;
+  font-family: var(--font-display) !important;
+  font-size: 13px !important; font-weight: 800 !important;
+  letter-spacing: 0.16em !important; text-transform: uppercase !important;
+  color: #04221c !important;
+  background: linear-gradient(180deg, var(--cyan), #2bc4b4) !important;
+  border: 1px solid var(--cyan) !important; border-radius: 999px !important;
+  box-shadow: 0 0 20px rgba(79, 230, 210, 0.5) !important;
+  animation: playBreath 2.4s ease-in-out infinite;
+}
+@keyframes playBreath {
+  0%, 100% { box-shadow: 0 0 16px rgba(79, 230, 210, 0.38); }
+  50% { box-shadow: 0 0 28px rgba(79, 230, 210, 0.72); }
+}
+.gradio-container .play-hero:hover,
+.gradio-container .play-hero button:hover {
+  box-shadow: 0 0 32px rgba(79, 230, 210, 0.85) !important;
+  filter: brightness(1.1) !important;
+}
+@media (prefers-reduced-motion: reduce) {
+  .gradio-container .play-hero,
+  .gradio-container .play-hero button { animation: none; }
+}
+
+/* ---- 3 · the end-of-show card (verdict ruling + STOPPED both reuse .verdict.banner) ---- */
+.fishbowl .verdict.banner {
+  position: relative;
+  display: flex; flex-direction: column; align-items: center; gap: 10px;
+  margin: 14px auto; max-width: 560px; padding: 22px 30px 24px; text-align: center;
+  border: 1px solid var(--lime); border-radius: 16px;
+  background:
+    radial-gradient(120% 90% at 50% -10%, rgba(155, 232, 107, 0.18), transparent 62%),
+    rgba(6, 20, 27, 0.96);
+  box-shadow: 0 0 50px rgba(155, 232, 107, 0.32), inset 0 0 30px rgba(155, 232, 107, 0.08);
+  backdrop-filter: blur(10px);
+  animation: endCard 0.55s cubic-bezier(0.18, 1.3, 0.35, 1) both;
+}
+@keyframes endCard { from { opacity: 0; transform: translateY(-14px) scale(0.96); } to { opacity: 1; transform: none; } }
+.fishbowl .verdict.banner .eyebrow {
+  font-size: 12px; letter-spacing: 0.34em; color: var(--lime);
+  text-shadow: 0 0 14px rgba(155, 232, 107, 0.6);
+}
+.fishbowl .verdict.banner .vb-text { font-size: 15.5px; line-height: 1.5; color: var(--ink); max-width: 48ch; }
+.fishbowl .verdict.banner .vb-winner { font-size: 18px; letter-spacing: 0.12em; }
+/* the STOPPED / ended-without-verdict variant: coral, not celebratory lime */
+.fishbowl .verdict.banner.stopped {
+  border-color: var(--coral);
+  background:
+    radial-gradient(120% 90% at 50% -10%, rgba(255, 143, 125, 0.16), transparent 62%),
+    rgba(6, 20, 27, 0.96);
+  box-shadow: 0 0 50px rgba(255, 143, 125, 0.28), inset 0 0 30px rgba(255, 143, 125, 0.08);
+}
+.fishbowl .verdict.banner.stopped .eyebrow { color: var(--coral); text-shadow: 0 0 14px rgba(255, 143, 125, 0.6); }
+
+@media (prefers-reduced-motion: reduce) {
+  .fishbowl .thinking-strip,
+  .fishbowl .thinking-strip .ts-orb,
+  .fishbowl .thinking-strip .ts-dots i,
+  .fishbowl .verdict.banner { animation: none; }
+}

src/ui/fishbowl/render/stage.py

@@ -39,6 +39,27 @@ def _core(vm: dict) -> str:
         f'<div class="core-glyph disp">{glyph}</div>'
         f'<div class="core-title disp">{scene}</div>'
         f'<div class="core-round eyebrow">{html.escape(round_text)}</div>'
+        f"{_secret_badge(vm)}"
+        "</div>"
+    )
+
+
+def _secret_badge(vm: dict) -> str:
+    """Audience-only reveal of a hidden-word run's secret (Twenty Sprouts).
+
+    The view model carries ``secret`` only for hidden-word scenarios, and only the human
+    watching the show ever sees it — it is never placed in any agent's prompt (see
+    ``view_model.py``). Empty string for every other run, so the core is unchanged
+    elsewhere. The 🔒 + "only you can see this" framing tells the viewer it's a peek
+    behind the curtain, not something the cast knows.
+    """
+    secret = vm.get("secret")
+    if not secret:
+        return ""
+    return (
+        '<div class="core-secret eyebrow" title="The cast cannot see this — it never enters their prompts.">'
+        "🔒 only you can see · the keeper holds "
+        f'<b class="core-secret-word disp">{html.escape(str(secret))}</b>'
         "</div>"
     )
 

src/ui/fishbowl/session.py

@@ -112,6 +112,13 @@ class FishbowlSession:
         its own (no extra token spend)."""
         return any(e.kind == "judge.verdict" for e in self.conductor.ledger.events_for_run(self.conductor.run_id))
 
+    def peek_next_actor_name(self) -> str | None:
+        """Best-effort name of whoever the next :meth:`step_one` will run.
+
+        Feeds the Show's "who's thinking…" hint while a model call is in flight; a pure
+        read that never advances the run.  Returns ``None`` when nothing is queued."""
+        return self.conductor.peek_next_actor_name()
+
     def has_judge(self) -> bool:
         """True when this cast has a judge that can be asked to rule.
 
@@ -293,6 +300,10 @@ class ReplaySession:
         # recorded run may already carry its verdict.  Report on the recording.
         return self.has_verdict()
 
+    def peek_next_actor_name(self) -> str | None:  # pragma: no cover - inert by design
+        # A replay never generates, so nobody is ever "thinking" — no hint to show.
+        return None
+
     def force_verdict(self) -> bool:  # pragma: no cover - inert by design
         # A replay is read-only: nothing to judge, the recording stands as-is.
         return self.has_verdict()

src/ui/fishbowl/show.py

@@ -33,11 +33,20 @@ def build_show() -> dict[str, object]:
     handles: dict[str, object] = {}
 
     with gr.Column(elem_id="show", elem_classes=["show"]):
-        # ---- SHOW BAR : back-to-lab · mind-reader · layout selector -------
+        # ---- SHOW BAR : PLAY/PAUSE · RESTART · mind-reader · layout -------
+        # The Play/Pause control rides up here at the top of the Show, front-and-centre:
+        # it is the one thing a visitor needs.  Its label flips "▶ Play"⇄"❚❚ Pause"; the
+        # app shell owns the toggle, auto-starts it on Summon, and begins the conversation
+        # the instant it's pressed.  Restart wipes the run and begins a fresh context.
         with gr.Row(elem_classes=["showbar"]):
-            handles["back_to_lab"] = gr.Button(
-                "← back to the Lab",
-                elem_classes=["icon-btn", "back-to-lab"],
+            handles["play_btn"] = gr.Button(
+                "▶ Play",
+                elem_classes=["icon-btn", "play", "play-hero"],
+                scale=0,
+            )
+            handles["restart_btn"] = gr.Button(
+                "↺ Restart",
+                elem_classes=["icon-btn", "restart-btn"],
                 scale=0,
             )
             handles["mind_reader"] = gr.Checkbox(
@@ -101,37 +110,10 @@ def build_show() -> dict[str, object]:
                     scale=0,
                 )
 
-        # ---- TRANSPORT : ⏮/▶/⏭ · scrubber · speed · autoplay clock -------
-        with gr.Row(elem_classes=["transport"]):
-            with gr.Row(elem_classes=["tp-btns"]):
-                handles["back_btn"] = gr.Button("⏮", elem_classes=["icon-btn"], scale=0)
-                handles["play_btn"] = gr.Button("▶", elem_classes=["icon-btn", "play"], scale=0)
-                handles["fwd_btn"] = gr.Button("⏭", elem_classes=["icon-btn"], scale=0)
-                # Curtain call: stop the cast and hand the floor to the judge, which
-                # reads the whole ledger and rules.  The app shell wires it to
-                # ``force_verdict`` and disables it for casts with no judge.
-                handles["judge_btn"] = gr.Button(
-                    "⚖ Start judging",
-                    elem_classes=["icon-btn", "judge-now"],
-                    scale=0,
-                )
-            handles["step_slider"] = gr.Slider(
-                minimum=0,
-                maximum=1,
-                value=0,
-                step=1,
-                label="step",
-                elem_classes=["scrub"],
-                scale=4,
-            )
-            handles["speed"] = gr.Radio(
-                ["live", "1×", "fast"],
-                value="1×",
-                label="speed",
-                elem_classes=["seg", "speed-seg"],
-            )
-
         # ---- AUTOPLAY CLOCK : app shell toggles ``active`` + interval -----
+        # Play/Pause + Restart live in the showbar; the manual "start judging" and speed
+        # controls are gone — the judge is brought on automatically at the end of a run,
+        # and the clock runs at a single comfortable cadence.
         handles["timer"] = gr.Timer(value=1.9, active=False)
 
     return handles

src/ui/fishbowl/view_model.py

@@ -128,6 +128,14 @@ def view_model_at(
     competition = next((e.payload.get("competition") for e in prefix if e.kind == "run.started"), None) or {}
     teams = competition.get("teams") or {}
 
+    # Audience-only ground truth: a hidden-word scenario (Twenty Sprouts) deals its
+    # secret onto the keeper's events as a private ``secret`` payload key. The engine
+    # never surfaces it to any agent's prompt (``_displayable`` shows ``text`` only), but
+    # the human watching the show should see what the keeper is holding — so we lift the
+    # latest one into the view model for the stage to render. Empty for every other run.
+    secret = next((e.payload["secret"] for e in reversed(prefix) if e.payload.get("secret")), None)
+    secret_holder = next((e.actor for e in reversed(prefix) if e.payload.get("secret")), None) if secret else None
+
     verdict = None
     for e in prefix:
         if e.kind == "judge.verdict":
@@ -167,6 +175,10 @@ def view_model_at(
         "voice": chosen_voice,
         "voice_meta": {"name": voice_name, "desc": voice_desc},
         "speaking_id": speaking_id,
+        # Audience-only secret (Twenty Sprouts); None for every other scenario. Rendered on
+        # the stage for the human, never placed in an agent's context.
+        "secret": secret,
+        "secret_holder": secret_holder,
         "verdict": verdict,
         # The winning side's roster (ADR-0029) — lets the champion celebration line up a
         # team's members as chips. Empty for symmetric/judged/none-kind runs.

tests/test_conductor.py

@@ -225,3 +225,33 @@ class TestConductorStepOne:
         assert c.step_one() is True
         kinds = {e.kind for e in c.ledger.events}
         assert "run.started" in kinds and "world.observed" in kinds
+
+
+class TestPeekNextActor:
+    """``peek_next_actor_name`` powers the Show's "who's thinking…" hint: a pure read
+    that names whoever the next ``step_one`` will run, without advancing the run."""
+
+    def test_peeks_the_first_queued_agent(self):
+        # Two tick-every-1 agents: after the first step_one pops the first, the second
+        # sits queued for this same turn — peek must name it, not re-open a turn.
+        scenario = Scenario(name="s", default_seed="seed", agents=(_SpeakingAgent(), _ExplodingAgent()))
+        c = Conductor(scenario=scenario, governor=Governor())
+        c.reset("seed")
+        c.step_one()  # pops "speaker"; "boom" remains queued for turn 1
+        assert c.peek_next_actor_name() == "boom"
+
+    def test_peek_does_not_advance_the_run(self):
+        scenario = Scenario(name="s", default_seed="seed", agents=(_SpeakingAgent(),))
+        c = Conductor(scenario=scenario, governor=Governor())
+        c.reset("seed")
+        before_events, before_turn = len(c.ledger.events), c.turn
+        c.peek_next_actor_name()
+        c.peek_next_actor_name()
+        assert (len(c.ledger.events), c.turn) == (before_events, before_turn)
+
+    def test_peeks_next_turns_tick_actor_when_queue_is_empty(self):
+        # Queue drained between turns: peek looks ahead to who ticks on turn+1.
+        scenario = Scenario(name="s", default_seed="seed", agents=(_SpeakingAgent(),))
+        c = Conductor(scenario=scenario, governor=Governor())
+        c.reset("seed")  # turn 0, nothing queued; "speaker" ticks every turn
+        assert c.peek_next_actor_name() == "speaker"

tests/test_context.py

@@ -36,6 +36,77 @@ def test_persona_and_goal_still_lead():
     assert prompt.index("I am A.") < prompt.index("catch the spy") < prompt.index("WHAT'S BEEN SAID")
 
 
+def _spoke(actor, text, turn=1, kind="agent.spoke"):
+    from src.core.events import Event
+
+    return Event(run_id="r", turn=turn, kind=kind, actor=actor, payload={"text": text})
+
+
+def test_judge_gets_the_full_ordered_transcript_not_just_the_tail():
+    # A judge rules on the WHOLE discussion — every spoken line, in order — not the
+    # recency-biased blackboard tail a worker reacts to (ADR-0023 follow-up).
+    events = tuple(_spoke("debater-a" if i % 2 == 0 else "debater-b", f"point number {i}", turn=i) for i in range(12))
+    proj = StageProjection(goal="g", current_scene="scene")
+    prompt = ContextBuilder().build(
+        agent_name="debate-judge", persona="(judge)", projection=proj, all_events=events, role="judge"
+    )
+    assert "THE EXCHANGE TO JUDGE" in prompt and "WHAT'S BEEN SAID" not in prompt
+    # every line is present, oldest first
+    assert "point number 0" in prompt and "point number 11" in prompt
+    assert prompt.index("point number 0") < prompt.index("point number 11")
+
+
+def test_judge_transcript_excludes_private_thoughts():
+    # Thoughts are the mind-reader's alone; a judge rules on what was SAID.
+    events = (_spoke("a", "said aloud"), _spoke("b", "secret scheming", kind="agent.thought"))
+    prompt = ContextBuilder().build(
+        agent_name="j",
+        persona="(judge)",
+        projection=StageProjection(current_scene="s"),
+        all_events=events,
+        role="judge",
+    )
+    assert "said aloud" in prompt
+    assert "secret scheming" not in prompt
+
+
+def test_worker_gets_blackboard_not_transcript():
+    proj = StageProjection(current_scene="scene")
+    proj.agent_notes = ["a: hello there"]
+    prompt = ContextBuilder().build(
+        agent_name="w", persona="(w)", projection=proj, all_events=(_spoke("a", "hello there"),), role="worker"
+    )
+    assert "WHAT'S BEEN SAID" in prompt and "THE EXCHANGE TO JUDGE" not in prompt
+
+
+def test_memory_does_not_repeat_a_line_already_in_the_discussion():
+    # A spoken line shown in the blackboard must not be printed again in YOUR MEMORY:
+    # the union is unchanged, we just don't duplicate (blackboard=recent, memory=earlier).
+    proj = StageProjection(current_scene="scene")
+    proj.agent_notes = ["a: the bench needs shade"]
+    memory_text = "[turn 003][agent.spoke] the bench needs shade\n[turn 001][world.observed] an older beat"
+    prompt = ContextBuilder().build(
+        agent_name="w", persona="(w)", projection=proj, all_events=(), memory_text=memory_text, role="worker"
+    )
+    # the duplicated line appears once (in the blackboard), the unique earlier beat survives in memory
+    assert prompt.count("the bench needs shade") == 1
+    assert "an older beat" in prompt
+
+
+def test_memory_shows_a_pointer_when_fully_covered_by_the_discussion():
+    proj = StageProjection(current_scene="scene")
+    proj.agent_notes = ["a: only line"]
+    prompt = ContextBuilder().build(
+        agent_name="w",
+        persona="(w)",
+        projection=proj,
+        all_events=(),
+        memory_text="[turn 003][agent.spoke] only line",
+        role="worker",
+    )
+    assert "nothing beyond the exchange above" in prompt
+
+
 def test_a_peer_thought_never_reaches_another_agent():
     # A spoken event carries a private `thought` (the mind-reader content). It must
     # ride only on its own payload — peers see the public `text`, never the thought.

tests/test_engine.py

@@ -31,4 +31,3 @@ def test_conductor_runs_vertical_slice() -> None:
 
     assert len(conductor.ledger.events) >= 3
     assert conductor.projection.current_scene != "The curtain has not risen."
-

tests/test_fishbowl_app.py

@@ -90,6 +90,34 @@ def test_render_show_html_returns_four_panes() -> None:
         assert isinstance(stage, str)
 
 
+def test_render_show_html_overlays_thinking_strip_on_stage() -> None:
+    # The "who's thinking…" hint rides on the always-visible stage pane (not the feed,
+    # which resets its scroll on every re-render). It appears only when asked.
+    from src.ui.fishbowl.app import SCENARIOS, _new_session, render_show_html
+
+    session = _new_session(next(iter(SCENARIOS.values())))
+    session.reset("")
+    vm = session.snapshot(session.head)
+
+    stage_plain, *_ = render_show_html(vm, layout="constellation")
+    assert "thinking-strip" not in stage_plain
+
+    stage_hint, *_ = render_show_html(vm, layout="constellation", thinking="scene-whisperer is thinking")
+    assert "thinking-strip" in stage_hint
+    assert "scene-whisperer is thinking" in stage_hint
+    # Prepended (first child) so position:sticky pins it to the TOP of the stage — in
+    # view without scrolling, rather than below the fold at the bottom.
+    assert stage_hint.index("thinking-strip") < stage_hint.index('class="constellation"')
+
+
+def test_thinking_strip_escapes_its_label() -> None:
+    from src.ui.fishbowl.app import _thinking_strip
+
+    html = _thinking_strip("<script>alert(1)</script>")
+    assert "<script>" not in html
+    assert "&lt;script&gt;" in html
+
+
 def test_inject_appends_a_poke() -> None:
     from src.ui.fishbowl.app import SCENARIOS, _new_session
 

tests/test_fishbowl_loop_safety.py

@@ -146,7 +146,8 @@ def test_autoplay_streams_one_agent_per_advance() -> None:
 def test_stopped_banner_reuses_verdict_chrome() -> None:
     html = fb_app._stopped_banner_html("Total call cap 3 reached")
     assert "verdict banner" in html  # reuses the existing banner CSS class
-    assert "Stopped" in html
+    assert "banner stopped" in html  # the coral end-card variant (distinct from a lime verdict)
+    assert "The show has ended" in html  # a loud, unmissable end-of-show headline
     assert "Total call cap 3 reached" in html  # the reason is shown
 
 

tests/test_fishbowl_show.py

@@ -26,16 +26,12 @@ def test_returns_expected_keys() -> None:
         "verdict_html",
         "layout",
         "mind_reader",
-        "step_slider",
-        "back_btn",
         "play_btn",
-        "fwd_btn",
-        "speed",
+        "restart_btn",
         "timer",
         "poke_btns",
         "poke_text",
         "poke_send",
-        "back_to_lab",
     }
     assert expected <= set(handles)
 
@@ -49,7 +45,6 @@ def test_recipe_subset() -> None:
         "meters_html",
         "layout",
         "mind_reader",
-        "step_slider",
         "play_btn",
         "timer",
     } <= set(handles)
@@ -80,26 +75,33 @@ def test_mind_reader_checkbox_defaults_sealed() -> None:
     assert mr.value is False
 
 
-def test_step_slider_is_scrubber() -> None:
+def test_pared_back_transport_controls_removed() -> None:
+    # The Show is down to Play/Pause + Restart in the showbar: the step buttons,
+    # scrubber, speed radio, manual judge, and back-to-Lab button were all removed
+    # (tab nav covers Lab; the judge is now auto-summoned at the end of a run).
     handles = _build()
-    slider = handles["step_slider"]
-    assert isinstance(slider, gr.Slider)
-    assert slider.value == 0
-    assert slider.minimum == 0
-    assert slider.step == 1
+    for gone in ("step_slider", "back_btn", "fwd_btn", "speed", "judge_btn", "back_to_lab"):
+        assert gone not in handles
 
 
-def test_speed_radio_options() -> None:
+def test_play_button_defaults_to_play_label() -> None:
     handles = _build()
-    speed = handles["speed"]
-    assert isinstance(speed, gr.Radio)
-    assert speed.value == "1×"
-    assert [c[0] for c in speed.choices] == ["live", "1×", "fast"]
+    play = handles["play_btn"]
+    assert isinstance(play, gr.Button)
+    # Starts paused: the app shell flips it to "❚❚ Pause" on Summon (auto-start).
+    assert play.value == "▶ Play"
+
+
+def test_restart_button_present() -> None:
+    handles = _build()
+    restart = handles["restart_btn"]
+    assert isinstance(restart, gr.Button)
+    assert "Restart" in restart.value
 
 
 def test_transport_buttons_are_buttons() -> None:
     handles = _build()
-    for key in ("back_btn", "play_btn", "fwd_btn", "back_to_lab", "poke_send"):
+    for key in ("play_btn", "restart_btn", "poke_send"):
         assert isinstance(handles[key], gr.Button)
 
 

tests/test_fishbowl_winner.py

@@ -44,10 +44,20 @@ class TestAgentWin:
     def _vm(self, **over) -> dict:
         vm = {
             "cast": [
-                {"id": "hypothesis-former", "name": "hypothesis-former", "archetype": "the analyst",
-                 "model": "Arch-Router-1.5B", "hue": 200},
-                {"id": "devil-advocate", "name": "devil-advocate", "archetype": "the skeptic",
-                 "model": "Qwen", "hue": 20},
+                {
+                    "id": "hypothesis-former",
+                    "name": "hypothesis-former",
+                    "archetype": "the analyst",
+                    "model": "Arch-Router-1.5B",
+                    "hue": 200,
+                },
+                {
+                    "id": "devil-advocate",
+                    "name": "devil-advocate",
+                    "archetype": "the skeptic",
+                    "model": "Qwen",
+                    "hue": 20,
+                },
             ],
             "teams": {},
             "verdict": {
@@ -126,6 +136,10 @@ class TestTeamWin:
 
 class TestEscaping:
     def test_label_is_escaped(self):
-        vm = {"verdict": {"winner": "x", "winner_label": "<script>x</script>", "winner_kind": "agent"}, "cast": [], "teams": {}}
+        vm = {
+            "verdict": {"winner": "x", "winner_label": "<script>x</script>", "winner_kind": "agent"},
+            "cast": [],
+            "teams": {},
+        }
         html = render_winner(vm)
         assert "<script>" not in html and "&lt;script&gt;" in html

tests/test_instructor.py

@@ -11,6 +11,7 @@ No network and no real credentials.  Three layers are covered:
     ``complete_structured`` (validated payload, no ``_raw_fallback``) and the
     tolerant-parser path with the deterministic stub.
 """
+
 from __future__ import annotations
 
 import sys

tests/test_journal.py

@@ -7,4 +7,3 @@ def test_journal_scripts_exist() -> None:
     assert (root / "scripts" / "new_journal_entry.py").exists()
     assert (root / "scripts" / "snapshot_progress.py").exists()
     assert (root / "docs" / "blog" / "building-in-public.md").exists()
-

tests/test_mcp.py

@@ -11,6 +11,7 @@ Three tiers, mirroring the optional-dependency tests elsewhere:
   * A guarded stdio round-trip asserts ``oracle`` returns an omen over MCP
     (skipped if ``mcp`` is absent or the server can't be spawned quickly).
 """
+
 from __future__ import annotations
 
 import pytest
@@ -42,6 +43,7 @@ class _SpyResolver:
 
 # ── capability enforcement wraps the transport (no mcp required) ────────────────
 
+
 class TestCapabilityWrapsTransport:
     def test_denied_grant_raises_before_resolver_is_touched(self):
         """The grant check fires before MCP dispatch, regardless of transport."""
@@ -99,6 +101,7 @@ class TestCapabilityWrapsTransport:
 
 # ── the config gate flips in-process ↔ MCP (no mcp required) ────────────────────
 
+
 class TestConfigGate:
     def test_default_is_in_process(self, monkeypatch):
         monkeypatch.delenv("MCP_SERVERS", raising=False)
@@ -123,9 +126,7 @@ class TestConfigGate:
     def test_mcp_servers_gate_parses_multiple(self):
         from src.tools.mcp_client import server_configs_from_env
 
-        configs = server_configs_from_env(
-            {"MCP_SERVERS": "python -m src.tools.mcp_server :: node other.js --flag"}
-        )
+        configs = server_configs_from_env({"MCP_SERVERS": "python -m src.tools.mcp_server :: node other.js --flag"})
         assert len(configs) == 2
         assert configs[0].command == "python"
         assert configs[1].command == "node"
@@ -134,9 +135,7 @@ class TestConfigGate:
     def test_mcp_servers_takes_precedence_over_oracle_flag(self):
         from src.tools.mcp_client import server_configs_from_env
 
-        configs = server_configs_from_env(
-            {"MCP_SERVERS": "python -m custom.server", "MCP_ORACLE": "1"}
-        )
+        configs = server_configs_from_env({"MCP_SERVERS": "python -m custom.server", "MCP_ORACLE": "1"})
         assert len(configs) == 1
         assert configs[0].args == ("-m", "custom.server")
 
@@ -148,6 +147,7 @@ class TestConfigGate:
 
 # ── result coercion (no mcp required: pure dataclass shaping) ────────────────────
 
+
 class TestResultCoercion:
     def test_prefers_structured_content(self):
         from src.tools.mcp_client import _result_to_dict
@@ -189,6 +189,7 @@ class TestResultCoercion:
 
 # ── server module registers oracle (requires mcp) ───────────────────────────────
 
+
 class TestMCPServer:
     def test_server_builds_and_registers_oracle(self):
         pytest.importorskip("mcp")
@@ -216,15 +217,14 @@ class TestMCPServer:
 
 # ── guarded stdio round-trip (requires mcp + a spawnable server) ─────────────────
 
+
 class TestMCPStdioRoundTrip:
     def test_oracle_over_stdio(self):
         pytest.importorskip("mcp")
         from src.tools.builtins import oracle
         from src.tools.mcp_client import MCPServerConfig, MCPToolClient
 
-        client = MCPToolClient(
-            server=MCPServerConfig(command="python", args=("-m", "src.tools.mcp_server"))
-        )
+        client = MCPToolClient(server=MCPServerConfig(command="python", args=("-m", "src.tools.mcp_server")))
         try:
             listed = client.list_tools()
         except Exception as exc:  # pragma: no cover - environment dependent

tests/test_memory.py

@@ -21,11 +21,26 @@ class TestEpisodicMemory:
         visible = mem.visible(events)
         assert len(visible) == 1
 
-    def test_other_agent_spoke_not_visible(self):
+    def test_other_agent_spoke_is_visible(self):
+        # Peers' SPOKEN lines are the shared table — recallable across the whole run, not
+        # just this round's blackboard tail (ADR-0023 follow-up). A late-firing judge
+        # depends on this to read the discussion it rules on.
         mem = EpisodicMemory("pocket-actor")
         events = (_event("agent.spoke", actor="scene-whisperer"),)
-        visible = mem.visible(events)
-        assert len(visible) == 0
+        assert len(mem.visible(events)) == 1
+
+    def test_other_agent_thought_not_visible(self):
+        # A private thought (the mind-reader content) rides only its own event — peers
+        # never read another mind's thinking, even though spoken lines are now shared.
+        mem = EpisodicMemory("pocket-actor")
+        events = (_event("agent.thought", actor="scene-whisperer"),)
+        assert len(mem.visible(events)) == 0
+
+    def test_oracle_spoke_visible_to_all(self):
+        # The custom public-speech kind (oracle-grove) is shared like agent.spoke.
+        mem = EpisodicMemory("scene-whisperer")
+        events = (_event("oracle.spoke", actor="fortune-teller"),)
+        assert len(mem.visible(events)) == 1
 
     def test_user_injected_visible_to_all(self):
         mem = EpisodicMemory("echo")

tests/test_modal_endpoint_urls.py

@@ -48,8 +48,7 @@ def test_every_endpoint_url_is_a_valid_dns_host():
         url = cat.endpoint_url(e.app, e.endpoint_name, _SAMPLE_WORKSPACE)
         label = url.removeprefix("https://").split(".modal.run", 1)[0]
         assert len(label) <= _DNS_LABEL_MAX, (
-            f"{e.key}: DNS label is {len(label)} chars (> {_DNS_LABEL_MAX}); "
-            f"shorten endpoint_name. label={label!r}"
+            f"{e.key}: DNS label is {len(label)} chars (> {_DNS_LABEL_MAX}); shorten endpoint_name. label={label!r}"
         )
 
 

tests/test_modularity.py

@@ -6,6 +6,7 @@ The new agent even mints its own namespaced event kind, and it still renders on
 stage via the generic projection fallback.  If this passes, "config over code" is
 real, not aspirational.
 """
+
 from __future__ import annotations
 
 from collections import Counter

tests/test_salience_memory.py

@@ -88,6 +88,14 @@ class TestReflectionTracker:
         events6 = tuple(_event("world.observed", turn=i) for i in range(6))
         assert tracker.observe(events6)
 
+    def test_peer_speech_does_not_advance_the_reflection_clock(self):
+        # Reflection compacts "what I've been through" — its cadence keys on world beats and
+        # the agent's own events, NOT how chatty the table got (peers' spoke is recallable
+        # but excluded from the reflection count). Three peer lines must not trip threshold 3.
+        tracker = ReflectionTracker("a", threshold=3)
+        peer_chatter = tuple(_event("agent.spoke", actor="b", turn=i) for i in range(3))
+        assert not tracker.observe(peer_chatter)
+
 
 class TestKindImportanceTable:
     def test_user_injected_high(self):

tests/test_twenty_sprouts.py

@@ -0,0 +1,312 @@
+"""Twenty Sprouts gameplay — the keeper answers, the guesser builds on the ledger.
+
+These exercise the handlers' *pure* logic (Q&A reconstruction, dossier prompts, the
+keeper's answer guard) plus the end-to-end discipline that matters most for a
+hidden-word game: the secret word is dealt by code, shown to the human audience, and
+never placed in any agent's prompt.  All offline — zero tokens, zero mocks.
+"""
+
+from __future__ import annotations
+
+import pytest
+
+from src.agents.twenty_sprouts import (
+    _WORDS,
+    SecretKeeper,
+    SproutGuesser,
+    _answer_violation,
+    _classify_answer,
+    _contains_word,
+    _qa_history,
+    _questions_since_guess,
+    _redact_word,
+    _word_for_seed,
+)
+from src.core.context import ContextBuilder
+from src.core.conductor import Conductor
+from src.core.events import Event
+from src.core.governor import BudgetExceeded
+from src.core.memory import EpisodicMemory
+from src.core.projections import StageProjection, rebuild_stage
+from src.core.registry import Registry
+from src.models.router import ModelRouter
+from src.tools.builtins import default_tool_registry
+from src.ui.fishbowl.render.stage import render_constellation
+from src.ui.fishbowl.view_model import view_model_at
+
+_RUN = "r1"
+
+
+def _spoke(actor: str, text: str, turn: int = 1) -> Event:
+    return Event(run_id=_RUN, turn=turn, kind="agent.spoke", actor=actor, payload={"text": text})
+
+
+def _qa(*pairs: tuple[str, str | None]) -> tuple[Event, ...]:
+    """Build a guesser/keeper transcript from (question, answer|None) pairs."""
+    events: list[Event] = []
+    for i, (q, a) in enumerate(pairs, start=1):
+        events.append(_spoke("sprout-guesser", q, turn=i))
+        if a is not None:
+            events.append(_spoke("secret-keeper", a, turn=i))
+    return tuple(events)
+
+
+# ── ground truth: the dealt word ────────────────────────────────────────────────
+
+
+def test_word_is_a_deterministic_function_of_the_seed():
+    seed = "A small thing from the wood"
+    assert _word_for_seed(seed) == _word_for_seed(seed)
+    assert _word_for_seed(seed) in _WORDS
+
+
+def test_empty_seed_still_deals_a_valid_word():
+    assert _word_for_seed("") in _WORDS
+
+
+# ── Q&A reconstruction off the ledger ────────────────────────────────────────────
+
+
+def test_qa_history_pairs_each_question_with_the_following_answer():
+    events = _qa(("alive?", "No, never alive."), ("made by hands?", "Yes, crafted."))
+    assert _qa_history(events) == [("alive?", "No, never alive."), ("made by hands?", "Yes, crafted.")]
+
+
+def test_qa_history_leaves_an_unanswered_trailing_question_open():
+    events = _qa(("alive?", "No."), ("does it glow?", None))
+    pairs = _qa_history(events)
+    assert pairs[-1] == ("does it glow?", None)
+
+
+def test_qa_history_ignores_a_keeper_line_with_no_open_question():
+    # A stray keeper line before any question must not attach to nothing or crash.
+    events = (_spoke("secret-keeper", "Ask me anything."), _spoke("sprout-guesser", "alive?"))
+    assert _qa_history(events) == [("alive?", None)]
+
+
+@pytest.mark.parametrize(
+    "answer,expected",
+    [
+        ("Yes, you could hold it.", "yes"),
+        ("No, never alive.", "no"),
+        ("Never — not in a hundred winters.", "no"),
+        ("Mostly, on cold nights.", "yes"),
+        ("Warmer now — it belongs to the wood.", "hint"),
+    ],
+)
+def test_classify_answer_reads_the_lead_word(answer: str, expected: str):
+    assert _classify_answer(answer) == expected
+
+
+# ── the keeper: answers, never asks ──────────────────────────────────────────────
+
+
+def _keeper() -> SecretKeeper:
+    agent = SecretKeeper(ModelRouter(offline=True, specs={}))
+    agent.manifest = Registry.from_dir().agents["secret-keeper"]
+    return agent
+
+
+def _guesser() -> SproutGuesser:
+    agent = SproutGuesser(ModelRouter(offline=True, specs={}))
+    agent.manifest = Registry.from_dir().agents["sprout-guesser"]
+    return agent
+
+
+def test_keeper_prompt_carries_the_word_and_the_open_question():
+    proj = StageProjection(seed="seed-A")
+    events = _qa(("Is it alive?", None))
+    prompt = _keeper()._build_extra_prompt(proj, events)
+    assert _word_for_seed("seed-A") in prompt  # the keeper knows its word
+    assert "Is it alive?" in prompt  # and the exact question to answer
+    assert "never ask" in prompt.lower()  # and the discipline to only answer
+
+
+def test_keeper_first_turn_invites_the_guesser_to_begin():
+    prompt = _keeper()._build_extra_prompt(StageProjection(seed="seed-A"), ())
+    assert "not asked yet" in prompt.lower() or "invite" in prompt.lower()
+
+
+def test_keeper_prompt_forbids_writing_the_actual_word():
+    word = _word_for_seed("seed-A")
+    prompt = _keeper()._build_extra_prompt(StageProjection(seed="seed-A"), _qa(("Is it alive?", None)))
+    assert f"NEVER write the word '{word}'" in prompt  # the word it must never spell
+
+
+def test_keeper_question_guard_is_a_passthrough_offline():
+    # Offline the curated keeper lines are answers, so a full offline turn never trips
+    # the live-only question/leak guard — proving the deterministic path is unchanged.
+    keeper = _keeper()
+    event = keeper.act(_RUN, 1, StageProjection(seed="seed-A"), _qa(("Is it alive?", None)))
+    assert event.kind == "agent.spoke"
+    assert event.payload["secret"] == _word_for_seed("seed-A")  # ground truth stamped on
+
+
+# ── the keeper never leaks the word (the worst bug: it spelled "ember" aloud) ─────
+
+
+@pytest.mark.parametrize(
+    "text,word,leaks",
+    [
+        ("Yes, a glowing ember can emerge from the fire.", "EMBER", True),
+        ("Yes, embers like it glow.", "EMBER", True),  # simple inflection
+        ("No, it never drives anywhere.", "RIVER", False),  # substring, not the word
+        ("Yes, you could hold it in one hand.", "EMBER", False),
+    ],
+)
+def test_contains_word_is_whole_word_and_inflection_aware(text: str, word: str, leaks: bool):
+    assert _contains_word(text, word) is leaks
+
+
+def test_redact_word_scrubs_the_secret_before_it_ships():
+    scrubbed = _redact_word("Yes, a glowing ember can emerge from the fire.", "EMBER")
+    assert "ember" not in scrubbed.lower()
+    assert scrubbed.startswith("Yes,")  # the rest of the answer survives
+
+
+def test_redact_word_is_a_noop_when_the_word_is_absent():
+    line = "No, it was never alive, though plenty have leaned on it."
+    assert _redact_word(line, "EMBER") == line
+
+
+@pytest.mark.parametrize(
+    "text,word,reason_substr",
+    [
+        ("Yes, an ember glows.", "EMBER", "spelled"),  # leak
+        ("Is it warm to hold?", "EMBER", "asked a question"),  # asking, not answering
+        ("Yes, you could hold it patiently.", "EMBER", None),  # clean answer
+    ],
+)
+def test_answer_violation_flags_leaks_and_questions(text: str, word: str, reason_substr: str | None):
+    reason = _answer_violation(text, word)
+    if reason_substr is None:
+        assert reason is None
+    else:
+        assert reason and reason_substr in reason
+
+
+# ── the guesser: builds on the ledger, never repeats ─────────────────────────────
+
+
+def test_guesser_dossier_sorts_confirmed_and_ruled_out():
+    events = _qa(
+        ("Is it made by hands?", "Yes, crafted by someone patient."),
+        ("Is it alive?", "No, never alive."),
+    )
+    prompt = _guesser()._build_extra_prompt(StageProjection(seed="seed-A"), events)
+    assert "CONFIRMED" in prompt and "Is it made by hands?" in prompt
+    assert "RULED OUT" in prompt and "Is it alive?" in prompt
+    assert "ALREADY ASKED" in prompt  # every prior question, never to be repeated
+
+
+def test_guesser_opening_prompt_when_nothing_asked_yet():
+    prompt = _guesser()._build_extra_prompt(StageProjection(seed="seed-A"), ())
+    assert "opening" in prompt.lower() or "broad" in prompt.lower()
+
+
+def test_guesser_hard_commits_after_the_question_cap():
+    # All "No" answers (no confirmed facts), so only the hard _COMMIT_AFTER stop can fire.
+    asked = tuple((f"Is it property number {i}?", "No, not that.") for i in range(SproutGuesser._COMMIT_AFTER + 1))
+    prompt = _guesser()._build_extra_prompt(StageProjection(seed="seed-A"), _qa(*asked))
+    assert "time to guess" in prompt.lower() and "my guess is" in prompt.lower()
+
+
+def test_guesser_commits_once_the_word_has_clearly_taken_shape():
+    # _GUESS_WHEN_CONFIRMED yes-answers ⇒ commit even though few questions were asked.
+    yes = tuple((f"Is it trait {i}?", "Yes, that's right.") for i in range(SproutGuesser._GUESS_WHEN_CONFIRMED))
+    prompt = _guesser()._build_extra_prompt(StageProjection(seed="seed-A"), _qa(*yes))
+    assert "time to guess" in prompt.lower()
+
+
+def test_guesser_interleaves_a_guess_after_too_many_questions_without_one():
+    # Enough facts to guess, and _GUESS_EVERY questions since the last guess ⇒ forced guess,
+    # so the guesser commits *between* questions instead of interrogating forever.
+    pairs = [("Is it made by hands?", "Yes."), ("Is it warm?", "Yes."), ("Is it small?", "Yes.")]
+    pairs += [(f"Is it trait {i}?", "No.") for i in range(SproutGuesser._GUESS_EVERY)]
+    prompt = _guesser()._build_extra_prompt(StageProjection(seed="seed-A"), _qa(*pairs))
+    assert "time to guess" in prompt.lower()
+
+
+def test_guesser_keeps_asking_when_it_has_too_little_and_guessed_recently():
+    # One confirmed fact, just asked a couple questions: not enough to force a guess yet.
+    prompt = _guesser()._build_extra_prompt(
+        StageProjection(seed="seed-A"), _qa(("Is it warm?", "Yes."), ("Is it loud?", "No."))
+    )
+    assert "time to guess" not in prompt.lower()
+    assert "yes/no question" in prompt.lower()
+
+
+def test_questions_since_guess_counts_back_to_the_last_commit():
+    pairs = _qa_history(_qa(("q1?", "No."), ("My guess is: ACORN", "No."), ("q2?", "No."), ("q3?", "No.")))
+    assert _questions_since_guess(pairs) == 2  # two questions after the guess
+    assert _questions_since_guess(_qa_history(_qa(("q1?", "No."), ("q2?", "No.")))) == 2  # never guessed
+
+
+def test_guesser_lists_a_prior_wrong_guess_so_it_is_not_repeated():
+    events = _qa(("Is it alive?", "No."), ("My guess is: ACORN", "No, that's not it."))
+    prompt = _guesser()._build_extra_prompt(StageProjection(seed="seed-A"), events)
+    assert "ALREADY GUESSED" in prompt and "ACORN" in prompt
+
+
+# ── the whole game: secret to the audience, never to the cast ────────────────────
+
+
+@pytest.fixture(scope="module")
+def played():
+    """Run Twenty Sprouts to a verdict on the deterministic stub; return (events, word)."""
+    registry = Registry.from_dir()
+    scenario = registry.build_scenario(
+        "twenty-sprouts", router=ModelRouter(offline=True, specs={}), tools=default_tool_registry()
+    )
+    conductor = Conductor(scenario, governor=registry.governor_for("twenty-sprouts"))
+    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)
+    return events, _word_for_seed(scenario.default_seed), [a.manifest for a in scenario.agents]
+
+
+def test_secret_never_enters_the_guessers_context(played):
+    events, word, _cast = played
+    proj = rebuild_stage(events)
+    memory = EpisodicMemory("sprout-guesser", max_recent=40).format_for_prompt(events)
+    context = ContextBuilder().build(
+        agent_name="sprout-guesser",
+        persona="P",
+        projection=proj,
+        all_events=events,
+        memory_window=40,
+        memory_text=memory,
+    )
+    assert word not in context
+    assert word not in memory
+    assert word not in "\n".join(proj.agent_notes)
+
+
+def test_secret_reaches_the_audience_view_model_and_stage(played):
+    events, word, cast = played
+    vm = view_model_at(events, len(events), cast, scenario_name="twenty-sprouts")
+    assert vm["secret"] == word
+    assert vm["secret_holder"] == "secret-keeper"
+    stage_html = render_constellation(vm, {})
+    assert word in stage_html and "only you can see" in stage_html
+
+
+def test_secret_does_not_leak_into_the_narrator_feed(played):
+    events, word, cast = played
+    vm = view_model_at(events, len(events), cast, scenario_name="twenty-sprouts")
+    feed_text = " ".join(str(item.get("said") or item.get("text") or "") for item in vm["feed"])
+    assert word not in feed_text
+
+
+def test_non_secret_scenarios_have_no_audience_badge():
+    # A run with no dealt secret leaves the field None and renders no badge.
+    cast = list(Registry.from_dir().agents.values())[:1]
+    vm = view_model_at((), 0, cast, scenario_name="debate-duel")
+    assert vm["secret"] is None and vm["secret_holder"] is None
+    assert "only you can see" not in render_constellation(vm, {})