"
f"{_seals_html(status['catches'], status['catches_to_win'])}"
f"{_meter_html('Witness composure', status['composure'], '#7a4a2f')}"
f"{_meter_html('Your standing with the bench', status['credibility'], '#43607f')}"
"
"
)
def _dock_html(tier: str) -> str:
"""The witness in the dock; `tier` (composed→rattled→cornered→breaking) drives the visual break."""
if PORTRAIT_DATA_URI:
face = f""
else:
face = "
"
def _parse_mic(mic):
if mic is None:
return None, None
sr, data = mic
y = np.asarray(data)
if y.dtype.kind in "iu":
y = y.astype(np.float32) / max(1, np.iinfo(y.dtype).max)
else:
y = y.astype(np.float32)
if y.ndim > 1:
y = y.mean(axis=1)
return y, int(sr)
def _concat(a, b, sr):
if a is None:
return b
if b is None:
return a
gap = np.zeros(int(0.5 * sr), dtype=np.float32)
return np.concatenate([a.astype(np.float32), gap, b.astype(np.float32)])
# --------------------------------------------------------------------------- #
# callbacks
# --------------------------------------------------------------------------- #
def on_start(engine):
engine = WitnessBoxEngine(get_backends())
intro = engine.start()
chat = [
{"role": "assistant", "content": f"⚖️ *The Court:* {intro['narration']}"},
{"role": "assistant", "content": f"**{WITNESS_NAME}:** {intro['opening_text']}"},
]
opening_audio = intro["opening_audio"] # (sr, np) or None
footer = f"Backend: **{intro['backend']}** — {intro['backend_note']}"
from witnessbox.stance import _neutral
return (
engine,
chat,
gr.update(value=opening_audio),
_stance_html(_neutral("awaiting your first question")),
_counters_html(intro["status"]),
_dock_html("composed"),
gr.update(value="", visible=False),
_banner("info", "Examination open. Mind how you say it — he listens for doubt."),
footer,
gr.update(interactive=True), # ask button
gr.update(visible=False), # begin button
gr.update(interactive=True), # mic
gr.update(interactive=True), # typed
)
def on_ask(engine, mic, typed):
if engine is None:
return (engine, gr.skip(), gr.skip(), gr.skip(), gr.skip(), gr.skip(), gr.skip(),
_banner("info", "Press “Call the witness” to begin."), gr.skip())
try:
y, sr = _parse_mic(mic)
result = engine.take_turn(audio=y, sr=sr, typed_text=typed)
except Exception as exc: # surface the real cause in the UI, don't silently toast
import traceback
traceback.print_exc()
return (engine, gr.skip(), gr.skip(), gr.skip(), gr.skip(), gr.skip(), gr.skip(),
_banner("lose", f"Turn failed — {type(exc).__name__}: {exc}"), gr.skip())
# Rebuild the chat from the transcript (engine keeps it consistent with what
# is actually spoken, including the break line on the winning turn).
chat = []
for rec in engine.state.transcript:
tag = f"_[{rec.stance_tier.lower()}]_ " if rec.stance_tier != "NEUTRAL" else ""
chat.append({"role": "user", "content": f"{tag}{rec.examiner_text}"})
chat.append({"role": "assistant", "content": f"**{WITNESS_NAME}:** {rec.witness_text}"})
# Terminal turns (e.g. no clear audio) don't enter the transcript — show them
# anyway so the player always gets visible feedback.
last_bot = chat[-1]["content"] if chat else ""
if result.witness_text and result.witness_text not in last_bot:
if result.examiner_text:
chat.append({"role": "user", "content": result.examiner_text})
chat.append({"role": "assistant", "content": f"**{WITNESS_NAME}:** {result.witness_text}"})
# witness audio (+ epilogue concatenated on win/lose for a single dramatic play)
audio_val = None
if result.witness_audio is not None:
merged = _concat(result.witness_audio, result.epilogue_audio, result.audio_sr)
audio_val = (result.audio_sr, merged)
# banner
if result.events.won:
banner = _banner("win", "🩻 He breaks. Three contradictions on the record — you win.")
elif result.events.lost:
banner = _banner("lose", "The bench excuses the witness. You’ve lost the room.")
elif result.evidence: # a contradiction just landed (non-winning) — the gotcha moment
banner = _banner("win", f"⚖ Contradiction admitted — {result.status['catches']} of {result.status['catches_to_win']} on the record.")
elif result.events.near_miss:
banner = _banner("info", "He flinched. You’re circling something — name the specific fact.")
else:
banner = _banner("info", f"Stance read: {result.stance.tier.title()}.")
evidence_update = (
gr.update(value=result.evidence, visible=True)
if result.evidence else gr.update()
)
return (
engine,
chat,
gr.update(value=audio_val),
_stance_html(result.stance),
_counters_html(result.status),
_dock_html(result.status["witness_tier"]),
evidence_update,
banner,
gr.update(value=""), # clear typed box
)
# --------------------------------------------------------------------------- #
# layout
# --------------------------------------------------------------------------- #
def build() -> gr.Blocks:
theme = gr.themes.Soft(
primary_hue=gr.themes.colors.red, # oxblood, refined to exact hues in CSS
secondary_hue=gr.themes.colors.amber, # brass
neutral_hue=gr.themes.colors.stone, # warm paper greys, never blue-greys
)
with gr.Blocks(css=CSS, head=HEAD, title="WitnessBox", theme=theme) as demo:
engine_state = gr.State(None)
gr.HTML(
"
"
"
⚖️
"
"
Cross-Examination · The People v. Halcyon Dynamics
"
"
WitnessBox
"
f"
Cross-examine {WITNESS_NAME}, {WITNESS_ROLE}. "
"Your voice is the weapon.
"
""
"
"
)
banner = gr.HTML(_banner("info", "Call the witness to the stand."))
with gr.Row():
with gr.Column(scale=2):
dock_html = gr.HTML(_dock_html("composed"))
stance_html = gr.HTML(_stance_html(_neutral_seed()))
with gr.Column(scale=4):
chat = gr.Chatbot(type="messages", height=420, label="The Stand",
elem_id="wb-chat")
witness_audio = gr.Audio(label="Witness", autoplay=True, interactive=False)
with gr.Column(scale=2):
counters_html = gr.HTML(_counters_seed())
with gr.Accordion("🔎 Contradiction Engine (live verdict)", open=True):
evidence = gr.Textbox(
elem_id="wb-evidence", show_label=False, visible=False, lines=5,
interactive=False,
)
gr.Markdown(
"_Catches are decided by a deterministic engine over three planted "
"contradictions — the language model never grades itself, so the "
"verdict is reproducible._"
)
with gr.Row():
mic = gr.Audio(sources=["microphone"], type="numpy", label="Question (push to talk)",
interactive=False)
typed = gr.Textbox(label="…or type your question (primary in offline mock mode)",
interactive=False, scale=2,
placeholder="e.g. The wire cleared March 6th — before the board approved it on the 14th.")
with gr.Row():
begin_btn = gr.Button("Call the witness to the stand", variant="primary")
ask_btn = gr.Button("Put it to him", variant="secondary", interactive=False)
footer = gr.Markdown("")
outs_start = [engine_state, chat, witness_audio, stance_html, counters_html,
dock_html, evidence, banner, footer, ask_btn, begin_btn, mic, typed]
begin_btn.click(on_start, [engine_state], outs_start)
outs_ask = [engine_state, chat, witness_audio, stance_html, counters_html,
dock_html, evidence, banner, typed]
ask_btn.click(on_ask, [engine_state, mic, typed], outs_ask)
typed.submit(on_ask, [engine_state, mic, typed], outs_ask)
return demo
def _neutral_seed():
from witnessbox.stance import _neutral
return _neutral("awaiting examination")
def _counters_seed():
return _counters_html({
"catches": 0, "catches_to_win": getattr(config, "CATCHES_TO_WIN", 3),
"composure": getattr(config, "COMPOSURE_START", 100),
"credibility": getattr(config, "CREDIBILITY_START", 100),
"witness_tier": "composed",
})
demo = build()
if __name__ == "__main__":
# server_name=0.0.0.0 so the HF Space's startup self-check can reach the app.
# ssr_mode=False: Gradio 5's experimental SSR layer caused flaky request errors
# on the Space; the classic client-rendered path is reliable for this app.
demo.launch(
server_name="0.0.0.0",
server_port=int(os.environ.get("GRADIO_SERVER_PORT", 7860)),
ssr_mode=False,
)