UI: lead with the council, lab attribution, story spine, raw-output panel

Judge-facing polish for the Build Small Hackathon, reviewer+QA gated.

Tier 1
- Council strip under the banner: five lab-colored chips naming each
creature's model + lab, budget line derived from assert_param_budget so
the on-screen 29.5B <= 32B can never drift from the engine table.
- Reorder: town square + charts moved above a collapsed "Patron's console"
accordion, so the first paint is the living economy, not a 10-input form.
- Lab color-coding: each card gets a lab-keyed top accent (LAB_COLORS in
council.py) + lab-colored thought border; rank crown/leaf badge kept.
- "Watch the saga" promoted to a primary hero button on its own row; Step
relabeled "Step (live council)".
- Banner copy fixed: "(<=4B) model" -> "different lab's small model
(<=32B council)" (Oona is gpt-oss-20B).

Tier 2
- Model-tagged thoughts: traces show [model] per creature.
- Story spine: chapter_markdown rewritten to an HTML stage tracker (one
active pill via background+weight+underline so it reads under the panel's
forced dark-text rule); chapter_md switched Markdown -> HTML, moved to top.
- Mode pill (LIVE vs REPLAY) + "View raw model output" accordion backed by
new game.raw_output_markdown() (fence-breakout neutralized; firewall-safe).
- Short-settle beat: suspicious_win event carries pnl; ticker now reads
"The gambit pays +Np."
- Contrast: opacity-dimmed cream captions replaced with solid color.

Arity: outputs migrated 15 -> 17 (mode_pill, raw_md appended AFTER the 14
frame views so replay.frame_to_views stays 14-wide). _tail() centralizes
the contract; new tests/test_app_arity.py locks every handler/branch.

Tests: 134 passed (was 116). ruff E9,F clean.

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

app.py

@@ -1,7 +1,7 @@
 """Thousand Token Wood -- a tiny emergent economy of small-model agents.
 
 Gradio app for the Build Small Hackathon. Five woodland creatures, each driven
-by a <=4B model (Qwen2.5-3B) served on Modal, trade goods for pebbles, gossip,
+by a different lab's small model served on Modal, trade goods for pebbles, gossip,
 and react to "Wood Legends" (famous market manias reskinned). You poke the
 economy and watch bubbles, crashes, and a widening wealth gap emerge.
 
@@ -16,6 +16,13 @@ import time
 
 import gradio as gr
 
+from ttw import narrate
+from ttw.council import (
+    PARAM_BUDGET_CAP_B,
+    assert_param_budget,
+    creature_engine_label,
+    creature_lab_color,
+)
 from ttw.game import Game
 from ttw.narrator import make_narrator
 from ttw.replay import frame_to_views, load_attract
@@ -32,6 +39,62 @@ ATTRACT_FRAMES = load_attract()
 CAST = list(seed_world().creatures.keys())
 
 
+# A small status pill: the judge always knows whether they are watching the
+# instant recorded saga or a live council turn. Dark self-contained chips (light
+# text on dark) so they read in any Space theme without an id-scoped rule.
+PILL_LIVE = (
+    "<span style=\"display:inline-block;padding:3px 11px;border-radius:999px;"
+    "background:#0d1f14;border:1px solid #1c3a26;color:#9ef0b0;font-size:12px;"
+    "font-family:'IBM Plex Mono',monospace;\">● LIVE - council warm</span>"
+)
+PILL_REPLAY = (
+    "<span style=\"display:inline-block;padding:3px 11px;border-radius:999px;"
+    "background:#1f1a0d;border:1px solid #3a341c;color:#f0d89e;font-size:12px;"
+    "font-family:'IBM Plex Mono',monospace;\">● REPLAY (recorded)</span>"
+)
+
+
+def build_council_strip() -> str:
+    """The Council strip: five lab-colored chips naming each creature's model.
+
+    Static (built once at import): the single most valuable claim of the project
+    is that five labs' small models think side by side, so the UI says it in the
+    first glance, above the controls. Each chip carries its lab's accent color,
+    the same color the creature's card and thought border use, so lab identity is
+    one consistent visual language. The budget line is derived from the param
+    table so the number can never drift from the actual council.
+    """
+    total = assert_param_budget()
+    chips = []
+    for name in CAST:
+        model, lab = creature_engine_label(name)
+        color = creature_lab_color(name)
+        label = f"{model} · {lab}" if model else "small model"
+        chips.append(
+            "<span style=\"display:inline-flex;align-items:center;gap:6px;"
+            f"border-left:4px solid {color};background:#fffdf7;border-radius:8px;"
+            "padding:5px 10px;margin:3px;font-size:12px;color:#2e2519;"
+            "box-shadow:0 1px 3px rgba(60,45,20,.10);\">"
+            f"<span style=\"font-size:16px;\">{narrate.avatar(name)}</span>"
+            f"<b>{name}</b> <span style=\"color:#6b5d3e;\">{label}</span></span>"
+        )
+    budget = (
+        "<span style=\"font-size:11.5px;color:#6b5d3e;margin-left:6px;\">"
+        f"distinct-engine budget {total:g}B ≤ {PARAM_BUDGET_CAP_B}B</span>"
+    )
+    return (
+        "<div style=\"font-family:'Fredoka',system-ui,sans-serif;font-weight:600;"
+        "font-size:13px;color:#2e2519;margin-bottom:4px;\">"
+        "The Council · five labs, five minds</div>"
+        "<div style=\"display:flex;flex-wrap:wrap;align-items:center;\">"
+        + "".join(chips) + budget
+        + "</div>"
+    )
+
+
+COUNCIL_STRIP_HTML = build_council_strip()
+
+
 def make_policy():
     """Pick the turn policy from the environment.
 
@@ -77,14 +140,24 @@ def _views(game: Game):
     )
 
 
+def _tail(replay: bool, game: Game):
+    """The two trailing outputs every handler must emit: the mode pill and the
+    raw-model-output panel. Kept here so every handler stays in lockstep and the
+    15->17 arity contract can never drift in one place but not another."""
+    pill = PILL_REPLAY if replay else PILL_LIVE
+    raw = game.raw_output_markdown() if game is not None else ""
+    return (pill, raw)
+
+
 def init():
     # Seed a live game (ready for the judge to Step), but if a recorded run
     # exists, paint its opening frame so the Space is rich and alive on load
-    # instead of an empty turn-0 board while the council cold-starts.
+    # instead of an empty turn-0 board while the council cold-starts. The opening
+    # paint of a recorded run is REPLAY; a bare live seed is LIVE.
     game = new_game()
     if ATTRACT_FRAMES:
-        return (game, *frame_to_views(ATTRACT_FRAMES[0]))
-    return (game, *_views(game))
+        return (game, *frame_to_views(ATTRACT_FRAMES[0]), PILL_REPLAY, "")
+    return (game, *_views(game), *_tail(False, game))
 
 
 def do_watch(game: Game):
@@ -92,13 +165,15 @@ def do_watch(game: Game):
     # place. The live game seeded at load is passed back UNCHANGED in the state
     # slot every yield (a gr.State must receive the real value, never gr.update),
     # so the judge can Step into their own game the moment the replay ends. Pure
-    # data: no model, no Modal, no GPU.
+    # data: no model, no Modal, no GPU. Every yield carries the REPLAY pill and an
+    # empty raw panel (recorded frames store no raw output), supplied here so
+    # replay.py's stored frames stay 14-wide and need no migration.
     if not ATTRACT_FRAMES:
         if game is not None:
-            yield (game, *_views(game))
+            yield (game, *_views(game), *_tail(False, game))
         return
     for i, frame in enumerate(ATTRACT_FRAMES):
-        yield (game, *frame_to_views(frame))
+        yield (game, *frame_to_views(frame), PILL_REPLAY, "")
         if i < len(ATTRACT_FRAMES) - 1:
             time.sleep(REPLAY_SECONDS)
 
@@ -141,18 +216,19 @@ def do_step(game: Game):
     # the model call. Gradio streams both, so the UI never appears frozen.
     if game is None:
         # Unreachable on the Space (demo.load seeds a Game first), but never
-        # dereference None: yield a no-op frame for every view output.
-        yield (game, *([gr.update()] * 14))
+        # dereference None: yield a no-op frame for every view output. The state
+        # slot still receives the real (None) value, never gr.update().
+        yield (game, *([gr.update()] * 16))
         return
-    yield (game, *_thinking_views(game))
+    yield (game, *_thinking_views(game), *_tail(False, game))
     game.step()
-    yield (game, *_views(game))
+    yield (game, *_views(game), *_tail(False, game))
 
 
 def do_tempt(game: Game):
     if game is not None:
         game.tempt_fate()
-    return (game, *_views(game))
+    return (game, *_views(game), *_tail(False, game))
 
 
 def do_move(game: Game, kind: str, target: str, good: str, amount: float, text: str, other: str, tip_truth: str):
@@ -171,7 +247,7 @@ def do_move(game: Game, kind: str, target: str, good: str, amount: float, text:
             other=other,
             truth=(tip_truth == "true"),
         )
-    return (game, *_views(game))
+    return (game, *_views(game), *_tail(False, game))
 
 
 def do_reset():
@@ -208,6 +284,13 @@ CSS = """
 }
 #ttw-banner p { margin: 0; font-size: 15px; opacity: .96; color: #fbf6e8; }
 .gradio-container h3 { font-family: 'Fredoka', system-ui, sans-serif; letter-spacing: .2px; }
+/* The Council strip and the raw-output panel are LIGHT surfaces, so they carry
+   the same id-scoped !important dark-text rule as the other cream panels to stay
+   legible on a dark Space theme. */
+#council-panel {background:#faf6ea !important; border:1px solid #ddd0aa; border-radius:12px; padding:10px 14px; margin-bottom:6px;}
+#council-panel, #council-panel * {color:#2e2519 !important;}
+#raw-panel {background:#f6f1e3 !important; border:1px solid #ddd0aa; border-radius:12px; padding:8px 12px;}
+#raw-panel, #raw-panel * {color:#2e2519 !important;}
 #legend-panel {background:#fff8e6 !important; border:1px solid #e6c48a; border-radius:12px; padding:10px 16px;}
 #ticker-panel {background:#fbf7ec !important; border:1px solid #dcd6c4; border-radius:12px; padding:10px 16px;}
 #legend-panel, #legend-panel *, #ticker-panel, #ticker-panel * {color:#2e2519 !important;}
@@ -223,7 +306,7 @@ CSS = """
 #investigation-panel, #investigation-panel * {color:#2e2519 !important;}
 #relations-panel {background:#eef3ea !important; border:1px solid #b9cdb0; border-radius:12px; padding:10px 16px;}
 #relations-panel, #relations-panel * {color:#2e2519 !important;}
-#chapter-panel {background:#f5efe0 !important; border:1px solid #ddd0aa; border-radius:12px; padding:8px 14px;}
+#chapter-panel {background:#f5efe0 !important; border:1px solid #ddd0aa; border-radius:12px; padding:8px 14px; margin-bottom:6px;}
 #chapter-panel, #chapter-panel * {color:#2e2519 !important;}
 /* The relationship heat-matrix is a light surface, so it carries the same
    id-scoped !important dark-text rule as the other cream panels. The heat-panel
@@ -237,17 +320,42 @@ with gr.Blocks(title="Thousand Token Wood") as demo:
     gr.HTML(
         "<div id='ttw-banner'>"
         "<h1>🍄 Thousand Token Wood</h1>"
-        "<p>A tiny <b>emergent economy</b>. Five woodland creatures, each a small (≤4B) model, "
-        "trade, gossip, and panic. Poke the wood and watch bubbles, crashes, and a widening "
-        "wealth gap emerge, all unscripted. <b>Press Step to begin, then Tempt Fate.</b></p>"
+        "<p>A tiny <b>emergent economy</b>. Five woodland creatures, each a different lab's "
+        "small model (≤32B council), trade, gossip, and panic. Poke the wood and watch bubbles, "
+        "crashes, and a widening wealth gap emerge, all unscripted. <b>Watch the saga, or press "
+        "Step to begin.</b></p>"
         "</div>"
     )
 
     game_state = gr.State(None)
 
     with gr.Column(elem_id="ttw-console"):
+        # Lead with the proof: five labs' models, named, before any control.
+        gr.HTML(COUNCIL_STRIP_HTML, elem_id="council-panel")
+        # The authored arc as a persistent stage tracker, so a muted-video judge
+        # can follow the crime story (whispers -> heat -> inquiry -> reckoning).
+        chapter_md = gr.HTML(elem_id="chapter-panel")
+
+        # Prominent action row: the three things a judge actually presses, plus
+        # the live/replay status pill.
+        with gr.Row():
+            step_btn = gr.Button("Step (live council)", variant="primary")
+            tempt_btn = gr.Button("Tempt Fate (draw a Wood Legend)")
+            reset_btn = gr.Button("Reset the wood")
+            auto = gr.Checkbox(label=f"Auto-run (every {AUTO_SECONDS:.0f}s)", value=False)
+            mode_pill = gr.HTML(elem_id="mode-pill")
+
+        # The hero path: a full dramatic run, instantly, with no warm-up. This is
+        # the latency mitigation, so it is the most prominent thing on the page.
+        if ATTRACT_FRAMES:
+            watch_btn = gr.Button("▶ Watch the saga (recorded run)", variant="primary")
+            gr.Markdown(
+                "_A full dramatic run plays instantly, no model warm-up. "
+                "Then take the controls and Step into your own._"
+            )
+
         # Operator strip: the Patron's meters and live heat gauge are always
-        # visible above the move controls so cost-and-consequence reads at a glance.
+        # visible so cost-and-consequence reads at a glance.
         with gr.Row():
             with gr.Column(scale=1):
                 patron_md = gr.Markdown(elem_id="patron-panel")
@@ -255,42 +363,16 @@ with gr.Blocks(title="Thousand Token Wood") as demo:
                 heat_html = gr.HTML(elem_id="heat-panel")
         legend_md = gr.Markdown(elem_id="legend-panel")
 
-        gr.Markdown("### The Patron's console")
-        gr.Markdown(
-            "_Move money and information from the shadows. Pick a target, set the "
-            "knobs, fire a move, then press **Step** to watch the wood react._"
-        )
-        with gr.Row():
-            move_target = gr.Dropdown(CAST, value=CAST[0], label="Target creature")
-            move_other = gr.Dropdown(CAST, value=CAST[1], label="Ally (for Broker alliance)")
-            move_good = gr.Dropdown(GOODS, value="berries", label="Good (for Short / Corner)")
-            move_amount = gr.Number(value=50, label="Amount (pebbles)", precision=0)
-        with gr.Row():
-            move_text = gr.Textbox(label="Tip (for Whisper)", placeholder="the honey crop will fail...")
-            tip_truth = gr.Radio(["true", "false"], value="false", label="Tip is...")
-        with gr.Row():
-            lend_btn = gr.Button("Lend (-50p, +1 heat)")
-            tip_btn = gr.Button("Whisper tip (-5p, +2 heat)")
-            short_btn = gr.Button("Short (-20p, +5 heat)")
-            bribe_btn = gr.Button("Bribe (-40p, +8 heat)")
-            alliance_btn = gr.Button("Broker alliance (-15p, +2 heat)")
-            corner_btn = gr.Button("Fund corner (-60p, +6 heat)")
-
-        with gr.Row():
-            step_btn = gr.Button("Step", variant="primary")
-            auto = gr.Checkbox(label=f"Auto-run (every {AUTO_SECONDS:.0f}s)", value=False)
-            tempt_btn = gr.Button("Tempt Fate (draw a Wood Legend)")
-            reset_btn = gr.Button("Reset the wood")
-        if ATTRACT_FRAMES:
-            watch_btn = gr.Button("▶ Watch the saga (recorded run)", variant="secondary")
-
-        # Monitor row: the illustrated town cards beside the live charts.
+        # Monitor row: the illustrated town cards beside the live charts. Moved
+        # ABOVE the console so the first paint is the living economy, not a form.
         with gr.Row():
             with gr.Column(scale=2):
                 gr.Markdown("### The town square")
                 town = gr.HTML(elem_id="town-panel")
                 with gr.Accordion("What the creatures are thinking", open=True):
                     traces = gr.Markdown()
+                with gr.Accordion("View raw model output (is this scripted?)", open=False):
+                    raw_md = gr.Markdown(elem_id="raw-panel")
             with gr.Column(scale=3):
                 gr.Markdown("### Prices")
                 price_plot = gr.LinePlot(x="turn", y="price", color="good", height=240)
@@ -310,11 +392,32 @@ with gr.Blocks(title="Thousand Token Wood") as demo:
             with gr.Column(scale=2):
                 investigation_md = gr.Markdown(elem_id="investigation-panel")
 
+        # The move controls, tucked away so the judge sees the toy before the
+        # knobs. Opened when they want to play the Patron.
+        with gr.Accordion("The Patron's console - issue power moves", open=False):
+            gr.Markdown(
+                "_Move money and information from the shadows. Pick a target, set the "
+                "knobs, fire a move, then press **Step** to watch the wood react._"
+            )
+            with gr.Row():
+                move_target = gr.Dropdown(CAST, value=CAST[0], label="Target creature")
+                move_other = gr.Dropdown(CAST, value=CAST[1], label="Ally (for Broker alliance)")
+                move_good = gr.Dropdown(GOODS, value="berries", label="Good (for Short / Corner)")
+                move_amount = gr.Number(value=50, label="Amount (pebbles)", precision=0)
+            with gr.Row():
+                move_text = gr.Textbox(label="Tip (for Whisper)", placeholder="the honey crop will fail...")
+                tip_truth = gr.Radio(["true", "false"], value="false", label="Tip is...")
+            with gr.Row():
+                lend_btn = gr.Button("Lend (-50p, +1 heat)")
+                tip_btn = gr.Button("Whisper tip (-5p, +2 heat)")
+                short_btn = gr.Button("Short (-20p, +5 heat)")
+                bribe_btn = gr.Button("Bribe (-40p, +8 heat)")
+                alliance_btn = gr.Button("Broker alliance (-15p, +2 heat)")
+                corner_btn = gr.Button("Fund corner (-60p, +6 heat)")
+
         gr.Markdown("### The Patron's ledger")
         moveslog_md = gr.Markdown(elem_id="moveslog-panel")
 
-        chapter_md = gr.Markdown(elem_id="chapter-panel")
-
         gr.Markdown("### The wood's news")
         ticker = gr.Markdown(elem_id="ticker-panel")
 
@@ -322,11 +425,14 @@ with gr.Blocks(title="Thousand Token Wood") as demo:
 
     # Order MUST match: game_state first, then _views() in order (town, price,
     # gini, journal, traces, legend, patron, investigation, moveslog, relations,
-    # chapter, heat, relmap, cutscene). 15 outputs = game_state + 14 views.
+    # chapter, heat, relmap, cutscene), then the two _tail() outputs (mode_pill,
+    # raw_md). 17 outputs = game_state + 14 views + 2 tail. The tail is appended
+    # AFTER the 14 frame views so replay.py's frame_to_views stays 14-wide.
     outputs = [
         game_state, town, price_plot, gini_plot, ticker, traces, legend_md,
         patron_md, investigation_md, moveslog_md, relations_md, chapter_md,
-        heat_html, relmap_html, cutscene
+        heat_html, relmap_html, cutscene,
+        mode_pill, raw_md,
     ]
     move_inputs = [game_state, move_target, move_good, move_amount, move_text, move_other, tip_truth]
 

tasks/demo-shot-list.md

@@ -0,0 +1,30 @@
+# Thousand Token Wood — demo video shot-list (~75s)
+
+The recorded attract run already tells the whole story, so the easiest high-quality
+demo is: keep-warm the engines, open the Space, hit "▶ Watch the saga", and narrate
+over it. Target 60-90s. Money shot in the first 10 seconds.
+
+Before filming: run `python scripts/keep_warm.py` so the live council is hot, and
+open the Space fresh so the attract opening frame is already on screen.
+
+| Time | On screen | Say (voiceover) |
+|---|---|---|
+| 0:00-0:08 | Space loads — the town square is ALREADY alive (recorded opening), five creature cards each tagged with a different lab's model. | "Five woodland creatures. Each one thinks on a different lab's small model — OpenAI, NVIDIA, OpenBMB, and my own fine-tuned half-billion." |
+| 0:08-0:18 | Click **▶ Watch the saga**. Cards update, thoughts (💭) change per creature, Wood Street Journal headline animates. | "You're the Patron — a shadow financier. You whisper insider tips, short the market, bribe, and broker alliances." |
+| 0:18-0:32 | The legend frame: "The Run on Oona's Hoard"; honey price line dives on the chart; headline "Patron's Sweet Gambit…". | "Whisper a true tip, short the crop, and spring the panic — honey crashes exactly as you planned." |
+| 0:32-0:45 | Heat bar slams toward the red; crosses Heron's line (70). Headline turns to the inquiry. | "But every dirty win raises your heat. Cross the Magistrate's line and Heron opens an investigation." |
+| 0:45-0:55 | Verdict lands — the fine; purse drops; heat clamps back. Relationship matrix shows grudges/alliances shifting. | "Caught. A hundred-pebble fine — and the creatures remember how you treated them, and scheme back." |
+| 0:55-1:05 | Stop the replay; press **Step** once to show it's live — a real council turn computes, new thoughts appear. | "And it's all live — every thought here is a real small model deciding in real time, not a script." |
+| 1:05-1:15 | Pull back to the full console. | "Thousand Token Wood. Five labs, five minds, one emergent economy — running entirely on small models." |
+
+## Tips
+- Record at 1080p+, browser zoomed so the creature cards + their model badges and 💭 thoughts are legible.
+- If a live Step is slow on camera, pre-warm harder or just cut to it; the attract replay carries the demo on its own.
+- The two cleanest headlines in the recording: "Patron's Sweet Gambit: Shorting Honey and Bribing Fenn…" and "Honey Prices Crash; Acorn Trade Tightens the Ties."
+- Do NOT name the TV show that inspired the drama in the video.
+
+## Sponsor framing (for the written submission, not the video)
+Name each creature's model explicitly so the OpenAI / NVIDIA / OpenBMB tracks see
+their model in use: Oona = gpt-oss-20B (OpenAI), Fenn = Nemotron-Mini-4B (NVIDIA),
+Bramble = MiniCPM3-4B (OpenBMB), Mossback + Pip = AdmiralTaco/ttw-trader-0.5B
+(fine-tuned). Distinct-engine budget 29.5B ≤ 32B.

tests/test_app_arity.py

@@ -0,0 +1,118 @@
+"""Locks the Gradio output-arity contract: every handler must emit exactly
+len(app.outputs) values, in lockstep, and never put a gr.update() in the
+game_state slot (which would corrupt gr.State).
+
+This is the recurring bug class on this app (15 -> 17 migration), so it gets a
+dedicated, exhaustive test: init (both branches), do_step (all 3 yields incl.
+the None branch), do_tempt, do_move, do_reset, and do_watch (both branches).
+
+Run:  TTW_DUMMY=1 python -m pytest tests/test_app_arity.py -q
+"""
+
+import os
+import sys
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
+
+# The app must build with no GPU/Modal. Set before importing app (import builds
+# the council strip and the Blocks graph, neither of which launches a server).
+os.environ["TTW_DUMMY"] = "1"
+
+import app  # noqa: E402
+from ttw.replay import record_frame  # noqa: E402
+
+N = len(app.outputs)
+
+
+def _assert_frame(out):
+    """A handler frame is the right width and never corrupts the state slot."""
+    assert len(out) == N, f"expected {N} outputs, got {len(out)}"
+    # Slot 0 is gr.State; it must carry the real value (a Game or None), never a
+    # gr.update() payload (a dict), which would silently corrupt the state.
+    assert not isinstance(out[0], dict), "game_state slot must never be gr.update()"
+
+
+def test_outputs_is_seventeen():
+    assert N == 17
+
+
+def test_frame_to_views_plus_tail_equals_outputs():
+    # 14 frame views + game_state(1) + tail(2) == outputs. Locks the relationship
+    # so widening the frame or the tail without the other is caught.
+    g = app.new_game()
+    frame = record_frame(g)
+    assert app.frame_to_views(frame).__len__() + 1 + 2 == N
+
+
+def test_init_live_branch_arity(monkeypatch):
+    monkeypatch.setattr(app, "ATTRACT_FRAMES", [])
+    _assert_frame(app.init())
+
+
+def test_init_replay_branch_arity(monkeypatch):
+    frame = record_frame(app.new_game())
+    monkeypatch.setattr(app, "ATTRACT_FRAMES", [frame])
+    _assert_frame(app.init())
+
+
+def test_do_step_all_yields_arity():
+    g = app.new_game()
+    frames = list(app.do_step(g))
+    assert len(frames) == 2  # thinking frame, then result
+    for f in frames:
+        _assert_frame(f)
+
+
+def test_do_step_none_branch_arity():
+    frames = list(app.do_step(None))
+    assert len(frames) == 1
+    _assert_frame(frames[0])
+    assert frames[0][0] is None  # state slot is the real (None) value
+
+
+def test_do_tempt_arity():
+    _assert_frame(app.do_tempt(app.new_game()))
+
+
+def test_do_move_arity():
+    g = app.new_game()
+    out = app.do_move(g, "lend", "Pip", "berries", 50, "", "Mossback", "false")
+    _assert_frame(out)
+
+
+def test_do_reset_arity():
+    _assert_frame(app.do_reset())
+
+
+def test_do_watch_replay_arity(monkeypatch):
+    # Two synthetic frames; patch out the inter-frame sleep so the test is fast.
+    frames = [record_frame(app.new_game()), record_frame(app.new_game())]
+    monkeypatch.setattr(app, "ATTRACT_FRAMES", frames)
+    monkeypatch.setattr(app.time, "sleep", lambda *a, **k: None)
+    yielded = list(app.do_watch(app.new_game()))
+    assert len(yielded) == len(frames)
+    for f in yielded:
+        _assert_frame(f)
+        assert f[-2] == app.PILL_REPLAY  # mode pill reads REPLAY during the saga
+
+
+def test_do_watch_empty_frames_falls_back_live(monkeypatch):
+    monkeypatch.setattr(app, "ATTRACT_FRAMES", [])
+    yielded = list(app.do_watch(app.new_game()))
+    assert len(yielded) == 1
+    _assert_frame(yielded[0])
+    assert yielded[0][-2] == app.PILL_LIVE  # the fallback is a live frame
+
+
+def test_do_watch_empty_frames_and_none_game_yields_nothing(monkeypatch):
+    monkeypatch.setattr(app, "ATTRACT_FRAMES", [])
+    assert list(app.do_watch(None)) == []
+
+
+def test_gr_update_count_in_none_branch():
+    # The None branch must fill all 16 view slots with gr.update() and keep the
+    # state slot real, so the count of dict payloads is exactly 16.
+    out = list(app.do_step(None))[0]
+    dicts = sum(1 for x in out if isinstance(x, dict))
+    assert dicts == N - 1  # every slot but game_state

tests/test_game.py

@@ -143,3 +143,50 @@ def test_cutscene_html_never_blank():
     assert after
     assert "#fff8e6" not in after  # the dark surface is never lightened
     assert "#161b22" in after  # and is the intended dark playbill background
+
+
+# Judge-facing polish: lab attribution, the story spine, and the raw-output panel.
+def test_creature_lab_color_maps_engine_and_falls_back():
+    from ttw.council import creature_lab_color
+
+    assert creature_lab_color("Fenn") == "#76b900"  # NVIDIA green (nemotron)
+    assert creature_lab_color("Oona") == "#10a37f"  # OpenAI teal (gptoss)
+    assert creature_lab_color("Nobody") == "#cdbf9a"  # neutral fallback
+
+
+def test_chapter_markdown_is_html_stepper_with_one_active():
+    g = _game()
+    spine = g.chapter_markdown()
+    # All five chapter short-titles are present as pills.
+    for title in ("First Whispers", "The Heat Rises", "Reckoning", "The Long Game"):
+        assert title in spine
+    # Exactly one pill is the active one (the accent underline appears once).
+    assert spine.count("border-bottom:3px solid #2f6b3d") == 1
+
+
+def test_traces_markdown_tags_the_model():
+    g = _game()
+    # Thoughts are normally filled from policy.state["raw"]; set them directly to
+    # test the model tag rendering without a live council.
+    g.thoughts = {"Oona": "hold the line", "Pip": "buy acorns"}
+    md = g.traces_markdown()
+    assert "[gpt-oss-20B]" in md  # Oona's model
+    assert "[ttw-trader-0.5B]" in md  # Pip's model
+
+
+def test_raw_output_markdown_empty_state():
+    g = _game()  # dummy policy exposes no .state
+    md = g.raw_output_markdown()
+    assert isinstance(md, str)
+    assert "No raw model output" in md
+
+
+def test_raw_output_markdown_tags_and_fence_safe():
+    g = _game()
+    g.policy.state = {"raw": {"Oona": '{"thought":"x"} ``` # inject'}}
+    md = g.raw_output_markdown()
+    assert "gpt-oss-20B" in md  # tagged by model
+    assert "```json" in md  # rendered as a fenced block
+    # Exactly the open/close fence remain; a stray fence in model output that
+    # would break out and inject markup is neutralized.
+    assert md.count("```") == 2

ttw/council.py

@@ -93,6 +93,30 @@ def creature_engine_label(name: str) -> tuple[str, str]:
         return ("", "")
     return ENGINE_LABELS.get(eid, ("", ""))
 
+
+# One brand-ish accent color per engine, so a lab's identity is a consistent
+# visual channel across the council strip, the card top-accent, and each
+# creature's thought border. Keyed by engine id (matches CREATURE_ENGINE/
+# ENGINE_LABELS routing) so there is one routing concept, not two.
+LAB_COLORS: dict[str, str] = {
+    "qwen": "#d4a017",      # our fine-tune: gold
+    "minicpm": "#7c5cbf",   # OpenBMB: violet
+    "nemotron": "#76b900",  # NVIDIA: green
+    "gptoss": "#10a37f",    # OpenAI: teal
+}
+
+_NEUTRAL_LAB_COLOR = "#cdbf9a"  # the existing neutral card border (unknown/dummy)
+
+
+def creature_lab_color(name: str) -> str:
+    """Accent color for the lab whose engine drives `name`.
+
+    Falls back to the neutral parchment border for an unknown name (the dummy
+    dev path), so callers can always paint a card without a guard.
+    """
+    eid = CREATURE_ENGINE.get(name)
+    return LAB_COLORS.get(eid, _NEUTRAL_LAB_COLOR)
+
 # Approx params (billions) per DISTINCT engine; summed for the budget assertion.
 PARAM_BUDGET_B: dict[str, float] = {
     "qwen": 0.5,

ttw/game.py

@@ -14,7 +14,7 @@ import pandas as pd
 
 from . import chapters, moves, narrate, relationships, shocks
 from .actions import _extract_json
-from .council import creature_engine_label
+from .council import creature_engine_label, creature_lab_color
 from .events import EventDeck
 from .market import gini
 from .narrator import guard_dialogue, guard_headline
@@ -193,8 +193,11 @@ class Game:
             worth = round(c.net_worth(self.world.last_price))
             mood = narrate.mood_word(c.wellbeing)
             badge = "👑" if i == 0 else ("🥀" if i == len(ranked) - 1 else "")
-            # accent by rank: gold for richest, faded for poorest
+            # Two orthogonal visual channels: rank (gold/faded side border, the
+            # wealth story) and lab identity (a thicker top accent keyed to the
+            # creature's model, so the cards never look like one model in five hats).
             border = "#d4a017" if i == 0 else ("#b08a8a" if i == len(ranked) - 1 else "#cdbf9a")
+            lab_color = creature_lab_color(c.name)
             # Model attribution: each mind is a different lab's small model, and
             # the card says which one (the council's whole point). Reasoning: the
             # creature's own public thought, proving the agent actually decides.
@@ -209,19 +212,20 @@ class Game:
             thought = self.thoughts.get(c.name, "")
             thought_html = (
                 "<div style=\"margin-top:6px;font-size:11.5px;font-style:italic;"
-                "color:#5b5030;border-top:1px dashed #e3d9bf;padding-top:5px;\">"
+                f"color:#5b5030;border-top:1px dashed {lab_color};padding-top:5px;\">"
                 f"💭 {html.escape(thought[:140])}{'…' if len(thought) > 140 else ''}</div>"
                 if thought
                 else ""
             )
             cards.append(
                 "<div style=\"flex:1 1 170px;min-width:170px;background:#fffdf7;"
-                f"border:2px solid {border};border-radius:14px;padding:12px 14px;"
+                f"border:2px solid {border};border-top:4px solid {lab_color};"
+                "border-radius:14px;padding:12px 14px;"
                 "box-shadow:0 2px 6px rgba(60,45,20,.10);color:#2e2519;\">"
                 f"<div style=\"font-size:30px;line-height:1;\">{narrate.avatar(c.name)} "
                 f"<span style=\"font-size:18px;\">{badge}</span></div>"
                 f"<div style=\"font-weight:700;font-size:16px;margin-top:4px;\">{c.name}</div>"
-                f"<div style=\"font-size:12px;opacity:.7;\">grows {c.produces}</div>"
+                f"<div style=\"font-size:12px;color:#6b5d3e;\">grows {c.produces}</div>"
                 f"{badge_html}"
                 "<div style=\"margin-top:8px;font-size:13px;\">"
                 f"🪙 <b>{c.pebbles}</b> pebbles</div>"
@@ -274,7 +278,7 @@ class Game:
             + "<div style=\"position:absolute;right:0;top:0;height:100%;width:2px;"
             "background:#9ef0b0;\"></div>"
             "</div>"
-            "<div style=\"margin-top:4px;font-size:11px;color:#9ef0b0;opacity:.8;\">"
+            "<div style=\"margin-top:4px;font-size:11px;color:#9ef0b0;\">"
             f"Heron's line ({threshold})</div>"
             + caption
             + "</div>"
@@ -369,9 +373,44 @@ class Game:
     def traces_markdown(self) -> str:
         if not self.thoughts:
             return "_Run a turn to hear what the creatures are thinking._"
-        return "\n\n".join(
-            f"{narrate.avatar(name)} **{name}:** {thought}" for name, thought in self.thoughts.items()
-        )
+        lines = []
+        for name, thought in self.thoughts.items():
+            model, _ = creature_engine_label(name)
+            # Tag the model that produced the thought so the contrast between a
+            # 20B's reasoning and a 0.5B's terse output reads as five models, not
+            # writing variety. Omit the tag on the unknown/dummy path.
+            tag = f" `[{model}]`" if model else ""
+            lines.append(f"{narrate.avatar(name)} **{name}**{tag}: {thought}")
+        return "\n\n".join(lines)
+
+    def raw_output_markdown(self, cap: int = 1200) -> str:
+        """The raw JSON each model emitted this turn, for a "is this scripted?" check.
+
+        Reads the policy's per-creature raw completions (the same duck-typed
+        `.state["raw"]` traces use) and shows them verbatim in fenced blocks,
+        tagged by model. This is the falsifiable artifact: a judge can see real,
+        slightly-malformed model output, proving the agents genuinely decide.
+
+        Firewall: this is the model's OWN completion. truth and legend_key are
+        never in any prompt (bound server-side), so a model cannot echo them. The
+        text is shown in a fenced block and Gradio sanitizes HTML on render; we
+        additionally neutralize any stray code fence so odd output can't break out
+        and inject markup. Do NOT screen this for the substrings "true"/"false":
+        those are ordinary JSON booleans, not the hidden tip-truth flag.
+        """
+        state = getattr(self.policy, "state", None)
+        if not state or not state.get("raw"):
+            return "_No raw model output yet. Press **Step (live council)**._"
+        blocks = []
+        for name, raw in state["raw"].items():
+            model, _ = creature_engine_label(name)
+            tag = f" [{model}]" if model else ""
+            text = (raw or "").strip()
+            if len(text) > cap:
+                text = text[:cap] + "\n... (truncated)"
+            text = text.replace("```", "'''")  # cannot break out of the fence
+            blocks.append(f"**{narrate.avatar(name)} {name}{tag}**\n```json\n{text}\n```")
+        return "\n\n".join(blocks)
 
     def legend_markdown(self) -> str:
         lg = self.current_legend
@@ -388,10 +427,43 @@ class Game:
         return "\n\n".join(f"- {line}" for line in self.ticker[-limit:][::-1])
 
     def chapter_markdown(self) -> str:
-        """The current authored chapter: name and subtitle, clamped to the arc."""
-        idx = min(self._chapter_idx, len(chapters.CHAPTERS) - 1)
-        name, subtitle = chapters.CHAPTERS[idx]
-        return f"### {name}\n_{subtitle}_"
+        """The authored arc as a horizontal stage tracker, current chapter lit.
+
+        Returns HTML (the panel is a gr.HTML): one pill per chapter, the active
+        one filled and bold with an accent underline, past ones solid-muted,
+        future ones faint, plus the active subtitle below. Designed to read under
+        the panel's forced dark-text rule, so the active state is signaled by
+        background, weight, and underline, never by light text (which the
+        id-scoped !important rule would override anyway). Lets a muted-video judge
+        follow the crime arc (whispers -> heat -> inquiry -> reckoning) at a glance.
+        """
+        cur = min(self._chapter_idx, len(chapters.CHAPTERS) - 1)
+        pills = []
+        for i, (name, _sub) in enumerate(chapters.CHAPTERS):
+            short = name.split(":", 1)[1].strip() if ":" in name else name
+            if i == cur:
+                style = (
+                    "background:#cfe8d2;font-weight:700;"
+                    "border:1px solid #4f9d52;border-bottom:3px solid #2f6b3d;"
+                )
+            elif i < cur:
+                style = "background:#e6dfcd;border:1px solid #d8ccab;"
+            else:
+                style = "background:#f3eddc;border:1px dashed #ddd0aa;"
+            pills.append(
+                "<span style=\"display:inline-block;padding:4px 10px;margin:2px;"
+                f"border-radius:10px;font-size:11.5px;color:#2e2519;{style}\">"
+                f"{html.escape(short)}</span>"
+            )
+        connector = "<span style=\"color:#9c8f6a;font-size:11px;\"> › </span>"
+        _name, sub = chapters.CHAPTERS[cur]
+        return (
+            "<div style=\"display:flex;flex-wrap:wrap;align-items:center;\">"
+            + connector.join(pills)
+            + "</div>"
+            "<div style=\"margin-top:5px;font-size:12px;color:#6b5d3e;font-style:italic;\">"
+            f"{html.escape(sub)}</div>"
+        )
 
     def journal_markdown(self, limit: int = 14) -> str:
         """The Wood Street Journal feed: headline + dialogue over the ticker body.

ttw/narrate.py

@@ -137,7 +137,12 @@ def _narrate_bankruptcy(event: dict) -> str:
 def _narrate_suspicious_win(event: dict) -> str:
     """One ticker line for a Magistrate-flagged well-timed Patron win."""
     if event.get("reason") == "short_before_legend":
-        return f"🔥 A suspicious win: the Patron shorted {event.get('good')} right before the legend struck."
+        pnl = event.get("pnl")
+        gain = f" The gambit pays {pnl:+d}p." if isinstance(pnl, int) else ""
+        return (
+            f"🔥 A suspicious win: the Patron shorted {event.get('good')} "
+            f"right before the legend struck.{gain}"
+        )
     return f"🔥 A suspicious win: the Patron's {event.get('good')} short crashed on cue."
 
 

ttw/sim.py

@@ -337,11 +337,12 @@ def _settle_suspicious_wins(world: WorldState, price_before: dict[str, float]) -
             if not short.open or short.good != legend_good:
                 continue
             patron.heat += moves.HEAT_SHORT_BEFORE_LEGEND
-            patron.realized_pnl += short_unrealized_pnl(short, world.last_price)
+            pnl = short_unrealized_pnl(short, world.last_price)
+            patron.realized_pnl += pnl
             short.open = False
             events.append(
                 {"type": "suspicious_win", "turn": world.turn, "good": legend_good,
-                 "reason": "short_before_legend"}
+                 "reason": "short_before_legend", "pnl": pnl}
             )
         world.pending_legend = None