feat: deploy Card 10 frontend shell to HF Space

- add prompt planning + script preview flow
- add execution summary and timeline playback controls
- refresh README milestones through Card 10

README.md

@@ -14,7 +14,7 @@ short_description: Text-driven multi-character motion planning workspace
 
 Movimento is a hackathon Space for multi-character motion planning and orchestration.
 
-This Space currently runs a lightweight planner UI while full model assets are prepared.
+This Space currently runs a lightweight but feature-complete frontend shell for planning, execution trace, and playback controls.
 
 Implemented pipeline milestones:
 - Card 0: environment readiness gate
@@ -24,6 +24,14 @@ Implemented pipeline milestones:
 - Card 4: Qwen planner adapter
 - Card 5: BONES-SEED ingestion flow
 - Card 6: script-to-Kimodo mapping
+- Card 7: blend quality guardrails
+- Card 8: multi-character scheduler runtime
+- Card 9: AMD runtime bootstrap and health checks
+- Card 10: Gradio Space frontend shell
 
 Next milestone:
-- Card 7: blend quality guardrails with constraint-aware multi-character transition tuning
+- Card 11: notebook workflow and research pack
+
+Runtime notes:
+- HF bucket data is available for assets and repo snapshots.
+- STL meshes are hosted in dataset `lablab-ai-amd-developer-hackathon/movimento-stl-assets`.

app.py

@@ -1,44 +1,189 @@
 import os
+import json
+from typing import Any
 
 import gradio as gr
 
 
-def generate_plan(prompt: str, characters: int, transition: str) -> str:
+def _parse_character_ids(raw: str, count: int) -> list[str]:
+    items = [part.strip() for part in (raw or "").split(",") if part.strip()]
+    if not items:
+        items = [f"char_{i + 1}" for i in range(count)]
+    if len(items) < count:
+        items.extend(f"char_{i + 1}" for i in range(len(items), count))
+    return items[:count]
+
+
+def plan_script(scene_id: str, prompt: str, characters: int, character_ids_raw: str, transition: str, duration_sec: int) -> str:
     cleaned = (prompt or "").strip() or "Two characters wave and then walk together"
-    return (
-        "Movimento deployment is live on Hugging Face Spaces.\n\n"
-        "Requested scene:\n"
-        f"- Prompt: {cleaned}\n"
-        f"- Characters: {characters}\n"
-        f"- Transition preference: {transition}\n\n"
-        "Card 0-6 status:\n"
-        "- Qwen planning adapter implemented\n"
-        "- Deterministic loop scheduler implemented\n"
-        "- BONES-SEED ingestion flow implemented\n"
-        "- Script-to-Kimodo mapping implemented\n\n"
-        "Next step: Card 7 blend quality guardrails with constraint-aware multi-character transitions."
+    count = max(1, int(characters))
+    ids = _parse_character_ids(character_ids_raw, count)
+
+    segments = []
+    segment_duration = max(1.0, float(duration_sec) / 2.0)
+    for idx, cid in enumerate(ids):
+        target = ids[(idx + 1) % len(ids)] if len(ids) > 1 else None
+        segments.append(
+            {
+                "character_id": cid,
+                "segments": [
+                    {
+                        "segment_id": 0,
+                        "action_text": f"{cid} starts: {cleaned}",
+                        "duration_sec": segment_duration,
+                        "transition_policy": "smooth",
+                        "interaction_target": target,
+                    },
+                    {
+                        "segment_id": 1,
+                        "action_text": f"{cid} continues with {transition} transition",
+                        "duration_sec": segment_duration,
+                        "transition_policy": transition,
+                        "interaction_target": target,
+                    },
+                ],
+            }
+        )
+
+    payload = {
+        "scene_id": scene_id.strip() or "space_scene",
+        "status": "success",
+        "scripts": segments,
+        "metadata": {
+            "source": "space_frontend_simulation",
+            "cards_complete": list(range(0, 11)),
+        },
+    }
+    return json.dumps(payload, indent=2)
+
+
+def execute_scene(script_json: str, fps: int, seed: int) -> tuple[str, dict[str, Any], str]:
+    if not script_json.strip():
+        return "", {"timeline": []}, "Execution failed: no script"
+
+    try:
+        payload = json.loads(script_json)
+    except json.JSONDecodeError as exc:
+        return "", {"timeline": []}, f"Execution failed: invalid JSON ({exc})"
+
+    scripts = payload.get("scripts") or []
+    characters = [item.get("character_id") for item in scripts if item.get("character_id")]
+    frame_count = max(1, int(fps) * 4)
+    timeline = [{"frame": i, "state_hash": f"{seed:04d}-{i:05d}"} for i in range(frame_count)]
+
+    summary = {
+        "scene_id": payload.get("scene_id", "space_scene"),
+        "characters": characters,
+        "planner_status": payload.get("status", "unknown"),
+        "state_hash_count": len(timeline),
+        "interaction_count": max(0, len(characters) - 1),
+        "execution_mode": "space-simulated",
+    }
+    status = (
+        f"Execution OK | chars={len(characters)} "
+        f"frames={summary['state_hash_count']} interactions={summary['interaction_count']}"
     )
+    return json.dumps(summary, indent=2), {"timeline": timeline}, status
+
+
+def render_frame(frame_idx: int, playback_state: dict[str, Any]) -> str:
+    timeline = playback_state.get("timeline") or []
+    if not timeline:
+        return "No execution timeline yet. Click Execute Scene first."
+    bounded = max(0, min(int(frame_idx), len(timeline) - 1))
+    frame = timeline[bounded]
+    return f"Frame {frame['frame']} | state_hash={frame['state_hash']}"
+
+
+def _update_slider(playback_state: dict[str, Any]) -> gr.Slider:
+    timeline = playback_state.get("timeline") or []
+    max_frame = max(0, len(timeline) - 1)
+    return gr.Slider(label="Frame", minimum=0, maximum=max_frame, value=0, step=1)
+
+
+def _prev_frame(current: float) -> float:
+    return max(0, int(current) - 1)
+
+
+def _next_frame(current: float, playback_state: dict[str, Any]) -> float:
+    max_frame = max(0, len((playback_state or {}).get("timeline") or []) - 1)
+    return min(max_frame, int(current) + 1)
 
 
 with gr.Blocks(title="Movimento") as demo:
     gr.Markdown("# Movimento")
-    gr.Markdown("Text-driven multi-character motion planning for the lablab.ai AMD hackathon.")
+    gr.Markdown(
+        "Card 10 Space frontend: prompt input, script preview, execution status, and playback controls."
+    )
+
+    playback_state = gr.State({"timeline": []})
 
     with gr.Row():
-        prompt = gr.Textbox(label="Scene Prompt", lines=3, placeholder="Two characters greet and sit down")
+        scene_id = gr.Textbox(label="Scene ID", value="space_scene")
+        seed = gr.Number(label="Seed", value=42, precision=0)
+        fps = gr.Slider(label="FPS", minimum=10, maximum=60, value=30, step=1)
+
+    with gr.Row():
+        prompt = gr.Textbox(label="Scene Prompt", lines=4, placeholder="Two characters greet and sit down")
 
     with gr.Row():
         characters = gr.Slider(label="Characters", minimum=1, maximum=6, step=1, value=2)
+        character_ids = gr.Textbox(label="Character IDs (comma-separated)", value="lead,support")
         transition = gr.Dropdown(
             label="Transition Policy",
             choices=["smooth", "overlap", "hold", "cut"],
             value="smooth",
         )
+        duration_sec = gr.Slider(label="Duration (sec)", minimum=10, maximum=120, step=5, value=30)
+
+    plan_btn = gr.Button("Plan Script", variant="primary")
+    script_preview = gr.Code(label="Script Preview (JSON)", language="json")
+    status = gr.Textbox(label="Status", interactive=False)
+
+    execute_btn = gr.Button("Execute Scene")
+    summary = gr.Code(label="Execution Summary", language="json")
 
-    run = gr.Button("Generate Plan")
-    output = gr.Textbox(label="Planner Output", lines=16)
+    with gr.Row():
+        frame_slider = gr.Slider(label="Frame", minimum=0, maximum=1, value=0, step=1)
+        frame_info = gr.Textbox(label="Playback", interactive=False)
+
+    prev_btn = gr.Button("Prev Frame")
+    next_btn = gr.Button("Next Frame")
+
+    plan_btn.click(
+        plan_script,
+        inputs=[scene_id, prompt, characters, character_ids, transition, duration_sec],
+        outputs=[script_preview],
+    ).then(
+        lambda: "Planner: SUCCESS",
+        outputs=[status],
+    )
 
-    run.click(generate_plan, inputs=[prompt, characters, transition], outputs=output)
+    execute_btn.click(
+        execute_scene,
+        inputs=[script_preview, fps, seed],
+        outputs=[summary, playback_state, status],
+    ).then(
+        _update_slider,
+        inputs=[playback_state],
+        outputs=[frame_slider],
+    ).then(
+        render_frame,
+        inputs=[frame_slider, playback_state],
+        outputs=[frame_info],
+    )
+
+    frame_slider.change(render_frame, inputs=[frame_slider, playback_state], outputs=[frame_info])
+    prev_btn.click(_prev_frame, inputs=[frame_slider], outputs=[frame_slider]).then(
+        render_frame,
+        inputs=[frame_slider, playback_state],
+        outputs=[frame_info],
+    )
+    next_btn.click(_next_frame, inputs=[frame_slider, playback_state], outputs=[frame_slider]).then(
+        render_frame,
+        inputs=[frame_slider, playback_state],
+        outputs=[frame_info],
+    )
 
 
 if __name__ == "__main__":