change defaults for hf spaces

inference.py

@@ -42,7 +42,7 @@ MODEL_NAME = os.getenv("MODEL_NAME", "openai/gpt-oss-20b")
 HF_TOKEN = os.getenv("HF_TOKEN") or os.getenv("API_KEY") or "lm-studio"
 LOCAL_IMAGE_NAME = os.getenv("LOCAL_IMAGE_NAME")
 
-ENV_BASE_URL = os.getenv("ENV_BASE_URL", "http://127.0.0.1:8000")
+ENV_BASE_URL = os.getenv("ENV_BASE_URL", "http://127.0.0.1:7860")
 TASK_NAME = os.getenv("TASK_NAME", "tracefix_rl")
 BENCHMARK = os.getenv("BENCHMARK", "tracefix_rl")
 MAX_STEPS = int(os.getenv("MAX_STEPS", "50"))

vision_ui.py

@@ -68,30 +68,31 @@ CSS = """
   font-family: 'Inter', sans-serif !important;
   background: var(--bg-top);
   color: var(--text-main);
+  padding: 0px !important;
 }
 
 #header-wrap {
-  margin-bottom: 5px;
-  border: 1px solid var(--accent);
+  margin-bottom: 2px;
+  border: 1px solid var(--panel-border);
   background: #000;
   border-radius: 0px;
-  padding: 16px 20px;
+  padding: 8px 12px;
   text-transform: uppercase;
 }
 
 #header-wrap h1 {
   margin: 0;
-  letter-spacing: 2px;
-  font-weight: 900;
+  letter-spacing: 1px;
+  font-weight: 700;
   color: #fff;
-  font-style: italic;
-  text-shadow: 2px 2px #E60012;
+  font-size: 20px;
 }
 
 #header-wrap p {
-  margin: 6px 0 0;
-  color: #fff;
+  margin: 2px 0 0;
+  color: var(--text-dim);
   font-weight: 500;
+  font-size: 13px;
 }
 
 .panel {
@@ -99,34 +100,45 @@ CSS = """
   border-radius: 0px !important;
   background: var(--panel) !important;
   overflow: hidden;
+  padding: 0px !important;
 }
 
 .panel-title {
-  padding: 10px 14px;
+  padding: 6px 10px;
   border-bottom: 1px solid var(--panel-border);
   color: var(--text-dim);
-  font-size: 14px;
-  letter-spacing: 0.1em;
+  font-size: 12px;
+  letter-spacing: 0.05em;
   text-transform: uppercase;
   font-weight: bold;
 }
 
 #execute-btn {
-  background: var(--accent) !important;
+  background: #2b2b2b !important;
   color: #fff !important;
   border-radius: 0px !important;
-  font-weight: 900 !important;
-  font-size: 18px !important;
+  font-weight: 700 !important;
+  font-size: 16px !important;
   text-transform: uppercase !important;
-  border: none !important;
+  border: 2px solid #fff !important;
   transition: all 0.2s ease !important;
-  height: 60px !important;
+  height: 40px !important;
 }
 
 #execute-btn:hover {
-  background: #fff !important;
-  color: var(--accent) !important;
-  box-shadow: 0 0 15px var(--accent) !important;
+  background: #801a1a !important;
+  border-color: #ff4a4a !important;
+}
+
+#execute-btn-running {
+  background: #801a1a !important;
+  color: #fff !important;
+  border-radius: 0px !important;
+  font-weight: 700 !important;
+  font-size: 16px !important;
+  text-transform: uppercase !important;
+  border: 2px solid #ff4a4a !important;
+  height: 40px !important;
 }
 
 .code-panel * {
@@ -134,14 +146,14 @@ CSS = """
 }
 
 .terminal-wrap {
-  height: 600px;
+  height: 45vh;
   overflow-y: auto;
-  padding: 12px;
+  padding: 8px;
   font-family: 'JetBrains Mono', monospace;
   font-size: 13px;
-  line-height: 1.6;
+  line-height: 1.5;
   background: #050505;
-  border: 2px solid var(--accent);
+  border: 1px solid var(--panel-border);
 }
 
 .term-line {
@@ -149,20 +161,26 @@ CSS = """
   word-break: break-word;
 }
 
-/* Cyberpunk Log Colors */
-.c-start { color: #E60012; font-weight: bold; }
-.c-end { color: #E60012; font-weight: bold; }
+/* Base Log Colors */
+.c-start { color: #fff; font-weight: bold; }
+.c-end { color: #fff; font-weight: bold; }
 .c-step { color: #39ff14; font-weight: bold; }
 .c-thought { color: #5b7a96; font-style: italic; }
-.c-error { color: #E60012; }
+.c-error { color: #ff4a4a; }
 .c-muted { color: var(--text-dim); }
 
 .metric {
-  border: 1px solid var(--panel-border);
   background: #000;
-  border-radius: 0px;
-  padding: 12px;
-  border-left: 4px solid var(--accent);
+  padding: 4px;
+}
+
+@keyframes pulse-border {
+  0% { border-color: #ff4a4a; box-shadow: 0 0 10px #ff4a4a; }
+  50% { border-color: #2b2b2b; box-shadow: none; }
+  100% { border-color: #ff4a4a; box-shadow: 0 0 10px #ff4a4a; }
+}
+.token-alert > div > input {
+  animation: pulse-border 1.5s infinite;
 }
 """
 
@@ -170,9 +188,8 @@ def _code_from_task_name(task_name: str) -> str:
     task = TASK_MAP.get((task_name or "").strip())
     if not task:
         return (
-            "# Waiting for mission start...\n"
-            "# Tip: Select a target from the Mission Board\n"
-            "# so the buggy sandbox code can be previewed before launch."
+            "# Waiting for selection...\n"
+            "# Tip: Select a target from the Task Selection Grid\n"
         )
     return "\n".join(task.get("code", []))
 
@@ -184,57 +201,13 @@ def _normalize_base_url(base_url: str) -> str:
         candidate = f"http://{candidate}"
     return candidate.rstrip("/")
 
-def _code_from_openenv(task_name: str, env_base_url: str) -> str | None:
-    normalized_url = _normalize_base_url(env_base_url)
-    task_key = (task_name or "").strip()
-    if not task_key:
-        return None
-
-    candidates = [
-        f"{normalized_url}/tasks/{task_key}/code",
-        f"{normalized_url}/task/{task_key}/code",
-        f"{normalized_url}/tasks/{task_key}",
-        f"{normalized_url}/task/{task_key}",
-    ]
-
-    for url in candidates:
-        try:
-            req = urllib.request.Request(url, method="GET")
-            with urllib.request.urlopen(req, timeout=3) as response:
-                if response.status != 200:
-                    continue
-                payload = json.loads(response.read().decode("utf-8"))
-        except (urllib.error.URLError, urllib.error.HTTPError, TimeoutError, ValueError):
-            continue
-
-        if isinstance(payload, dict):
-            code = payload.get("code")
-            if isinstance(code, list):
-                return "\n".join(str(line) for line in code)
-            if isinstance(code, str):
-                return code
-
-            task_data = payload.get("task")
-            if isinstance(task_data, dict):
-                task_code = task_data.get("code")
-                if isinstance(task_code, list):
-                    return "\n".join(str(line) for line in task_code)
-                if isinstance(task_code, str):
-                    return task_code
-    return None
-
 def load_code(task_name: str, env_base_url: str) -> str:
     local_code = _code_from_task_name(task_name)
-    if "Waiting for mission start" not in local_code:
+    if "Waiting for selection" not in local_code:
         return local_code
-
-    api_code = _code_from_openenv(task_name, env_base_url)
-    if api_code:
-        return api_code
-
     return (
         "# Unable to load code for the selected task.\n"
-        "# Verify Task / Bug Selection and confirm OpenEnv API is reachable."
+        "# Verify OpenEnv API is reachable."
     )
 
 def _solution_from_task_name(task_name: str) -> str | None:
@@ -248,7 +221,7 @@ def _terminal_html(lines: list[tuple[str, str]]) -> str:
     for css_class, text in lines:
         safe = html.escape(text)
         rendered.append(f"<div class='term-line {css_class}'>{safe}</div>")
-    content = "\n".join(rendered) if rendered else "<div class='term-line c-muted'>Idle. Configure mission variables and press EXECUTE TRACEFIX.</div>"
+    content = "\n".join(rendered) if rendered else "<div class='term-line c-muted'>Idle. Configure parameters and run agent.</div>"
     return (
         "<div id='terminal' class='terminal-wrap'>"
         f"{content}"
@@ -258,20 +231,20 @@ def _terminal_html(lines: list[tuple[str, str]]) -> str:
         "</script>"
     )
 
-def _metric_block(state: str, details: str) -> str:
-    return (
-        "<div class='metric'>"
-        f"<div><strong>{html.escape(state)}</strong></div>"
-        f"<div style='color:var(--text-dim); margin-top: 6px'>{html.escape(details)}</div>"
-        "</div>"
-    )
-
 def _update_hud_badge(task_name: str, difficulty: str) -> str:
     if not task_name:
-        return "<div style='padding: 10px; color: var(--text-dim); border: 1px dashed var(--panel-border); text-align: center;'>WAITING FOR TARGET SELECTION...</div>"
-    color = "#39ff14" if difficulty == "Easy" else ("#f9d78b" if difficulty == "Medium" else "#E60012")
-    return f"""<div style='border: 2px solid {color}; padding: 12px; background: rgba(0,0,0,0.5); color: {color}; font-weight: 900; font-size: 16px; text-transform: uppercase; text-align: center; letter-spacing: 1.5px;'>
-        >> TARGET ACQUIRED: {html.escape(task_name)} | THREAT LEVEL: {difficulty} <<
+        return "<div style='padding: 6px; color: var(--text-dim); text-align: center; font-size: 14px;'>Waiting for Task Selection...</div>"
+    return f"""<div style='padding: 6px; color: #fff; font-weight: 700; font-size: 15px; text-transform: uppercase; text-align: center;'>
+        Active Task: {html.escape(task_name)} | Difficulty: {difficulty.capitalize()}
+    </div>"""
+
+def _large_metric_html(success: bool, score: float, steps: int, reward: str) -> str:
+    color = "#39ff14" if success else "#ff4a4a"
+    status_text = "SUCCESS" if success else "FAILED"
+    return f"""<div style='text-align: center; padding: 10px; border: 1px solid var(--panel-border); background: #000;'>
+        <h1 style='color: {color}; margin: 0; font-size: 32px; font-weight: 900;'>{status_text}</h1>
+        <h3 style='color: #fff; margin: 4px 0 0 0;'>Score: {score:.2f} | Steps: {steps}</h3>
+        <p style='color: var(--text-dim); margin: 4px 0 0 0;'>Rewards: {html.escape(reward)}</p>
     </div>"""
 
 def _reader_thread(stream: Any, source: str, out_q: queue.Queue[tuple[str, str | None]]) -> None:
@@ -291,10 +264,8 @@ def _build_env(
     model_name: str,
     env_base_url: str,
     task_name: str,
-    benchmark: str,
     max_steps: int,
     success_score_threshold: float,
-    local_image_name: str,
 ) -> dict[str, str]:
     env = os.environ.copy()
     updates = {
@@ -303,10 +274,8 @@ def _build_env(
         "MODEL_NAME": model_name,
         "ENV_BASE_URL": _normalize_base_url(env_base_url),
         "TASK_NAME": task_name,
-        "BENCHMARK": benchmark,
         "MAX_STEPS": str(int(max_steps)),
         "SUCCESS_SCORE_THRESHOLD": str(float(success_score_threshold)),
-        "LOCAL_IMAGE_NAME": local_image_name,
     }
     for key, value in updates.items():
         cleaned = (value or "").strip()
@@ -316,61 +285,90 @@ def _build_env(
             env.pop(key, None)
     return env
 
-def get_active_task(easy, medium, hard):
-    return (easy or medium or hard or "").strip()
 
-def _reset_run_state(easy, medium, hard):
-    task_name = get_active_task(easy, medium, hard)
+def sync_tasks(selected, grid_name):
+    # Depending on which grid was clicked, clear the others and fetch code
+    if grid_name == "easy":
+        easy_val = selected
+        med_val = None
+        hard_val = None
+        diff = "easy"
+    elif grid_name == "medium":
+        easy_val = None
+        med_val = selected
+        hard_val = None
+        diff = "medium"
+    else:
+        easy_val = None
+        med_val = None
+        hard_val = selected
+        diff = "hard"
+        
+    code_content = _code_from_task_name(selected)
+    hud_content = _update_hud_badge(selected, diff)
+    
+    return (
+        selected, 
+        gr.update(value=easy_val), 
+        gr.update(value=med_val), 
+        gr.update(value=hard_val), 
+        hud_content, 
+        code_content
+    )
+
+def validate_and_start(token):
+    if not token or not token.strip():
+        # Empty token: halt execution, render alert, push an error state early
+        return (
+            gr.update(elem_classes=["token-alert"]), 
+            gr.update(value="ERROR: Token Required"), 
+            False
+        )
+    # Valid token
+    return (
+        gr.update(elem_classes=[]), 
+        gr.update(value="RUNNING...", elem_id="execute-btn-running", interactive=False),
+        True
+    )
+
+def _reset_run_state(task_name):
     return (
         _code_from_task_name(task_name),
-        _terminal_html([]),
-        _metric_block("Mission Ready", "Awaiting [START] from inference subprocess..."),
-        0.0,
-        "`Rewards:` pending"
+        _terminal_html([("c-muted", "Boot sequence initialized...")]),
+        "<div style='text-align: center; color: var(--text-dim); padding: 20px;'>Running...</div>"
     )
 
 def run_agent(
-    easy_radio: str,
-    medium_radio: str,
-    hard_radio: str,
+    task_name: str,
     hf_token: str,
     api_base_url: str,
     model_name: str,
     env_base_url: str,
-    benchmark: str,
     max_steps: int,
     success_score_threshold: float,
-    local_image_name: str,
-    difficulty: str,
     show_thought: bool,
-) -> Generator[tuple[str, str, str, float, str, dict], None, None]:
+    proceed: bool
+) -> Generator[tuple[str, str, str, dict], None, None]:
     
-    task_name = get_active_task(easy_radio, medium_radio, hard_radio)
+    if not proceed:
+        # User didn't pass auth check
+        yield (gr.skip(), gr.skip(), gr.skip(), gr.update(value="Run Debugging Agent", interactive=True))
+        return
+
     code_view = _code_from_task_name(task_name)
     terminal_lines: list[tuple[str, str]] = []
-    terminal_lines.append(("c-muted", "Boot sequence initialized... infiltrating target."))
+    terminal_lines.append(("c-muted", "Agent initialized... infiltrating target."))
 
-    status_html = _metric_block("Mission Infiltration", "Launching inference subprocess...")
-    score_value = 0.0
-    rewards_md = "`Rewards:` pending"
-    yield code_view, _terminal_html(terminal_lines), status_html, score_value, rewards_md, gr.update(value="INFILTRATING...", interactive=False)
+    result_html = "<div style='text-align: center; color: var(--text-dim); padding: 20px;'>Awaiting end...</div>"
+    yield code_view, _terminal_html(terminal_lines), result_html, gr.update()
 
     cmd = [sys.executable, str(INFERENCE_PATH)]
-    if difficulty in {"easy", "medium", "hard"}:
-        cmd.append(f"--{difficulty}")
     if show_thought:
         cmd.append("--thought")
 
     env = _build_env(
-        hf_token,
-        api_base_url,
-        model_name,
-        env_base_url,
-        task_name,
-        benchmark,
-        max_steps,
-        success_score_threshold,
-        local_image_name,
+        hf_token, api_base_url, model_name, env_base_url,
+        task_name, max_steps, success_score_threshold
     )
 
     process = subprocess.Popen(
@@ -392,7 +390,6 @@ def run_agent(
     ended_streams: set[str] = set()
     thought_mode = False
     active_task_name = task_name
-    final_steps = 0
 
     while True:
         try:
@@ -421,14 +418,13 @@ def run_agent(
                     terminal_lines.append(("c-thought", line))
             else:
                 if not show_thought:
-                    # Strict gatekeeper rules over stderr leakage too
                     if not any(tag in line for tag in ["[START]", "[STEP]", "[END]"]):
                         continue
                 terminal_lines.append(("c-error", line))
         else:
             if not show_thought:
                 if not any(tag in line for tag in ["[START]", "[STEP]", "[END]"]):
-                    continue # Strict Gatekeeper skipping log
+                    continue
 
             start_match = START_RE.match(line)
             step_match = STEP_RE.match(line)
@@ -437,77 +433,57 @@ def run_agent(
             if start_match:
                 active_task_name = start_match.group("task").strip()
                 task_preview = _code_from_task_name(active_task_name)
-                if "Waiting for mission start" not in task_preview:
+                if "Waiting for selection" not in task_preview:
                     code_view = task_preview
                 terminal_lines.append(("c-start", line))
-                status_html = _metric_block(
-                    "Mission Running",
-                    f"task={active_task_name} | env={start_match.group('env')} | model={start_match.group('model')}",
-                )
             elif step_match:
-                final_steps = int(step_match.group("step"))
-                action = step_match.group("action")
-                reward = float(step_match.group("reward"))
-                done_flag = step_match.group("done") == "true"
                 err = step_match.group("error")
                 css = "c-step" if err == "null" else "c-error"
                 terminal_lines.append((css, line))
-                status_html = _metric_block(
-                    "Mission Running",
-                    f"step={final_steps} action={action} reward={reward:.2f} done={str(done_flag).lower()}",
-                )
             elif end_match:
                 success = end_match.group("success") == "true"
                 final_steps = int(end_match.group("steps"))
                 score_value = float(end_match.group("score"))
                 rewards_raw = end_match.group("rewards").strip()
-                rewards_md = f"`Rewards:` {rewards_raw or 'none'}"
                 terminal_lines.append(("c-end", line))
+                
+                result_html = _large_metric_html(success, score_value, final_steps, rewards_raw or 'none')
+                
                 if success:
                     solved = _solution_from_task_name(active_task_name)
                     if solved:
                         code_view = solved
-                    status_html = _metric_block(
-                        "Mission Success",
-                        f"score={score_value:.2f} | steps={final_steps}",
-                    )
-                else:
-                    status_html = _metric_block(
-                        "Mission Failed",
-                        f"score={score_value:.2f} | steps={final_steps}",
-                    )
             else:
                 terminal_lines.append(("c-muted", line))
 
         if len(terminal_lines) > 500:
             terminal_lines = terminal_lines[-500:]
 
-        yield code_view, _terminal_html(terminal_lines), status_html, score_value, rewards_md, gr.update(value="INFILTRATING...", interactive=False)
+        yield code_view, _terminal_html(terminal_lines), result_html, gr.update()
 
     return_code = process.wait(timeout=2)
     if return_code != 0:
         terminal_lines.append(("c-error", f"Process exited with code {return_code}."))
-        status_html = _metric_block(
-            "Mission Error",
-            f"inference.py exited non-zero (code={return_code})",
-        )
+        result_html = _large_metric_html(False, 0.0, 0, f"Error code {return_code}")
 
     if len(terminal_lines) > 500:
         terminal_lines = terminal_lines[-500:]
 
-    yield code_view, _terminal_html(terminal_lines), status_html, score_value, rewards_md, gr.update(value="EXECUTE TRACEFIX", interactive=True)
+    yield code_view, _terminal_html(terminal_lines), result_html, gr.update(value="Run Debugging Agent", elem_id="execute-btn", interactive=True)
 
 
-with gr.Blocks(title="TraceFix-RL Mission Control") as demo:
+with gr.Blocks(title="TraceFix-RL") as demo:
     gr.HTML(
         f"""
         <style>{CSS}</style>
         <div id='header-wrap'>
-          <h1>TraceFix-RL /// PHANTOM PROTOCOL</h1>
-          <p>Real-time autonomous agent infiltration orchestration.</p>
+          <h1>TraceFix-RL: Auto SWE OpenEnv RL</h1>
+          <p>Professional Autonomous Agent Trace Orchestration.</p>
         </div>
         """
     )
+    
+    selected_task_state = gr.State(value="")
 
     if hasattr(gr, "Sidebar"):
         sidebar_context = gr.Sidebar()
@@ -515,110 +491,88 @@ with gr.Blocks(title="TraceFix-RL Mission Control") as demo:
         sidebar_context = gr.Column()
 
     with sidebar_context:
-        # Zone 1: The Config Sidebar
-        gr.Markdown("### CORE AUTHENTICATION")
-        hf_token = gr.Textbox(label="HF Token", type="password", placeholder="hf_xxx")
+        gr.Markdown("### Authentication")
+        hf_token = gr.Textbox(label="HF Token", type="password", placeholder="hf_xxx", elem_classes=[])
 
-        with gr.Accordion("Advanced Engine Parameters", open=False):
+        with gr.Accordion("Engine Parameters", open=False):
             model_name = gr.Textbox(label="Model Name", value=os.getenv("MODEL_NAME", "openai/gpt-oss-20b"))
             api_base_url = gr.Textbox(label="API Base URL", value=os.getenv("API_BASE_URL", "https://router.huggingface.co/v1"))
             env_base_url = gr.Textbox(label="Env Base URL", value=os.getenv("ENV_BASE_URL", f"http://{BACKEND_HOST}:{BACKEND_PORT}"))
-            benchmark = gr.Textbox(label="Benchmark", value=os.getenv("BENCHMARK", "tracefix_rl"))
-            local_image_name = gr.Textbox(label="Local Image Name", value=os.getenv("LOCAL_IMAGE_NAME", ""), placeholder="optional")
             max_steps = gr.Number(label="Max Steps", value=int(os.getenv("MAX_STEPS", "50")), precision=0)
             success_score_threshold = gr.Number(
                 label="Success Score Threshold",
                 value=float(os.getenv("SUCCESS_SCORE_THRESHOLD", "0.99")),
                 precision=2,
             )
-            difficulty = gr.Dropdown(label="Difficulty", choices=["auto", "easy", "medium", "hard"], value="auto")
-            show_thought = gr.Checkbox(label="Stream Thought Trace", value=True)
+            show_thought = gr.Checkbox(label="Stream Thought Trace", value=False)
 
-    # Zone 2: The Mission Board
-    gr.HTML("<div class='panel-title' style='margin-top: 10px;'>MISSION BOARD /// TARGET SELECTION</div>")
+    gr.HTML("<div class='panel-title'>Task Selection Grid</div>")
     with gr.Row(elem_classes=["panel"]):
         easy_radio = gr.Radio(choices=EASY_CHOICES, label="Easy Targets", elem_id="easy-radio")
         medium_radio = gr.Radio(choices=MEDIUM_CHOICES, label="Medium Targets", elem_id="medium-radio")
         hard_radio = gr.Radio(choices=HARD_CHOICES, label="Hard Targets", elem_id="hard-radio")
 
-    # Zone 3: The HUD 
     hud_badge = gr.HTML(_update_hud_badge("", ""))
-    run_button = gr.Button("EXECUTE TRACEFIX", elem_id="execute-btn", variant="primary")
+    run_button = gr.Button("Run Debugging Agent", elem_id="execute-btn", variant="primary")
 
-    # Radio change handlers for mutual exclusivity logic & HUD updates
-    def select_easy(val):
-        if not val:
-            return gr.skip(), gr.skip(), gr.skip(), gr.skip()
-        return None, None, _update_hud_badge(val, "Easy"), _code_from_task_name(val)
+    # Sync tasks correctly
+    easy_radio.change(lambda x: sync_tasks(x, "easy"), inputs=[easy_radio], outputs=[selected_task_state, easy_radio, medium_radio, hard_radio, hud_badge, code_view] if 'code_view' in locals() else None)
+    medium_radio.change(lambda x: sync_tasks(x, "medium"), inputs=[medium_radio], outputs=[selected_task_state, easy_radio, medium_radio, hard_radio, hud_badge, code_view] if 'code_view' in locals() else None)
+    hard_radio.change(lambda x: sync_tasks(x, "hard"), inputs=[hard_radio], outputs=[selected_task_state, easy_radio, medium_radio, hard_radio, hud_badge, code_view] if 'code_view' in locals() else None)
 
-    def select_medium(val):
-        if not val:
-            return gr.skip(), gr.skip(), gr.skip(), gr.skip()
-        return None, None, _update_hud_badge(val, "Medium"), _code_from_task_name(val)
 
-    def select_hard(val):
-        if not val:
-            return gr.skip(), gr.skip(), gr.skip(), gr.skip()
-        return None, None, _update_hud_badge(val, "Hard"), _code_from_task_name(val)
-
-    # Zone 4: The Arena
     with gr.Row(equal_height=True):
         with gr.Column(scale=1, elem_classes=["panel", "code-panel"]):
-            gr.HTML("<div class='panel-title'>SANDBOX CODE</div>")
+            gr.HTML("<div class='panel-title'>Sandbox Source Code</div>")
             code_view = gr.Code(
                 language="python",
                 interactive=False,
                 value=_code_from_task_name(""),
-                lines=30,
             )
+            # Override height via CSS
+            gr.HTML("<style>.code-panel .cm-content { height: 45vh; overflow-y: auto; }</style>")
 
         with gr.Column(scale=1, elem_classes=["panel"]):
-            gr.HTML("<div class='panel-title'>TERMINAL TRACE</div>")
+            gr.HTML("<div class='panel-title'>Terminal Trace</div>")
             terminal = gr.HTML(_terminal_html([]))
 
-    with gr.Row():
-        metric = gr.HTML(_metric_block("Idle", "Awaiting target selection."))
-        score = gr.Number(label="Final Score", value=0.0, precision=3)
-        rewards = gr.Markdown("`Rewards:` pending")
+    with gr.Row(elem_classes=["panel"]):
+        result_block = gr.HTML("<div style='text-align: center; color: var(--text-dim); padding: 20px;'>Awaiting Execution</div>")
 
-    easy_radio.change(select_easy, inputs=[easy_radio], outputs=[medium_radio, hard_radio, hud_badge, code_view])
-    medium_radio.change(select_medium, inputs=[medium_radio], outputs=[easy_radio, hard_radio, hud_badge, code_view])
-    hard_radio.change(select_hard, inputs=[hard_radio], outputs=[easy_radio, medium_radio, hud_badge, code_view])
+    # Due to 'code_view' not being defined above when change was defined, we must re-bind the change events to include code_view.
+    easy_radio.change(lambda x: sync_tasks(x, "easy"), inputs=[easy_radio], outputs=[selected_task_state, easy_radio, medium_radio, hard_radio, hud_badge, code_view])
+    medium_radio.change(lambda x: sync_tasks(x, "medium"), inputs=[medium_radio], outputs=[selected_task_state, easy_radio, medium_radio, hard_radio, hud_badge, code_view])
+    hard_radio.change(lambda x: sync_tasks(x, "hard"), inputs=[hard_radio], outputs=[selected_task_state, easy_radio, medium_radio, hard_radio, hud_badge, code_view])
 
     # Run Sequence
-    # First disable button to show immediate feedback
-    run_immediate = run_button.click(
-        lambda: gr.update(value="INFILTRATING...", interactive=False),
-        inputs=[],
-        outputs=[run_button],
+    run_state = gr.State(value=True)
+
+    validate_step = run_button.click(
+        validate_and_start,
+        inputs=[hf_token],
+        outputs=[hf_token, run_button, run_state],
         queue=False
     )
     
-    # Then reset state
-    run_event = run_immediate.then(
+    reset_step = validate_step.then(
         _reset_run_state,
-        inputs=[easy_radio, medium_radio, hard_radio],
-        outputs=[code_view, terminal, metric, score, rewards],
+        inputs=[selected_task_state],
+        outputs=[code_view, terminal, result_block],
         queue=False,
     )
 
-    # Finally run generator (loads environment, streams stdout, then re-enables button upon END)
-    run_event.then(
+    reset_step.then(
         run_agent,
         inputs=[
-            easy_radio,
-            medium_radio,
-            hard_radio,
+            selected_task_state,
             hf_token,
             api_base_url,
             model_name,
             env_base_url,
-            benchmark,
             max_steps,
             success_score_threshold,
-            local_image_name,
-            difficulty,
             show_thought,
+            run_state
         ],
-        outputs=[code_view, terminal, metric, score, rewards, run_button],
+        outputs=[code_view, terminal, result_block, run_button],
     )