Tier 1: rich control panel — buttons, joystick, intervention, live trace

app.py

@@ -1,26 +1,24 @@
-"""HuggingFace Space — interactive ghostloop demo.
+"""HuggingFace Space — ghostloop control panel.
 
-Live URL: https://huggingface.co/spaces/Ghostgim/ghostloop-demo (after deploy).
+Live URL: https://huggingface.co/spaces/Ghostgim/ghostloop-demo
 
-Lets a visitor:
-  1. Pick a robot profile (franka_arm / spot / tello / humanoid_demo).
-  2. See the safety pipeline (gates active for that profile).
-  3. Send an Intent and watch the runtime dispatch + record the trace.
-  4. Replay the trace as JSON.
-  5. Read each profile's instructions block to understand what the LLM
-     "knows" about that robot.
+A no-code interface to ghostloop. Visitors pick a robot profile, then
+drive it via:
 
-Why a Space: GitHub repos take 30 seconds to clone + install. A Space
-loads in 5 seconds, no install. That's where most reputation conversions
-happen — the moment somebody clicks a link and sees Claude reasoning
-about a robot in the browser.
+  - Per-primitive dispatch buttons (auto-generated from the profile's
+    registry — no JSON typing required).
+  - Virtual joystick (D-pad style) for mobile bases / quadrupeds /
+    drones.
+  - Free-form Intent dispatch (advanced — JSON args).
+  - Live intervention controls: Pause, Resume, Emergency Stop.
+  - Live trace pane that updates after every dispatch.
+  - Live state pane showing the backend snapshot.
 
-Stack:
-  gradio ≥ 4.0 (UI)
-  ghostloop ≥ 1.0 (the library)
+The runtime is held per-session so the trace accumulates across
+button clicks. Switch profiles to reset.
 
-Zero hardware deps — runs against MockBackend so the Space starts
-instantly on the free CPU tier.
+Backend is MockBackend so the Space runs on the free CPU tier without
+any sim install.
 """
 
 from __future__ import annotations
@@ -30,7 +28,14 @@ from typing import Any
 
 import gradio as gr
 
-from ghostloop import Intent
+from ghostloop import (
+    Intent,
+    InterventionGate,
+    InterventionState,
+    LivePolicyController,
+    PolicyPipeline,
+    Runtime,
+)
 from ghostloop.profiles import (
     build_runtime_from_profile,
     franka_arm,
@@ -51,200 +56,445 @@ PRESETS = {
     "turtlebot — wheeled mobile base":     turtlebot_base,
 }
 
+DEFAULT_PROFILE = "franka_arm — 7-DOF arm"
+
+
+# ---------------------------------------------------------------------------
+# Per-session runtime state (persisted via gr.State).
+# ---------------------------------------------------------------------------
 
-def load_profile(profile_label: str) -> tuple[str, str, str, str]:
-    """Build a runtime + return its description / primitives / gates / instructions."""
+
+def make_session(profile_label: str) -> dict[str, Any]:
+    """Construct a fresh runtime session for a profile selection."""
     factory = PRESETS[profile_label]
     profile = factory()
     runtime = build_runtime_from_profile(profile)
-    primitives_md = "\n".join(
+    controller = LivePolicyController(
+        policy=lambda state: Intent("emit_event", {"kind": "noop"}),
+        fallback_policy=lambda state: Intent(
+            "stop" if "stop" in runtime.registry.names() else "emit_event",
+            {"kind": "fallback"},
+        ),
+    )
+    # Add the InterventionGate to the front of the pipeline so pause
+    # affects future dispatches.
+    runtime.policy_pipeline = PolicyPipeline(
+        gates=[InterventionGate(controller=controller), *runtime.policy_pipeline.gates]
+    )
+    return {
+        "profile_label": profile_label,
+        "profile": profile,
+        "runtime": runtime,
+        "controller": controller,
+    }
+
+
+# ---------------------------------------------------------------------------
+# Default-args lookup so primitive buttons launch with sensible values.
+# ---------------------------------------------------------------------------
+
+
+DEFAULT_ARGS: dict[str, dict[str, Any]] = {
+    # Arm primitives.
+    "move_to": {"x": 0.4, "y": 0.0, "z": 0.5},
+    "scan": {"radius": 0.3},
+    "pick": {"object_id": "widget-7"},
+    "place": {},
+    "set_joint": {"joint_name": "shoulder", "angle": 0.5, "duration": 1.0},
+    "set_gripper": {"state": "open", "force": 0.0},
+    # Mobile base.
+    "drive": {"linear_x": 0.2, "angular_z": 0.0},
+    "stop": {},
+    "goto": {"x": 1.0, "y": 0.0, "theta": 0.0},
+    "rotate": {"dtheta": 1.57},
+    # Quadruped.
+    "sit": {},
+    "stand": {},
+    "lie_down": {},
+    "walk_to": {"x": 1.5, "y": 0.0, "theta": 0.0},
+    # Humanoid.
+    "wave": {"hand": "right"},
+    "look_at": {"x": 1.0, "y": 0.0, "z": 1.5},
+    "point_at": {"x": 1.0, "y": 0.0, "z": 1.5},
+    "nod": {"direction": "yes"},
+    # Aerial.
+    "takeoff": {"altitude": 1.0},
+    "land": {},
+    "fly_to": {"x": 1.0, "y": 0.0, "z": 1.5, "yaw": 0.0},
+    "hover": {"seconds": 2.0},
+    # Sensing.
+    "sense": {"modality": "rgb"},
+    "scan_360": {},
+    "take_photo": {},
+    "read_battery": {},
+    "wait": {"seconds": 1.0},
+    "emit_event": {"kind": "note", "message": "demo event"},
+}
+
+
+# ---------------------------------------------------------------------------
+# Render helpers — keep all formatting in one place.
+# ---------------------------------------------------------------------------
+
+
+def _render_profile_summary(session: dict[str, Any]) -> str:
+    profile = session["profile"]
+    runtime = session["runtime"]
+    return (
+        f"### `{profile.name}` — `{profile.morphology}`\n\n"
+        f"**Backend:** `{runtime.backend.name}` (mock) · "
+        f"**Workspace:** `{profile.workspace_bounds}` · "
+        f"**Max velocity:** `{profile.max_velocity}` m/s · "
+        f"**HITL primitives:** `{profile.hitl_primitives}`"
+    )
+
+
+def _render_primitives_list(session: dict[str, Any]) -> str:
+    runtime = session["runtime"]
+    return "\n".join(
         f"- **`{name}`** — {runtime.registry.get(name).description}"
         for name in runtime.registry.names()
     )
-    gates_md = "\n".join(
+
+
+def _render_gates_list(session: dict[str, Any]) -> str:
+    runtime = session["runtime"]
+    return "\n".join(
         f"- {g.__class__.__name__}" for g in runtime.policy_pipeline.gates
     )
-    summary = (
-        f"**Profile:** `{profile.name}`  \n"
-        f"**Morphology:** `{profile.morphology}`  \n"
-        f"**Backend:** `{runtime.backend.name}` (mock)  \n"
-        f"**Workspace:** `{profile.workspace_bounds}`  \n"
-        f"**Max velocity:** `{profile.max_velocity}` m/s  \n"
-        f"**HITL primitives:** `{profile.hitl_primitives}`"
+
+
+def _render_state(session: dict[str, Any]) -> str:
+    runtime = session["runtime"]
+    return f"```json\n{json.dumps(runtime.backend.snapshot(), indent=2)}\n```"
+
+
+def _render_trace(session: dict[str, Any]) -> str:
+    runtime = session["runtime"]
+    if not runtime.trace.events:
+        return "_(no events yet — dispatch a primitive to see the trace)_"
+    rows = ["| step | intent | decision | gate | result | reason |",
+            "|---:|---|:---:|---|:---:|---|"]
+    for ev in runtime.trace.events[-12:]:
+        decision_icon = {"allow": "✅", "deny": "🚫", "escalate": "⚠️"}.get(
+            ev.decision.action.value, "?"
+        )
+        result_icon = {"ok": "✅", "blocked": "🚫", "error": "❌"}.get(
+            ev.result.status.value, "?"
+        )
+        args_compact = json.dumps(ev.intent.args, separators=(",", ":"))
+        if len(args_compact) > 40:
+            args_compact = args_compact[:37] + "…"
+        reason = (ev.decision.reason or ev.result.message or "")[:80]
+        rows.append(
+            f"| {ev.step} | `{ev.intent.name}` {args_compact} | "
+            f"{decision_icon} | `{ev.decision.gate_name or ''}` | "
+            f"{result_icon} | {reason} |"
+        )
+    n = len(runtime.trace.events)
+    if n > 12:
+        rows.append(f"\n_showing last 12 of {n} events_")
+    return "\n".join(rows)
+
+
+def _render_intervention_state(session: dict[str, Any]) -> str:
+    state = session["controller"].state
+    icon = {
+        InterventionState.RUNNING:        "🟢",
+        InterventionState.PAUSED:         "⏸️",
+        InterventionState.SWAPPING:       "🔄",
+        InterventionState.EMERGENCY_STOP: "🛑",
+    }.get(state, "?")
+    return f"### {icon} Intervention: `{state.value}`"
+
+
+def _render_instructions(session: dict[str, Any]) -> str:
+    return session["profile"].instructions or "(no instructions block)"
+
+
+def _all_outputs(session: dict[str, Any]) -> tuple:
+    return (
+        _render_profile_summary(session),
+        _render_primitives_list(session),
+        _render_gates_list(session),
+        _render_instructions(session),
+        _render_state(session),
+        _render_trace(session),
+        _render_intervention_state(session),
     )
-    return summary, primitives_md, gates_md, profile.instructions or "(no instructions block)"
 
 
-def step_runtime(profile_label: str, primitive_name: str, args_json: str) -> tuple[str, str]:
-    """Dispatch one Intent against a fresh runtime, return result + last trace event."""
-    factory = PRESETS[profile_label]
-    runtime = build_runtime_from_profile(factory())
+# ---------------------------------------------------------------------------
+# Action handlers.
+# ---------------------------------------------------------------------------
+
+
+def select_profile(profile_label: str):
+    session = make_session(profile_label)
+    names = session["runtime"].registry.names()
+    # Up to 12 primitive buttons; pad with empty updates for the rest.
+    btn_updates = []
+    for i in range(12):
+        if i < len(names):
+            btn_updates.append(gr.update(value=names[i], visible=True, interactive=True))
+        else:
+            btn_updates.append(gr.update(visible=False))
+    return (session, *_all_outputs(session), *btn_updates)
+
+
+def dispatch_primitive(session: dict[str, Any], primitive_name: str):
+    if not primitive_name:
+        return session, *_all_outputs(session)
+    args = dict(DEFAULT_ARGS.get(primitive_name, {}))
+    session["runtime"].step(Intent(primitive_name, args))
+    return session, *_all_outputs(session)
+
+
+def dispatch_custom(session: dict[str, Any], primitive_name: str, args_json: str):
+    if not primitive_name.strip():
+        return session, *_all_outputs(session)
     try:
         args = json.loads(args_json) if args_json.strip() else {}
         if not isinstance(args, dict):
             raise ValueError("args must be a JSON object")
-    except (ValueError, json.JSONDecodeError) as e:
-        return f"❌ args JSON parse error: {e}", "—"
-    if primitive_name not in runtime.registry.names():
-        return (
-            f"❌ Unknown primitive {primitive_name!r}. Available for "
-            f"this profile: {runtime.registry.names()}",
-            "—",
-        )
-    intent = Intent(name=primitive_name, args=args)
-    result = runtime.step(intent)
-    event = runtime.trace.events[-1]
-    decision = event.decision
-    status_icon = {"ok": "✅", "blocked": "🚫", "error": "❌"}.get(
-        result.status.value, "⚠️"
+    except (ValueError, json.JSONDecodeError):
+        return session, *_all_outputs(session)
+    if primitive_name not in session["runtime"].registry.names():
+        return session, *_all_outputs(session)
+    session["runtime"].step(Intent(primitive_name, args))
+    return session, *_all_outputs(session)
+
+
+def dispatch_drive(session: dict[str, Any], linear_x: float, angular_z: float):
+    """Joystick handler — emits drive(linear_x, angular_z) for mobile / quad."""
+    runtime = session["runtime"]
+    name = None
+    if "drive" in runtime.registry.names():
+        name = "drive"
+        args = {"linear_x": float(linear_x), "angular_z": float(angular_z)}
+    elif "fly_to" in runtime.registry.names():
+        # Drone: interpret as relative flight.
+        name = "fly_to"
+        args = {"x": float(linear_x), "y": 0.0, "z": 1.0, "yaw": float(angular_z)}
+    elif "walk_to" in runtime.registry.names():
+        name = "walk_to"
+        args = {"x": float(linear_x), "y": 0.0, "theta": float(angular_z)}
+    elif "move_to" in runtime.registry.names():
+        # Arm: interpret as a delta on x.
+        name = "move_to"
+        args = {"x": float(linear_x), "y": 0.0, "z": 0.5}
+    if name is None:
+        return session, *_all_outputs(session)
+    runtime.step(Intent(name, args))
+    return session, *_all_outputs(session)
+
+
+def pause_runtime(session: dict[str, Any]):
+    session["controller"].pause(operator="ui_visitor", reason="UI pause button")
+    return session, *_all_outputs(session)
+
+
+def resume_runtime(session: dict[str, Any]):
+    session["controller"].resume(operator="ui_visitor", reason="UI resume button")
+    return session, *_all_outputs(session)
+
+
+def emergency_stop(session: dict[str, Any]):
+    runtime = session["runtime"]
+    stop_intent_name = (
+        "stop" if "stop" in runtime.registry.names() else
+        "land" if "land" in runtime.registry.names() else
+        "lie_down" if "lie_down" in runtime.registry.names() else
+        "emit_event"
     )
-    summary = (
-        f"{status_icon} **status:** `{result.status.value}`  \n"
-        f"**decision:** `{decision.action.value}`"
-        f" (gate: `{decision.gate_name}`)  \n"
-        f"**reason:** {decision.reason}  \n"
-        f"**message:** {result.message}"
+    session["controller"].emergency_stop(
+        stop_intent=Intent(stop_intent_name, {}),
+        operator="ui_visitor", reason="UI E-STOP button",
     )
-    trace_json = json.dumps(event.to_json(), indent=2)
-    return summary, trace_json
-
-
-def example_args(primitive_name: str) -> str:
-    """Convenience: a sensible default args dict for common primitives."""
-    examples = {
-        "move_to":     '{"x": 0.4, "y": 0.0, "z": 0.5}',
-        "pick":        '{"object_id": "widget-7"}',
-        "place":       '{}',
-        "scan":        '{"radius": 0.3}',
-        "drive":       '{"linear_x": 0.2, "angular_z": 0.0}',
-        "stop":        '{}',
-        "goto":        '{"x": 1.5, "y": -0.5, "theta": 0.0}',
-        "rotate":      '{"dtheta": 1.57}',
-        "sit":         '{}',
-        "stand":       '{}',
-        "lie_down":    '{}',
-        "walk_to":     '{"x": 2.0, "y": 1.0, "theta": 0.0}',
-        "wave":        '{"hand": "right"}',
-        "look_at":     '{"x": 1.0, "y": 0.0, "z": 1.5}',
-        "point_at":    '{"x": 1.0, "y": 0.0, "z": 1.5}',
-        "nod":         '{"direction": "yes"}',
-        "takeoff":     '{"altitude": 1.0}',
-        "land":        '{}',
-        "fly_to":      '{"x": 1.0, "y": 0.0, "z": 1.5, "yaw": 0.0}',
-        "hover":       '{"seconds": 2.0}',
-        "set_joint":   '{"joint_name": "shoulder", "angle": 0.5, "duration": 1.0}',
-        "set_gripper": '{"state": "open", "force": 0.0}',
-        "sense":       '{"modality": "rgb"}',
-        "scan_360":    '{}',
-        "take_photo":  '{}',
-        "read_battery": '{}',
-        "wait":        '{"seconds": 1.0}',
-        "emit_event":  '{"kind": "note", "message": "demo event"}',
-    }
-    return examples.get(primitive_name, "{}")
+    return session, *_all_outputs(session)
+
+
+def clear_trace(session: dict[str, Any]):
+    session["runtime"].trace.events.clear()
+    return session, *_all_outputs(session)
+
+
+# ---------------------------------------------------------------------------
+# UI.
+# ---------------------------------------------------------------------------
 
 
 with gr.Blocks(
-    title="ghostloop — the agent loop, embodied",
+    title="ghostloop — control panel",
     theme=gr.themes.Soft(primary_hue="teal"),
+    css="""
+    .gl-pad-button { min-height: 56px; font-weight: 600; }
+    .gl-estop button { background: #DC2626 !important; color: white !important; font-weight: 700; }
+    .gl-pause button { background: #F59E0B !important; color: white !important; }
+    .gl-resume button { background: #10B981 !important; color: white !important; }
+    """,
 ) as demo:
-    gr.Markdown(
-        """
-# ghostloop · live demo
+    gr.Markdown("""
+# ghostloop · control panel
 
-The agent loop, embodied. A tool-using runtime + fail-closed safety
-pipeline + sim-first execution + post-hoc analysis layer for embodied AI.
+Pick a robot profile, then drive it through the safety pipeline. Every
+dispatch goes through `Geofence + ForceCap + ActionSmoothing + RateLimit
++ HITL` — try sending a `move_to` outside the workspace and watch the
+geofence reject it.
 
-This Space runs against `MockBackend` so it starts instantly. Every
-primitive call goes through the **same fail-closed safety pipeline** that
-ships in the library (geofence + force cap + action smoothing + rate
-limit + HITL) — try sending a `move_to` outside the workspace and watch
-the geofence reject it.
+Sister to **[GhostLM](https://github.com/joemunene-by/GhostLM)** · `pip install ghostloop` · [GitHub](https://github.com/joemunene-by/ghostloop) · [PyPI](https://pypi.org/project/ghostloop/)
+""")
 
-[GitHub](https://github.com/joemunene-by/ghostloop) · [PyPI](https://pypi.org/project/ghostloop/) · [arXiv preprint](#) · [Sister project: GhostLM](https://github.com/joemunene-by/GhostLM)
-"""
-    )
+    session_state = gr.State()
 
+    # ---------- Profile picker ----------
     with gr.Row():
-        with gr.Column(scale=1):
-            profile_dd = gr.Dropdown(
-                label="Robot profile",
-                choices=list(PRESETS.keys()),
-                value="franka_arm — 7-DOF arm",
-            )
-            summary_md = gr.Markdown(label="Profile summary")
-            instructions_md = gr.Markdown(label="LLM instructions")
+        profile_dd = gr.Dropdown(
+            label="Robot profile",
+            choices=list(PRESETS.keys()),
+            value=DEFAULT_PROFILE,
+            scale=4,
+        )
+
+    summary_md = gr.Markdown()
 
+    with gr.Row():
+        with gr.Column(scale=1):
+            gr.Markdown("### Available primitives")
+            primitives_md = gr.Markdown()
         with gr.Column(scale=1):
-            primitives_md = gr.Markdown(label="Available primitives")
-            gates_md = gr.Markdown(label="Active safety gates")
+            gr.Markdown("### Active safety gates")
+            gates_md = gr.Markdown()
 
-    profile_dd.change(
-        load_profile,
-        inputs=[profile_dd],
-        outputs=[summary_md, primitives_md, gates_md, instructions_md],
-    )
+    with gr.Accordion("Robot instructions (LLM system prompt)", open=False):
+        instructions_md = gr.Markdown()
 
-    gr.Markdown("## Dispatch a primitive")
+    # ---------- Quick-dispatch buttons ----------
+    gr.Markdown("## Dispatch a primitive (one click — uses sensible defaults)")
+    primitive_buttons: list[gr.Button] = []
+    with gr.Row():
+        for _ in range(6):
+            primitive_buttons.append(gr.Button("", variant="primary", elem_classes="gl-pad-button"))
+    with gr.Row():
+        for _ in range(6):
+            primitive_buttons.append(gr.Button("", variant="primary", elem_classes="gl-pad-button"))
 
+    # ---------- Joystick (D-pad) ----------
+    gr.Markdown("## Virtual joystick — drive / walk / fly / move")
     with gr.Row():
-        primitive_in = gr.Textbox(
-            label="Primitive name",
-            value="move_to",
-            placeholder="e.g. move_to / drive / takeoff / wave",
-        )
-        args_in = gr.Textbox(
-            label="Args (JSON)",
-            value='{"x": 0.4, "y": 0.0, "z": 0.5}',
-            lines=2,
-        )
-        primitive_in.change(
-            example_args, inputs=[primitive_in], outputs=[args_in],
+        with gr.Column(scale=1):
+            pass
+        with gr.Column(scale=1):
+            joy_forward = gr.Button("⬆ FORWARD", elem_classes="gl-pad-button")
+        with gr.Column(scale=1):
+            pass
+    with gr.Row():
+        joy_left = gr.Button("⬅ LEFT", elem_classes="gl-pad-button")
+        joy_stop = gr.Button("◼ STOP", elem_classes="gl-pad-button")
+        joy_right = gr.Button("RIGHT ➡", elem_classes="gl-pad-button")
+    with gr.Row():
+        with gr.Column(scale=1):
+            pass
+        with gr.Column(scale=1):
+            joy_back = gr.Button("⬇ BACK", elem_classes="gl-pad-button")
+        with gr.Column(scale=1):
+            pass
+
+    # ---------- Intervention controls ----------
+    gr.Markdown("## Live intervention")
+    intervention_md = gr.Markdown()
+    with gr.Row():
+        pause_btn = gr.Button("⏸ Pause", elem_classes="gl-pause")
+        resume_btn = gr.Button("▶ Resume", elem_classes="gl-resume")
+        estop_btn = gr.Button("🛑 EMERGENCY STOP", elem_classes="gl-estop")
+
+    # ---------- Live trace + state ----------
+    with gr.Row():
+        with gr.Column(scale=2):
+            gr.Markdown("## Live trace (most recent first)")
+            trace_md = gr.Markdown()
+            clear_trace_btn = gr.Button("Clear trace")
+        with gr.Column(scale=1):
+            gr.Markdown("## Current backend state")
+            state_md = gr.Markdown()
+
+    # ---------- Advanced: free-form Intent ----------
+    with gr.Accordion("Advanced: free-form Intent (JSON args)", open=False):
+        with gr.Row():
+            adv_name = gr.Textbox(label="Primitive", value="move_to", scale=1)
+            adv_args = gr.Textbox(
+                label="args JSON",
+                value='{"x": 0.4, "y": 0.0, "z": 0.5}',
+                lines=2, scale=3,
+            )
+        adv_btn = gr.Button("▶ runtime.step(intent)", variant="secondary")
+
+    # ---------- Try-this hints ----------
+    gr.Markdown("""
+### Try this:
+
+1. Pick the **`franka_arm`** profile, then click **`move_to`** — it dispatches with `(0.4, 0, 0.5)` and lands inside the workspace ✅. Now expand the **Advanced** accordion and dispatch `move_to` with `{"x": 5.0, "y": 0, "z": 0}` — the GeofenceGate rejects it 🚫.
+2. Switch to **`spot`**, then drive with the joystick. Each press emits `walk_to(linear_x, 0, angular_z)` through the safety pipeline.
+3. Hit **🛑 EMERGENCY STOP**. Try clicking another primitive — it gets denied. Hit **▶ Resume** to recover.
+
+Every dispatch is recorded in the trace pane below — that's the same `TraceEvent` shape the library exports for replay, diff, query, energy ledger, and LLM-judge scoring.
+""")
+
+    # ---------- Wiring ----------
+    profile_outputs = [
+        session_state,
+        summary_md, primitives_md, gates_md, instructions_md,
+        state_md, trace_md, intervention_md,
+        *primitive_buttons,
+    ]
+    standard_outputs = [
+        session_state,
+        summary_md, primitives_md, gates_md, instructions_md,
+        state_md, trace_md, intervention_md,
+    ]
+
+    profile_dd.change(select_profile, inputs=[profile_dd], outputs=profile_outputs)
+    demo.load(select_profile, inputs=[profile_dd], outputs=profile_outputs)
+
+    for btn in primitive_buttons:
+        btn.click(
+            dispatch_primitive, inputs=[session_state, btn], outputs=standard_outputs,
         )
 
-    run_btn = gr.Button("▶ runtime.step(intent)", variant="primary")
-    result_md = gr.Markdown(label="Result")
-    trace_json = gr.Code(label="Trace event (JSON)", language="json")
-    run_btn.click(
-        step_runtime,
-        inputs=[profile_dd, primitive_in, args_in],
-        outputs=[result_md, trace_json],
+    joy_forward.click(
+        lambda s: dispatch_drive(s, 0.2, 0.0),
+        inputs=[session_state], outputs=standard_outputs,
     )
-
-    gr.Markdown(
-        """
-### Try these:
-
-1. **Geofence violation:** keep `franka_arm` profile, send
-   `move_to` with `{"x": 5.0, "y": 0.0, "z": 0.5}`. The Geofence gate
-   blocks it; the trace records exactly why.
-2. **HITL escalation:** switch to `tello`, send `takeoff` with
-   `{"altitude": 1.0}`. The HumanInTheLoopGate is wired to `takeoff`
-   for this profile — in a real terminal it'd prompt for approval; in
-   the Space it returns an "approver declined" since there's no human.
-3. **Cross-morphology:** switch to `spot`, send `walk_to` with
-   `{"x": 2.0, "y": 1.0, "theta": 0.0}`. The same Runtime, the same
-   safety pipeline pattern, completely different primitive set.
-
-Every call records a typed `TraceEvent` you can replay, diff, query
-with the trace DSL, score with the LLM judge, or attribute causally
-when something fails.
-"""
+    joy_back.click(
+        lambda s: dispatch_drive(s, -0.2, 0.0),
+        inputs=[session_state], outputs=standard_outputs,
     )
+    joy_left.click(
+        lambda s: dispatch_drive(s, 0.0, 0.5),
+        inputs=[session_state], outputs=standard_outputs,
+    )
+    joy_right.click(
+        lambda s: dispatch_drive(s, 0.0, -0.5),
+        inputs=[session_state], outputs=standard_outputs,
+    )
+    joy_stop.click(
+        lambda s: dispatch_drive(s, 0.0, 0.0),
+        inputs=[session_state], outputs=standard_outputs,
+    )
+
+    pause_btn.click(pause_runtime, inputs=[session_state], outputs=standard_outputs)
+    resume_btn.click(resume_runtime, inputs=[session_state], outputs=standard_outputs)
+    estop_btn.click(emergency_stop, inputs=[session_state], outputs=standard_outputs)
+    clear_trace_btn.click(clear_trace, inputs=[session_state], outputs=standard_outputs)
 
-    # Initial population.
-    demo.load(
-        load_profile,
-        inputs=[profile_dd],
-        outputs=[summary_md, primitives_md, gates_md, instructions_md],
+    adv_btn.click(
+        dispatch_custom,
+        inputs=[session_state, adv_name, adv_args],
+        outputs=standard_outputs,
     )
 
 
 if __name__ == "__main__":
-    # HF Spaces require binding to 0.0.0.0:7860 explicitly. Without
-    # server_name, gradio defaults to 127.0.0.1 and the Space proxy
-    # can't reach the app — see the "localhost is not accessible"
-    # error in earlier deploys.
     import os
     demo.launch(
         server_name="0.0.0.0",