feat: implement winner celebration overlay and judging mechanics

- Added `render_winner` function to create a celebratory overlay for the winning agent or team.
- Integrated winner rendering into the main application flow, allowing for a modular display of victory.
- Introduced `has_judge` and `force_verdict` methods in `FishbowlSession` to manage judging logic.
- Updated session handling to allow for forced verdicts, even when the budget is spent.
- Enhanced CSS styles for the winner celebration, including confetti and trophy animations.
- Created tests for judging mechanics and winner rendering to ensure correct functionality across scenarios.

config/agents/secret-keeper.yaml

@@ -6,7 +6,7 @@ persona: >
   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).
+  (one of: thinking, calm, lying, panic, smug, truth, gossip). Do not reveal your secret word and do not ask questions.
 subscribes_to: []
 may_emit:
   - agent.spoke

docs/architecture/fishbowl-ui.md

@@ -111,6 +111,35 @@ So "replay" and "live" are the same code path differing only in whether the tick
 appends. Offline (no API key) the deterministic stub still produces every turn, so the
 hybrid transport — and the whole demo — is reproducible on stage.
 
+## Curtain call — "Start judging" + limit-reached verdict
+
+The show resolves on a **judge's ruling**, not a silent halt. Two triggers bring on the
+judge:
+
+- **The visitor presses "⚖ Start judging"** (`show.py` → `judge_btn`), the amber pill in
+  the transport. The app shell's `start_judging` handler stops autoplay (the halt-tail
+  kills the `gr.Timer`) and calls `session.force_verdict()`.
+- **A budget/turn limit ends the cast's run.** `on_tick` already stops on a tripped
+  governor or the tick-cap backstop; when that happens and the cast has a judge that
+  hasn't ruled, it brings the judge on instead of painting the bare `⛔ STOPPED` banner.
+
+`FishbowlSession.force_verdict()` delegates to **`Conductor.force_verdict()`**, which:
+
+1. **silences the cast** — drains `_pending` + `_trigger_queue` so no further competitor
+   speaks after the curtain call;
+2. **runs the judge(s) un-gated** (`role: judge` agents) — `_run_agent(..., check_budget=False)`
+   so a verdict lands *even when the very budget that ended the show is spent*. The judge
+   reads the whole run (`recent_events = events_for_run(run_id)`) and emits one
+   `judge.verdict` carrying a `winner` (via the `judged-competition` handler offline);
+3. is **idempotent** — a run that already has a verdict returns it unchanged.
+
+The session then `finalize("verdict")`s the run. When the limit path had already
+finalized the run `"budget"` with no winner, `Conductor.finalize` appends a **corrective
+`run.finished`** carrying the verdict + winner (its one scoped exception to idempotency);
+`run_index` folds `run.finished` last-wins, so the leaderboard attributes the ruling, not
+the truncation. A cast with **no judge** (e.g. Oracle Grove) can't be forced — the click
+halts visibly with a banner instead, and nothing is fabricated.
+
 ## Say vs think — the MindCard
 
 Each MindCard (`render/mindcard.py`) shows a mind's front face (its public `said`) and,

src/core/conductor.py

@@ -170,6 +170,13 @@ class Conductor:
         the existing one rather than emitting a duplicate.  ``turns`` and ``tokens``
         are read from the governor's live counters.
 
+        One scoped exception (the curtain call): when the show was cut short by a budget
+        bound — the run was already finalized ``"budget"`` with no winner — and the judge
+        *then* rules (``reason == "verdict"`` with a winner), we append a corrective
+        ``run.finished`` so the win is attributed (ADR-0029).  The leaderboard reads
+        ``run.finished`` last-wins (``run_index``), so the ruling, not the truncation,
+        names the winner.  Every other repeat call stays a true no-op.
+
         Attribution (ADR-0029): ``winner`` is a cast agent name (``winner_kind:
         "agent"``) or a team label (``winner_kind: "team"``).  ``winning_model`` keeps
         its original meaning — a single cast agent's endpoint, populated only for an
@@ -178,7 +185,15 @@ class Conductor:
         """
         existing = [e for e in self.ledger.events_for_run(self.run_id) if e.kind == "run.finished"]
         if existing:
-            return existing[0]
+            prior = existing[-1]
+            supersedes_budget_close = (
+                reason == "verdict"
+                and bool(winner)
+                and prior.payload.get("reason") == "budget"
+                and not prior.payload.get("winner")
+            )
+            if not supersedes_budget_close:
+                return prior
         stats = self.governor.stats
         finished = Event(
             run_id=self.run_id,
@@ -285,6 +300,46 @@ class Conductor:
         self._maybe_snapshot()
         return True
 
+    def force_verdict(self) -> Event | None:
+        """Cut the show short and have the judge rule *now*, on the whole run.
+
+        The curtain call: the visitor pressed "Start judging", or a budget/turn limit
+        ended the cast's run.  We silence the cast (drain any queued or in-flight
+        competitor turns so no further mind speaks), then run the scenario's judge(s)
+        so a ``judge.verdict`` — carrying a ``winner`` via the competition handler —
+        lands and reads every event of this run.
+
+        Crucially the judge runs *un-gated*: a verdict must still land even when the
+        very budget that ended the show is already spent, so the round resolves on a
+        ruling rather than a silent halt.  Idempotent: if this run already has a
+        verdict, it is returned unchanged.  Returns the verdict event, or ``None`` when
+        the scenario has no judge to rule.
+        """
+        existing = next(
+            (e for e in self.ledger.events_for_run(self.run_id) if e.kind == "judge.verdict"),
+            None,
+        )
+        if existing is not None:
+            return existing
+        judges = [a for a in self.scenario.agents if getattr(getattr(a, "manifest", None), "role", None) == "judge"]
+        if not judges:
+            return None
+        # Silence the cast: no queued subscription/tick competitor acts after this.
+        self._pending.clear()
+        self._trigger_queue.clear()
+        # Advance the sim-clock once to mark the curtain call, but DON'T gate on the
+        # governor — the judge must rule even when the show ended on a spent budget.
+        self.turn += 1
+        obs.set_context(turn=self.turn)
+        obs.log("run.judging", run_id=self.run_id, turn=self.turn, judges=[getattr(j, "name", "") for j in judges])
+        projection = self.projection
+        for judge in judges:
+            self._run_agent(judge, projection, check_budget=False)
+        return next(
+            (e for e in reversed(self.ledger.events_for_run(self.run_id)) if e.kind == "judge.verdict"),
+            None,
+        )
+
     def inject_user_event(self, text: str, label: str | None = None) -> None:
         self.turn += 1
         payload: dict[str, str] = {"text": text}
@@ -320,8 +375,9 @@ class Conductor:
             for agent in self._tick_scheduled_agents():
                 self._run_agent(agent, projection)
 
-    def _run_agent(self, agent: "Agent", projection: StageProjection) -> None:
-        self.governor.check(self.turn)  # before the span: a budget stop is not an agent turn
+    def _run_agent(self, agent: "Agent", projection: StageProjection, *, check_budget: bool = True) -> None:
+        if check_budget:
+            self.governor.check(self.turn)  # before the span: a budget stop is not an agent turn
         name = getattr(agent, "name", agent.__class__.__name__)
         start = time.perf_counter()
         with obs.bind(agent=name), obs.span("agent.turn", **{"mal.agent": name, "mal.turn": self.turn}):

src/ui/fishbowl/app.py

@@ -173,6 +173,16 @@ except Exception:  # pragma: no cover
         return f"<div class='verdict'>{v.get('text', '')}</div>"
 
 
+try:
+    # The cheerful champion celebration — a modular overlay, empty unless a winner was
+    # declared, so it composes into the verdict pane without touching no-winner scenarios.
+    from src.ui.fishbowl.render.winner import render_winner
+except Exception:  # pragma: no cover
+
+    def render_winner(vm) -> str:
+        return ""
+
+
 try:  # session: the transport wrapper over a Conductor
     from src.ui.fishbowl.session import FishbowlSession
 except Exception:  # pragma: no cover - fallback session keeps the shell live
@@ -202,6 +212,14 @@ except Exception:  # pragma: no cover - fallback session keeps the shell live
             # Mirrors the real session's loop-safety helper so on_tick never crashes.
             return any(getattr(e, "kind", None) == "judge.verdict" for e in self.conductor.ledger.events)
 
+        def has_judge(self) -> bool:
+            return any(
+                getattr(getattr(a, "manifest", None), "role", None) == "judge" for a in self.conductor.scenario.agents
+            )
+
+        def force_verdict(self) -> bool:
+            return self.conductor.force_verdict() is not None
+
         def reset(self, seed: str) -> None:
             self.conductor.reset(seed or self.conductor.scenario.default_seed)
 
@@ -382,7 +400,10 @@ def render_show_html(
 
     feed = render_feed(vm, mind_reader=mind_reader)
     meters = render_meters(vm)
-    verdict = render_verdict(vm)
+    # The sober ruling (banner) and its cheerful counterpart (champion celebration) share
+    # the verdict pane; render_winner is "" unless the run crowned someone, so no-winner
+    # scenarios get the banner alone.
+    verdict = render_verdict(vm) + render_winner(vm)
     return (
         _fishbowl(stage, role=f"fb-stage fb-{layout}"),
         _fishbowl(feed, role="fb-feed"),
@@ -643,6 +664,7 @@ def _wire(
     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")
@@ -883,6 +905,39 @@ def _wire(
             outputs=[k_state, *show_outs, *_tail_outs],
         )
 
+    # ── ⚖ Start judging → silence the cast, the judge rules on the whole ledger ──
+    # The curtain call: stop autoplay (the halt-tail kills the timer), drain the cast's
+    # pending turns, and have the judge read every event of the run and land a verdict +
+    # winner.  Renders the verdict pane on success; a cast with no judge halts visibly so
+    # the click is never silent.  Returns (k, *show_outs, *halt-tail).
+    def start_judging(session, layout, mind_reader):
+        if session is None:
+            out = _render_at(None, 0, layout=layout, mind_reader=mind_reader)
+            return (0, *_pad_values(out, show_outs), *_halt_tail())
+        try:
+            ruled = session.force_verdict()
+        except BudgetExceeded as exc:
+            # A judge that itself trips a bound still halts visibly rather than crashing.
+            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())
+        k = session.head
+        if ruled or session.has_verdict():
+            out = _render_at(session, k, layout=layout, mind_reader=mind_reader)
+            return (k, *_pad_values(out, show_outs), *_halt_tail())
+        # No judge in this cast — surface that instead of stopping silently.
+        panes = _stopped_panes(
+            session, k, layout=layout, mind_reader=mind_reader, reason="no judge in this cast to rule"
+        )
+        return (k, *panes, *_halt_tail())
+
+    if judge_btn is not None and show_outs:
+        judge_btn.click(
+            start_judging,
+            inputs=[session_state, layout_state, mind_reader_state],
+            outputs=[k_state, *show_outs, *_tail_outs],
+        )
+
     # ── scrubber / ⏮ → pure prefix view (no stepping) ───────────────────────────
     def scrub_to(session, k, layout, mind_reader):
         kk = int(k or 0)
@@ -916,11 +971,26 @@ def _wire(
     def on_tick(session, k, layout, mind_reader, tick_count):
         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)
-        if stop_reason is not None:
-            panes = _stopped_panes(session, new_k, layout=layout, mind_reader=mind_reader, reason=stop_reason)
-            return (new_k, *panes, *_halt_tail(), new_ticks)
-        out = _render_at(session, new_k, layout=layout, mind_reader=mind_reader)
-        return (new_k, *_pad_values(out, show_outs), *_run_tail(), new_ticks)
+        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)
+        # 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.
+        live = session is not None and not getattr(session, "replay", False)
+        if live and not session.has_verdict() and session.has_judge():
+            try:
+                session.force_verdict()
+            except BudgetExceeded:
+                pass  # a judge that trips its own bound falls through to the banner below
+        new_k = session.head if session is not None else new_k
+        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)
+        # 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)
 
     if timer is not None and show_outs:
         timer.tick(

src/ui/fishbowl/assets/styles.css

@@ -783,6 +783,86 @@ footer { display: none !important; }
 /* Winner ribbon — the arena's "who won" chip; only present for competitive runs. */
 .fishbowl .vb-winner { font-family: var(--font-display); font-size: 12px; letter-spacing: 0.16em; text-transform: uppercase; color: var(--amber); text-shadow: 0 0 12px rgba(255,207,107,0.55); white-space: nowrap; }
 
+/* ---- winner celebration ----
+   The cheerful counterpart to the verdict banner: a one-shot champion overlay that drops
+   in when a run crowns someone. Fixed + pointer-events:none so it floats over the theater
+   without stealing clicks from the transport. Tinted by --win-hue (the winning bot's own
+   hue) so the glow matches the mind on stage. Only rendered for winner/loser scenarios. */
+.fishbowl .winner-fx { position: fixed; inset: 0; z-index: 150; pointer-events: none; display: flex; align-items: center; justify-content: center; }
+
+/* dismiss machinery — a hidden checkbox toggled by the backdrop + the ✕ (no JS needed) */
+.fishbowl .wf-dismiss { position: absolute; width: 0; height: 0; margin: 0; opacity: 0; pointer-events: none; }
+.fishbowl .wf-backdrop { position: fixed; inset: 0; z-index: 0; pointer-events: auto; cursor: pointer;
+  background: radial-gradient(120% 120% at 50% 42%, transparent 0%, rgba(2, 10, 14, 0.55) 100%);
+  backdrop-filter: blur(2px); animation: wfFade 0.4s ease both; }
+@keyframes wfFade { from { opacity: 0; } to { opacity: 1; } }
+/* dismissed → the overlay vanishes and the transport is clickable again */
+.fishbowl .wf-dismiss:checked ~ .wf-backdrop,
+.fishbowl .wf-dismiss:checked ~ .wf-confetti,
+.fishbowl .wf-dismiss:checked ~ .wf-card { display: none; }
+
+/* the ✕ — a hue-tinted phosphor disc that spins on hover */
+.fishbowl .wf-x { position: absolute; top: 11px; right: 13px; z-index: 2; width: 26px; height: 26px; display: grid; place-items: center;
+  cursor: pointer; pointer-events: auto; font-family: var(--font-display); font-size: 17px; line-height: 1;
+  color: hsl(var(--win-hue) 70% 80%); border: 1px solid hsl(var(--win-hue) 70% 60% / 0.4); border-radius: 50%;
+  background: hsl(var(--win-hue) 70% 50% / 0.1); transition: color 0.15s ease, border-color 0.15s ease, box-shadow 0.15s ease, transform 0.2s ease; }
+.fishbowl .wf-x:hover { color: #fff; border-color: hsl(var(--win-hue) 80% 66% / 0.9); box-shadow: 0 0 14px hsl(var(--win-hue) 85% 60% / 0.5); transform: rotate(90deg); }
+
+/* the champion card — phosphor glass, hue-tinted, lands with an overshoot pop */
+.fishbowl .wf-card {
+  position: relative; isolation: isolate; z-index: 1; pointer-events: auto;
+  display: flex; flex-direction: column; align-items: center; gap: 9px;
+  padding: 30px 44px 26px; min-width: 280px; max-width: 86vw; text-align: center;
+  border: 1px solid hsl(var(--win-hue) 80% 62% / 0.7);
+  border-radius: 18px;
+  background:
+    radial-gradient(120% 90% at 50% -10%, hsl(var(--win-hue) 70% 22% / 0.55), transparent 60%),
+    rgba(6, 20, 27, 0.94);
+  box-shadow: 0 0 60px hsl(var(--win-hue) 80% 55% / 0.42), inset 0 0 36px hsl(var(--win-hue) 70% 50% / 0.12);
+  backdrop-filter: blur(10px);
+  animation: wfPop 0.62s cubic-bezier(0.18, 1.35, 0.35, 1) both;
+}
+@keyframes wfPop { 0% { opacity: 0; transform: translateY(26px) scale(0.86); } 60% { opacity: 1; } 100% { opacity: 1; transform: none; } }
+
+/* a slow spotlight cone sweeping behind the trophy */
+.fishbowl .wf-rays { position: absolute; inset: -40% -10% auto; height: 200%; z-index: -1; pointer-events: none;
+  background: conic-gradient(from 0deg at 50% 18%, transparent 0 8deg, hsl(var(--win-hue) 85% 60% / 0.14) 9deg 16deg, transparent 17deg 30deg);
+  background-size: 100% 100%; opacity: 0.7; animation: wfSpin 9s linear infinite; transform-origin: 50% 18%; }
+@keyframes wfSpin { to { transform: rotate(360deg); } }
+
+.fishbowl .wf-trophy { font-size: 56px; line-height: 1; filter: drop-shadow(0 0 18px hsl(var(--win-hue) 85% 62% / 0.85)); animation: wfTrophy 2.6s ease-in-out infinite; }
+@keyframes wfTrophy { 0%, 100% { transform: translateY(0) rotate(-4deg); } 50% { transform: translateY(-6px) rotate(4deg); } }
+
+.fishbowl .wf-eyebrow { font-family: var(--font-display); font-size: 10px; font-weight: 700; letter-spacing: 0.3em; text-transform: uppercase; color: hsl(var(--win-hue) 75% 72%); text-shadow: 0 0 12px hsl(var(--win-hue) 85% 60% / 0.6); }
+.fishbowl .wf-name { font-size: 30px; font-weight: 800; letter-spacing: 0.04em; line-height: 1.05; color: #fff; text-shadow: 0 0 22px hsl(var(--win-hue) 90% 65% / 0.9), 0 0 4px hsl(var(--win-hue) 90% 70% / 0.8); animation: wfShimmer 3.4s ease-in-out infinite; }
+@keyframes wfShimmer { 0%, 100% { text-shadow: 0 0 22px hsl(var(--win-hue) 90% 65% / 0.9), 0 0 4px hsl(var(--win-hue) 90% 70% / 0.8); } 50% { text-shadow: 0 0 34px hsl(var(--win-hue) 95% 68% / 1), 0 0 8px hsl(var(--win-hue) 95% 75% / 0.9); } }
+
+.fishbowl .wf-sub { display: flex; align-items: center; justify-content: center; gap: 9px; flex-wrap: wrap; margin-top: -2px; }
+.fishbowl .wf-arch { font-style: italic; font-size: 12px; color: var(--ink-dim); letter-spacing: 0.02em; }
+.fishbowl .wf-roster { display: flex; align-items: center; justify-content: center; gap: 7px; flex-wrap: wrap; }
+.fishbowl .wf-chip { font-family: var(--font-display); font-size: 9px; letter-spacing: 0.12em; text-transform: uppercase; color: hsl(var(--win-hue) 70% 78%); border: 1px solid hsl(var(--win-hue) 70% 60% / 0.4); background: hsl(var(--win-hue) 70% 50% / 0.1); border-radius: 999px; padding: 3px 10px; white-space: nowrap; }
+.fishbowl .wf-cheer { font-size: 12.5px; color: var(--ink); opacity: 0.92; margin-top: 4px; }
+.fishbowl .wf-loser { font-family: var(--font-display); font-size: 8.5px; letter-spacing: 0.16em; text-transform: uppercase; color: var(--ink-faint); }
+
+/* confetti — a finite phosphor burst; each bit falls once then clears the sky */
+.fishbowl .wf-confetti { position: absolute; inset: 0; overflow: hidden; pointer-events: none; }
+.fishbowl .wf-bit { position: absolute; top: -8vh; width: 8px; height: 13px; border-radius: 2px; opacity: 0; will-change: transform, opacity;
+  box-shadow: 0 0 8px currentColor; animation-name: wfFall; animation-timing-function: cubic-bezier(0.3, 0.1, 0.6, 1); animation-iteration-count: 1; animation-fill-mode: forwards; }
+.fishbowl .wf-bit.round { width: 9px; height: 9px; border-radius: 50%; }
+@keyframes wfFall {
+  0% { opacity: 0; transform: translate(0, 0) rotate(0deg); }
+  8% { opacity: 1; }
+  85% { opacity: 1; }
+  100% { opacity: 0; transform: translate(var(--wf-drift, 0), 118vh) rotate(var(--wf-rot, 360deg)); }
+}
+
+/* respect reduced-motion: keep the card, drop the spin/shimmer/confetti animation */
+@media (prefers-reduced-motion: reduce) {
+  .fishbowl .wf-card, .fishbowl .wf-rays, .fishbowl .wf-trophy, .fishbowl .wf-name, .fishbowl .wf-bit, .fishbowl .wf-backdrop { animation: none; }
+  .fishbowl .wf-x:hover { transform: none; }
+  .fishbowl .wf-bit { opacity: 0; }
+}
+
 /* ---- poke strip ---- */
 .fishbowl .poke-strip { display: flex; align-items: center; gap: 14px; padding: 10px 20px; border-top: 1px solid var(--line-soft); background: rgba(6,20,27,0.5); flex: none; }
 .fishbowl .poke-btns { display: flex; gap: 8px; flex: 1; flex-wrap: wrap; }
@@ -799,6 +879,13 @@ footer { display: none !important; }
 .fishbowl .transport { display: flex; align-items: center; gap: 16px; padding: 13px 22px; border-top: 1px solid var(--line); background: rgba(6,20,27,0.85); backdrop-filter: blur(10px); flex: none; }
 .fishbowl .tp-btns { display: flex; gap: 6px; }
 .fishbowl .icon-btn.play { border-color: var(--cyan); color: var(--cyan); box-shadow: var(--glow); }
+/* The curtain-call button: a text pill (not a square icon), amber like the judge's gavel. */
+.fishbowl .icon-btn.judge-now {
+  width: auto; min-width: 0; padding: 0 13px; gap: 6px;
+  font-family: var(--font-display); font-size: 10.5px; letter-spacing: 0.14em; text-transform: uppercase;
+  border-color: rgba(227,193,76,0.5); color: var(--amber);
+}
+.fishbowl .icon-btn.judge-now:hover { border-color: var(--amber); box-shadow: 0 0 14px rgba(227,193,76,0.35); color: var(--amber); }
 .fishbowl .scrub { flex: 1; }
 .fishbowl .tp-count { font-size: 12px; color: var(--ink-mid); white-space: nowrap; }
 .fishbowl .speed-seg .seg-b.on { color: var(--cyan); }

src/ui/fishbowl/render/winner.py

@@ -0,0 +1,149 @@
+"""The winner celebration — a one-shot, cheerful "champion" moment for the Show.
+
+This is the *modular* half of the verdict surface (ADR-0029).  The verdict banner
+(``render.meters.render_verdict``) is the sober ruling; this is the confetti.  It is a
+pure HTML string, gated on one thing: did the run declare a winner?  A ``none``-kind
+scenario (Wood, Oracle) never sets ``verdict.winner_label``, so ``render_winner`` returns
+``""`` and adds nothing to the page — the celebration is *opt-in by data*, not bolted onto
+every scenario.
+
+The card names the winning **bot**: for an agent win it shows the mind's archetype and the
+model that actually ran; for a team win it lines up the roster as chips and names the side
+it dethroned.  It tints itself with the winner's own hue (``hsl(var(--win-hue) …)``) so the
+champion of a teal mind glows teal.  No Gradio import — the same string feeds ``gr.HTML``
+today and a future JSON endpoint.
+"""
+
+from __future__ import annotations
+
+import html
+
+# The phosphor palette, in confetti form — cycles through the theme accents so the burst
+# reads as "our CRT theater is celebrating", not a generic party popper.
+_CONFETTI_COLORS = ("var(--lime)", "var(--cyan)", "var(--amber)", "var(--violet)", "var(--coral)")
+_CONFETTI_COUNT = 30
+
+
+def _pretty(slug: str) -> str:
+    """``spy-nil`` → ``Spy Nil`` — the same shape ``_winner_label`` uses for the ribbon."""
+    return slug.replace("-", " ").replace("_", " ").title()
+
+
+def _confetti() -> str:
+    """A finite burst of phosphor confetti.
+
+    Each bit falls exactly once (``animation-iteration-count: 1`` + ``forwards`` in the CSS),
+    so the sky clears after a few seconds and the champion card is left glowing on its own —
+    cheerful, not a perpetual distraction.  Geometry is index-derived (deterministic) so the
+    burst is stable across re-renders and trivial to snapshot in tests.
+    """
+    bits: list[str] = []
+    for i in range(_CONFETTI_COUNT):
+        color = _CONFETTI_COLORS[i % len(_CONFETTI_COLORS)]
+        left = (i * 37) % 100  # spread across the width without an even, mechanical comb
+        delay = round((i % 10) * 0.13, 2)  # stagger the fall so it rains, not drops as a sheet
+        dur = round(2.6 + (i % 6) * 0.32, 2)
+        drift = ((i * 53) % 140) - 70  # -70…70px lateral sway as it falls
+        rot = (i * 47) % 360
+        klass = "wf-bit round" if i % 3 == 0 else "wf-bit"
+        style = (
+            f"left:{left}%;background:{color};"
+            f"animation-delay:{delay}s;animation-duration:{dur}s;"
+            f"--wf-drift:{drift}px;--wf-rot:{rot}deg"
+        )
+        bits.append(f'<i class="{klass}" style="{style}"></i>')
+    return f'<div class="wf-confetti" aria-hidden="true">{"".join(bits)}</div>'
+
+
+def _chip(text: str) -> str:
+    return f'<span class="wf-chip">{html.escape(text)}</span>'
+
+
+def render_winner(vm: dict) -> str:
+    """The champion celebration — ``""`` until (and unless) the run declares a winner.
+
+    Reads ``vm["verdict"]`` (the same dict the banner uses) plus ``vm["cast"]`` /
+    ``vm["teams"]`` to name the winning bot.  Renders nothing when ``winner_label`` is
+    absent, which is every ``none``-kind scenario and any legacy verdict — that absence is
+    the modularity contract, so this can be composed into every Show without touching the
+    scenarios that have no winner to crown.
+    """
+    verdict = vm.get("verdict") or {}
+    label = verdict.get("winner_label")
+    if not label:
+        return ""
+
+    winner = verdict.get("winner")
+    kind = verdict.get("winner_kind")
+    correct = verdict.get("correct")
+    cast = vm.get("cast") or []
+    teams = vm.get("teams") or {}
+    by_id = {c.get("id"): c for c in cast}
+
+    # Default phosphor-lime hue, overridden by the winning bot's own hue so the card's glow
+    # matches the mind on the stage that just won.
+    hue = 95
+    sub = ""
+    roster = ""
+
+    if kind == "team":
+        members = [by_id[m] for m in (teams.get(winner) or []) if m in by_id]
+        if members:
+            hue = int(members[0].get("hue", hue))
+            chips = "".join(_chip(str(m.get("name", ""))) for m in members)
+            roster = f'<div class="wf-roster">{chips}</div>'
+    else:  # an individual mind took it
+        card = by_id.get(winner)
+        if card:
+            hue = int(card.get("hue", hue))
+            arch = str(card.get("archetype", "")).strip()
+            model = str(card.get("model", "")).strip()
+            parts = ""
+            if arch:
+                parts += f'<span class="wf-arch">{html.escape(arch)}</span>'
+            if model:
+                parts += f'<span class="wf-chip wf-model">{html.escape(model)}</span>'
+            sub = f'<div class="wf-sub">{parts}</div>' if parts else ""
+
+    # The losing side(s) — named only for team contests, where the roster makes "who lost"
+    # unambiguous. An agent/judged win has no single named loser, so we let it stand alone.
+    losers = [t for t in teams if t != winner] if kind == "team" else []
+    loser_line = (
+        f'<div class="wf-loser">outplayed {html.escape(", ".join("Team " + _pretty(t) for t in losers))}</div>'
+        if losers
+        else ""
+    )
+
+    # Ground-truth miss (the spy slipped past the herd): still a win for the spy, so we
+    # celebrate it — just with a wink instead of a trophy.
+    if correct is False:
+        glyph, eyebrow, cheer = "&#129399;", "Clean Getaway", "Slipped away without a trace."
+    elif kind == "team":
+        glyph, eyebrow, cheer = "&#127942;", "Champions", "They read the room — and won it."
+    else:
+        glyph, eyebrow, cheer = "&#127942;", "Champion", "The sharpest mind in the bowl."
+
+    # Dismissable with no JS (Gradio strips scripts/handlers from gr.HTML): a hidden
+    # checkbox is the toggle, and the backdrop + the ✕ button are <label>s that flip it.
+    # ``:checked`` then hides the whole overlay, which frees the pointer back to the
+    # transport. Re-rendering (e.g. a scrub) resets the checkbox, so the moment can replay.
+    return (
+        f'<div class="winner-fx" role="status" aria-live="polite" style="--win-hue:{hue}">'
+        # autocomplete=off so the browser never restores a stale "checked" (dismissed)
+        # state onto a freshly-rendered celebration — every new winner shows by default.
+        '<input type="checkbox" id="wf-dismiss" class="wf-dismiss" autocomplete="off" aria-hidden="true" tabindex="-1">'
+        '<label class="wf-backdrop" for="wf-dismiss" title="Dismiss"></label>'
+        f"{_confetti()}"
+        '<div class="wf-card">'
+        '<label class="wf-x" for="wf-dismiss" role="button" aria-label="Close celebration" title="Close">&#215;</label>'
+        '<div class="wf-rays" aria-hidden="true"></div>'
+        f'<div class="wf-trophy" aria-hidden="true">{glyph}</div>'
+        f'<div class="wf-eyebrow">{glyph} {eyebrow}</div>'
+        f'<div class="wf-name disp">{html.escape(str(label))}</div>'
+        f"{sub}"
+        f"{roster}"
+        f'<div class="wf-cheer">{cheer}</div>'
+        f"{loser_line}"
+        "</div>"
+        "</div>"
+    )

src/ui/fishbowl/session.py

@@ -112,6 +112,29 @@ 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 has_judge(self) -> bool:
+        """True when this cast has a judge that can be asked to rule.
+
+        The Show enables "Start judging" only when this holds, and the autoplay loop
+        consults it before bringing on the judge at a budget/turn limit (a cast with
+        no judge halts visibly instead)."""
+        return any(getattr(agent.manifest, "role", None) == "judge" for agent in self.scenario.agents)
+
+    def force_verdict(self) -> bool:
+        """Curtain call: silence the cast and have the judge rule on the whole run.
+
+        Delegates to :meth:`Conductor.force_verdict` (which reads every event of this
+        run and lands a ``judge.verdict`` even on a spent budget), then closes the run
+        with a ``run.finished`` so the winner is attributed (ADR-0029).  Returns True
+        when a verdict landed, False when the cast has no judge.  Idempotent — a second
+        call after a verdict is a no-op that returns True."""
+        with obs.span("session.force_verdict", **{"session.scenario": self._scenario_name}):
+            obs.log("session.force_verdict", scenario=self._scenario_name)
+            verdict = self.conductor.force_verdict()
+            if verdict is not None:
+                self.finalize("verdict")
+            return verdict is not None
+
     def finalize(self, reason: str) -> None:
         """Close the current run with a ``run.finished`` event (idempotent-safe).
 
@@ -265,6 +288,15 @@ class ReplaySession:
     def has_verdict(self) -> bool:
         return any(e.kind == "judge.verdict" for e in self._events)
 
+    def has_judge(self) -> bool:
+        # A replay owns no live engine, so it can never *call* a judge — but the
+        # recorded run may already carry its verdict.  Report on the recording.
+        return self.has_verdict()
+
+    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()
+
     @property
     def autoplay_tick_cap(self) -> int:
         return self.head

src/ui/fishbowl/show.py

@@ -107,6 +107,14 @@ def build_show() -> dict[str, object]:
                 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,

src/ui/fishbowl/view_model.py

@@ -168,6 +168,9 @@ def view_model_at(
         "voice_meta": {"name": voice_name, "desc": voice_desc},
         "speaking_id": speaking_id,
         "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.
+        "teams": teams,
         "rounds": rounds,
         "max_rounds": max_rounds,
         "tokens": _estimate_tokens_through(prefix),

tests/test_fishbowl_judging.py

@@ -0,0 +1,146 @@
+"""The curtain call — "Start judging" / limit-reached forced verdict (no mocks, offline stub).
+
+When the visitor presses *Start judging* (or a budget/turn limit ends the cast's run), the
+show stops the cast mid-flight and hands the floor to the judge, which reads the whole run
+ledger and lands a ``judge.verdict`` carrying a ``winner``.  These tests pin that contract on
+real offline sessions:
+
+  1. ``Conductor.force_verdict`` lands a verdict + winner — *even when the budget is spent*;
+  2. it silences the cast (drains the pending/trigger queues) and is idempotent;
+  3. a cast with no judge can't be forced (returns ``None`` / ``False``), never crashing;
+  4. ``FishbowlSession.force_verdict`` closes the run (``run.finished`` reason ``verdict``)
+     and the snapshot surfaces the ruling.
+"""
+
+from __future__ import annotations
+
+from src.core.governor import Governor
+from src.ui.fishbowl.session import FishbowlSession
+
+# A judged duel (has a judge) and a no-judge grove — the two halves of the contract.
+_JUDGED = "debate-duel"
+_NO_JUDGE = "oracle-grove"
+
+
+def _warm(scenario: str, *, governor: Governor | None = None, ticks: int = 6) -> FishbowlSession:
+    """A real session stepped a few times so there's a discussion for the judge to read."""
+    session = FishbowlSession(scenario)
+    if governor is not None:
+        session.conductor.governor = governor
+    session.reset()
+    for _ in range(ticks):
+        if session.has_verdict():
+            break
+        session.step_one()
+    return session
+
+
+# ── Conductor.force_verdict ──────────────────────────────────────────────────────
+
+
+def test_force_verdict_lands_a_verdict_with_a_winner() -> None:
+    session = _warm(_JUDGED)
+    assert not session.has_verdict()  # the judge hasn't ruled on its own yet
+    verdict = session.conductor.force_verdict()
+    assert verdict is not None
+    assert verdict.kind == "judge.verdict"
+    # The competition handler fills an offline winner deterministically (ADR-0029).
+    assert verdict.payload.get("winner")
+
+
+def test_force_verdict_rules_even_when_the_budget_is_spent() -> None:
+    # The whole point of the curtain call: a *limit* triggers it, so the judge must rule
+    # un-gated even though the governor that ended the show is already exhausted.
+    session = _warm(_JUDGED)
+    session.conductor.governor.max_total_calls = 0  # any further gated act would trip
+    verdict = session.conductor.force_verdict()
+    assert verdict is not None and verdict.kind == "judge.verdict"
+
+
+def test_force_verdict_silences_the_cast() -> None:
+    session = _warm(_JUDGED)
+    # Seed pending/trigger work so we can prove the curtain call drains it.
+    session.conductor._pending.append(session.conductor.scenario.agents[0])
+    session.conductor.force_verdict()
+    assert not session.conductor._pending
+    assert not session.conductor._trigger_queue
+
+
+def test_force_verdict_is_idempotent() -> None:
+    session = _warm(_JUDGED)
+    first = session.conductor.force_verdict()
+    verdicts_after_first = [e for e in session.events if e.kind == "judge.verdict"]
+    second = session.conductor.force_verdict()
+    verdicts_after_second = [e for e in session.events if e.kind == "judge.verdict"]
+    assert first is not None and second is not None
+    assert second.id == first.id  # same ruling returned, never re-judged
+    assert len(verdicts_after_first) == len(verdicts_after_second) == 1  # no duplicate
+
+
+def test_force_verdict_returns_none_without_a_judge() -> None:
+    session = _warm(_NO_JUDGE)
+    assert session.conductor.force_verdict() is None
+    assert not session.has_verdict()  # nothing was fabricated
+
+
+# ── FishbowlSession surface ────────────────────────────────────────────────────────
+
+
+def test_has_judge_reflects_the_cast() -> None:
+    assert _warm(_JUDGED, ticks=0).has_judge() is True
+    assert _warm(_NO_JUDGE, ticks=0).has_judge() is False
+
+
+def test_session_force_verdict_closes_the_run_with_the_winner() -> None:
+    session = _warm(_JUDGED)
+    assert session.force_verdict() is True
+    assert session.has_verdict()
+    # The run is closed and self-describing: run.finished, reason 'verdict', a named winner.
+    finished = [e for e in session.events if e.kind == "run.finished"]
+    assert len(finished) == 1
+    assert finished[0].payload.get("reason") == "verdict"
+    assert finished[0].payload.get("winner")
+    # The Show's snapshot surfaces the ruling for the verdict pane.
+    verdict_vm = session.snapshot().get("verdict")
+    assert verdict_vm and verdict_vm.get("winner")
+
+
+def test_session_force_verdict_false_without_a_judge() -> None:
+    session = _warm(_NO_JUDGE)
+    assert session.force_verdict() is False
+    assert not session.has_verdict()
+    # No judge → no premature run.finished from the curtain call.
+    assert not [e for e in session.events if e.kind == "run.finished"]
+
+
+# ── the budget-then-verdict attribution gap (run_index last-wins) ──────────────────
+
+
+def test_verdict_supersedes_a_winnerless_budget_close() -> None:
+    # The common limit path: the governor trips (run finalized "budget", no winner)
+    # BEFORE the judge rules.  The curtain call must still attribute the win — the
+    # leaderboard reads run.finished last-wins, so a corrective close is appended.
+    from src.core.run_index import index_runs
+
+    session = _warm(_JUDGED)
+    # Pre-finalize the run "budget" with no winner, exactly as a tripped step_one does.
+    session.conductor.finalize("budget")
+    pre = [e for e in session.events if e.kind == "run.finished"]
+    assert len(pre) == 1 and pre[0].payload.get("reason") == "budget"
+
+    assert session.force_verdict() is True
+    # A corrective run.finished now carries the verdict + winner; the leaderboard folds
+    # run.finished last-wins, so the indexed summary reads the ruling, not the truncation.
+    summary = next(s for s in index_runs(session.events) if s.run_id == session.conductor.run_id)
+    assert summary.reason == "verdict"
+    assert summary.winner
+
+
+def test_finalize_idempotent_for_nonbudget_close() -> None:
+    # The scoped supersede must NOT fire for a non-budget prior close: a user stop stands.
+    session = _warm(_JUDGED)
+    first = session.conductor.finalize("user_stop")
+    second = session.conductor.finalize("verdict", winner=session.scenario.agents[0].name)
+    assert first is not None and second is not None and first.id == second.id  # same event
+    finished = [e for e in session.events if e.kind == "run.finished"]
+    assert len(finished) == 1 and finished[0].payload.get("reason") == "user_stop"

tests/test_fishbowl_winner.py

@@ -0,0 +1,131 @@
+"""The winner celebration — a modular, opt-in-by-data champion overlay.
+
+Mirrors the verdict tests' discipline: the gate (no winner → empty string) is exercised
+against real offline snapshots, and the agent/team/ground-truth flavours against hand-built
+``vm`` dicts that match the shipped ``view_model_at`` contract.
+"""
+
+from __future__ import annotations
+
+from src.core.conductor import Conductor
+from src.core.ledger_factory import make_ledger
+from src.core.registry import default_registry
+from src.tools.builtins import default_tool_registry
+from src.ui.fishbowl import view_model_at
+from src.ui.fishbowl.render.winner import render_winner
+
+
+def _offline_vm(scenario: str = "thousand-token-wood") -> dict:
+    reg = default_registry()
+    c = Conductor(
+        reg.build_scenario(scenario, tools=default_tool_registry()),
+        governor=reg.governor_for(scenario),
+        ledger=make_ledger(),
+    )
+    c.reset(c.scenario.default_seed)
+    c.step(n_ticks=6)
+    cast = [a.manifest for a in c.scenario.agents]
+    return view_model_at(c.ledger.events, len(c.ledger.events), cast, scenario_name=scenario)
+
+
+class TestWinnerGate:
+    def test_empty_without_a_winner(self):
+        # missing verdict, explicit None, and a verdict with no winner all render nothing.
+        assert render_winner({}) == ""
+        assert render_winner({"verdict": None}) == ""
+        assert render_winner({"verdict": {"text": "Inconclusive.", "winner_label": None}}) == ""
+
+    def test_none_kind_scenario_stays_silent(self):
+        # a real no-winner run (the Wood) never crowns anyone → no celebration, ever.
+        assert render_winner(_offline_vm()) == ""
+
+
+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},
+            ],
+            "teams": {},
+            "verdict": {
+                "winner": "hypothesis-former",
+                "winner_label": "Hypothesis Former",
+                "winner_kind": "agent",
+                "correct": None,
+            },
+        }
+        vm["verdict"].update(over)
+        return vm
+
+    def test_names_the_winning_bot_with_model_and_archetype(self):
+        html = render_winner(self._vm())
+        assert 'class="winner-fx"' in html
+        assert "Hypothesis Former" in html  # the winner label, front and centre
+        assert "the analyst" in html  # its archetype
+        assert "Arch-Router-1.5B" in html  # the model that ran
+        assert "Champion" in html and "🏆" in html  # trophy flavour
+
+    def test_is_dismissable_via_backdrop_and_close_button(self):
+        # The celebration can be closed without JS: a hidden checkbox toggled by the
+        # backdrop (click-elsewhere) and the ✕ button, both <label for> the same control.
+        html = render_winner(self._vm())
+        assert 'class="wf-dismiss"' in html and 'id="wf-dismiss"' in html
+        assert 'class="wf-backdrop" for="wf-dismiss"' in html  # click-elsewhere to close
+        assert 'class="wf-x" for="wf-dismiss"' in html  # the styled ✕ button
+        assert html.count('for="wf-dismiss"') == 2
+
+    def test_tints_with_the_winning_bots_hue(self):
+        html = render_winner(self._vm())
+        assert "--win-hue:200" in html  # the analyst's hue drives the glow
+
+    def test_unknown_winner_id_still_celebrates_the_label(self):
+        # a winner not present in the cast (legacy/edge) still gets a card, just no chips.
+        html = render_winner(self._vm(winner="ghost", winner_label="Ghost"))
+        assert 'class="winner-fx"' in html
+        assert "Ghost" in html
+        assert "wf-model" not in html  # no model chip when the bot isn't in the cast
+
+
+class TestTeamWin:
+    def _vm(self, **over) -> dict:
+        vm = {
+            "cast": [
+                {"id": "spy-cara", "name": "spy-cara", "archetype": "the herd", "model": "M", "hue": 95},
+                {"id": "spy-bex", "name": "spy-bex", "archetype": "the herd", "model": "M", "hue": 95},
+                {"id": "spy-nil", "name": "spy-nil", "archetype": "the spy", "model": "M", "hue": 20},
+            ],
+            "teams": {"herd": ["spy-cara", "spy-bex"], "spy": ["spy-nil"]},
+            "verdict": {
+                "winner": "herd",
+                "winner_label": "Team Herd",
+                "winner_kind": "team",
+                "correct": True,
+            },
+        }
+        vm["verdict"].update(over)
+        return vm
+
+    def test_lines_up_the_roster_and_names_the_losing_side(self):
+        html = render_winner(self._vm())
+        assert "Team Herd" in html
+        assert "spy-cara" in html and "spy-bex" in html  # the winning roster as chips
+        assert "spy-nil" not in html  # the losing member is not lined up as a champion
+        assert "Team Spy" in html  # the dethroned side is named
+        assert "Champions" in html
+
+    def test_ground_truth_miss_is_a_clean_getaway(self):
+        # the spy slipped past the herd: still a win for the spy, celebrated with a wink.
+        html = render_winner(self._vm(winner="spy", winner_label="Team Spy", correct=False))
+        assert "Clean Getaway" in html
+        assert "&#129399;" in html  # raccoon, not trophy
+        assert "&#127942;" not in html
+
+
+class TestEscaping:
+    def test_label_is_escaped(self):
+        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