Revert "Add model playground demo UI"

This reverts commit a000f2ac127075ec4693648b000a950d19c03e74.

env/app.py

@@ -1,6 +1,5 @@
 from __future__ import annotations
 
-from html import escape
 from uuid import uuid4
 
 import gradio as gr
@@ -12,15 +11,6 @@ from server.runtime import SpaceTrainingManager
 TRAINING_MANAGER = SpaceTrainingManager()
 SESSIONS: dict[str, AdaptEnvironment] = {}
 
-PLAYGROUND_DEFAULT_PROBLEM = (
-    "Given an array of integers, return the length of the longest contiguous subarray "
-    "whose sum is divisible by k."
-)
-PLAYGROUND_DEFAULT_INPUT = (
-    "The first line contains two integers n and k. The second line contains n space-separated integers."
-)
-PLAYGROUND_DEFAULT_CONSTRAINTS = "1 <= n <= 2 * 10^5, 1 <= k <= 10^9, array values fit in 32-bit signed integers."
-
 
 def _get_env(session_id: str | None) -> AdaptEnvironment:
     if not session_id or session_id not in SESSIONS:
@@ -53,8 +43,6 @@ def sample_problem(problem_id: str, difficulty: str) -> tuple[str, str, str, str
         "",
         payload,
     )
-
-
 def evaluate_submission(session_id: str, code: str) -> tuple[str, str, str, dict]:
     env = _get_env(session_id)
     observation = env.step(AdaptAction(session_id=env.session_id, code=code))
@@ -107,314 +95,81 @@ def model_attempt(session_id: str) -> tuple[str, str, str, dict]:
     return evaluate_submission(session_id, generation["code"])
 
 
-def _format_accuracy(value: float | None) -> str:
-    if value is None:
-        return "Unavailable"
-    return f"{value * 100:.1f}%"
-
-
-def _format_progress(completed_steps: int, total_steps: int, progress_ratio: float) -> str:
-    if total_steps > 0:
-        return f"{completed_steps}/{total_steps} steps ({progress_ratio * 100:.1f}%)"
-    return "No active training run"
-
-
-def _render_metrics_card(metrics: dict) -> str:
-    overall_accuracy = metrics.get("overall_accuracy")
-    baseline_accuracy = metrics.get("baseline_accuracy")
-    live_pass_rate = metrics.get("live_pass_rate")
-    metric_source = metrics.get("metric_source", "unavailable")
-    training_status = escape(str(metrics.get("training_status", "unknown")).replace("_", " ").title())
-    phase = escape(str(metrics.get("phase", "idle")).replace("_", " ").title())
-    progress = escape(
-        _format_progress(
-            int(metrics.get("completed_steps", 0) or 0),
-            int(metrics.get("total_steps", 0) or 0),
-            float(metrics.get("progress_ratio", 0.0) or 0.0),
-        )
-    )
-    source_label = {
-        "trained_eval": "Final evaluation metric",
-        "rolling_pass_rate": "Live rolling pass rate",
-        "unavailable": "Metric unavailable",
-    }.get(metric_source, "Metric unavailable")
-    source_label = escape(source_label)
-    live_pass_rate_text = escape(_format_accuracy(live_pass_rate))
-    overall_accuracy_text = escape(_format_accuracy(overall_accuracy))
-    baseline_accuracy_text = escape(_format_accuracy(baseline_accuracy))
-
-    return f"""
-    <div class="panel metrics-card">
-      <div class="metrics-header">
-        <div>
-          <div class="metrics-eyebrow">Live Demo Dashboard</div>
-          <h3>Model Accuracy Tracker</h3>
-        </div>
-        <div class="metrics-chip">{source_label}</div>
-      </div>
-      <div class="metrics-grid">
-        <div class="metric-tile">
-          <span>Overall Accuracy</span>
-          <strong>{overall_accuracy_text}</strong>
-        </div>
-        <div class="metric-tile">
-          <span>Base Accuracy</span>
-          <strong>{baseline_accuracy_text}</strong>
-        </div>
-        <div class="metric-tile">
-          <span>Live Pass Rate</span>
-          <strong>{live_pass_rate_text}</strong>
-        </div>
-        <div class="metric-tile">
-          <span>Training Phase</span>
-          <strong>{phase}</strong>
-        </div>
-      </div>
-      <div class="metrics-footer">
-        <span>Status: <strong>{training_status}</strong></span>
-        <span>Progress: <strong>{progress}</strong></span>
-      </div>
-    </div>
-    """
-
-
-def playground_metrics_view() -> str:
-    payload = TRAINING_MANAGER.status_payload()
-    metrics = payload.get("demo_metrics", {})
-    return _render_metrics_card(metrics if isinstance(metrics, dict) else {})
-
-
-def _model_badge(result: dict | None, label: str, error: str | None = None) -> str:
-    if error:
-        return f"### {label}\nStatus: {error}"
-    if not result:
-        return f"### {label}\nStatus: No generation yet."
-    model = result.get("model", {}) if isinstance(result.get("model"), dict) else {}
-    effective_model = str(result.get("effective_model", model.get("active_model_kind", "unavailable"))).replace("_", " ")
-    source = model.get("source_repo_id") or model.get("base_model_name") or model.get("local_path") or "unknown source"
-    details = [f"Status: {effective_model.title()}"]
-    if model.get("fallback_reason"):
-        details.append("Fallback: trained model unavailable, using base model")
-    details.append(f"Source: {source}")
-    if model.get("revision"):
-        details.append(f"Revision: {model['revision']}")
-    return f"### {label}\n" + "\n".join(details)
-
-
-def compare_models(problem: str, input_format: str, constraints: str) -> tuple[str, str, str, str]:
-    if not problem.strip():
-        message = "Please enter a problem statement before generating solutions."
-        return "", "", _model_badge(None, "Base Model", message), _model_badge(None, "ADAPT-Trained Model", message)
-    if not input_format.strip():
-        message = "Please provide the input format so the model prompt is well-formed."
-        return "", "", _model_badge(None, "Base Model", message), _model_badge(None, "ADAPT-Trained Model", message)
-    if not constraints.strip():
-        message = "Please provide constraints so the model can target the expected solution shape."
-        return "", "", _model_badge(None, "Base Model", message), _model_badge(None, "ADAPT-Trained Model", message)
-
-    base_result: dict | None = None
-    trained_result: dict | None = None
-    base_error: str | None = None
-    trained_error: str | None = None
-
-    try:
-        base_result = TRAINING_MANAGER.generate_code(
-            problem=problem,
-            input_format=input_format,
-            constraints=constraints,
-            target_model="base",
-        )
-    except Exception as exc:
-        base_error = str(exc)
-
-    try:
-        trained_result = TRAINING_MANAGER.generate_code(
-            problem=problem,
-            input_format=input_format,
-            constraints=constraints,
-            target_model="current",
-        )
-    except Exception as exc:
-        trained_error = str(exc)
-
-    return (
-        base_result.get("code", "") if base_result else "",
-        trained_result.get("code", "") if trained_result else "",
-        _model_badge(base_result, "Base Model", base_error),
-        _model_badge(trained_result, "ADAPT-Trained Model", trained_error),
-    )
-
-
 with gr.Blocks(
     title="ADAPT DSA Tutor Demo",
     css="""
     .panel {border: 1px solid #d7d3c9; border-radius: 18px; background: #fffaf2;}
     .hero {background: linear-gradient(135deg, #f7eedb, #f3f8ef); border-radius: 22px; padding: 18px;}
-    .metrics-card {padding: 18px;}
-    .metrics-header {display: flex; justify-content: space-between; align-items: flex-start; gap: 12px; margin-bottom: 14px;}
-    .metrics-header h3 {margin: 4px 0 0; font-size: 1.2rem;}
-    .metrics-eyebrow {font-size: 0.8rem; letter-spacing: 0.08em; text-transform: uppercase; color: #816b45;}
-    .metrics-chip {background: #efe3c6; color: #6f5529; border-radius: 999px; padding: 6px 10px; font-size: 0.85rem;}
-    .metrics-grid {display: grid; grid-template-columns: repeat(4, minmax(0, 1fr)); gap: 12px; margin-bottom: 14px;}
-    .metric-tile {background: #fff; border: 1px solid #eadfc9; border-radius: 14px; padding: 12px;}
-    .metric-tile span {display: block; font-size: 0.82rem; color: #7a6541; margin-bottom: 6px;}
-    .metric-tile strong {font-size: 1.1rem; color: #2f2412;}
-    .metrics-footer {display: flex; justify-content: space-between; gap: 12px; flex-wrap: wrap; color: #5c4c30;}
-    @media (max-width: 900px) {
-      .metrics-grid {grid-template-columns: repeat(2, minmax(0, 1fr));}
-    }
-    @media (max-width: 640px) {
-      .metrics-grid {grid-template-columns: minmax(0, 1fr);}
-    }
     """,
 ) as demo:
-    with gr.Tab("Verifier Sandbox"):
-        session_id = gr.Textbox(label="Session ID", interactive=False)
-        state_payload = gr.JSON(label="Observation Payload")
-
-        gr.Markdown(
-            """
-            # ADAPT DSA Tutor
-            Sample a problem, inspect the verifier feedback, and compare your repair attempt with the currently loaded model path.
-            """,
-            elem_classes=["hero"],
-        )
-
-        with gr.Row():
-            problem_id = gr.Dropdown(
-                choices=[
-                    "",
-                    "sum_even_numbers",
-                    "range_span",
-                    "count_vowels",
-                    "max_consecutive_ones",
-                    "fizzbuzz_variant",
-                    "running_total",
-                    "count_local_peaks",
-                    "longest_non_decreasing_run",
-                    "two_sum_count",
-                    "max_subarray_sum",
-                    "group_anagrams_count",
-                    "balanced_brackets",
-                    "matrix_diagonal_sum",
-                    "smallest_most_frequent",
-                    "reverse_words",
-                    "longest_common_subsequence",
-                    "word_ladder_steps",
-                    "merge_intervals",
-                    "min_coins",
-                    "rotate_matrix_90",
-                ],
-                value="",
-                label="Problem Family",
-                info="Leave blank to sample automatically.",
-            )
-            difficulty = gr.Radio(choices=["easy", "medium", "hard"], value="easy", label="Difficulty")
-            sample_btn = gr.Button("Sample Problem", variant="primary")
-
-        problem_view = gr.Markdown(elem_classes=["panel"])
-        with gr.Row():
-            code = gr.Textbox(
-                label="Python Submission",
-                lines=18,
-                max_lines=24,
-                placeholder="Write code that reads stdin and prints stdout.",
-            )
-            with gr.Column():
-                feedback = gr.Textbox(label="Verifier Feedback", lines=14)
-                status = gr.Textbox(label="Scorecard", lines=4)
-                with gr.Row():
-                    verify_btn = gr.Button("Verify Submission", variant="primary")
-                    model_btn = gr.Button("Run Current Model", variant="secondary")
-
-        sample_btn.click(
-            fn=sample_problem,
-            inputs=[problem_id, difficulty],
-            outputs=[session_id, problem_view, feedback, code, state_payload],
-        )
-        verify_btn.click(
-            fn=evaluate_submission,
-            inputs=[session_id, code],
-            outputs=[feedback, status, code, state_payload],
-        )
-        model_btn.click(
-            fn=model_attempt,
-            inputs=[session_id],
-            outputs=[feedback, status, code, state_payload],
-        )
-
-    with gr.Tab("Model Playground"):
-        gr.Markdown(
-            """
-            # Model Playground
-            Paste a problem and compare how the base model stacks up against the current ADAPT-powered solver while training metrics refresh live below.
-            """,
-            elem_classes=["hero"],
-        )
-        playground_timer = gr.Timer(value=5)
-
-        problem_text = gr.Textbox(
-            label="Problem",
-            lines=8,
-            value=PLAYGROUND_DEFAULT_PROBLEM,
-            placeholder="Paste the full problem statement here.",
-        )
-        with gr.Row():
-            input_format_text = gr.Textbox(
-                label="Input Format",
-                lines=5,
-                value=PLAYGROUND_DEFAULT_INPUT,
-                placeholder="Describe how stdin is formatted.",
-            )
-            constraints_text = gr.Textbox(
-                label="Constraints",
-                lines=5,
-                value=PLAYGROUND_DEFAULT_CONSTRAINTS,
-                placeholder="Add the important bounds and edge constraints.",
-            )
-        with gr.Row():
-            generate_btn = gr.Button("Generate Solutions", variant="primary")
-            clear_btn = gr.Button("Clear", variant="secondary")
-
-        with gr.Row():
-            with gr.Column():
-                base_code = gr.Code(label="Base Model Output", language="python", lines=20)
-                base_status = gr.Markdown(_model_badge(None, "Base Model"))
-            with gr.Column():
-                trained_code = gr.Code(label="ADAPT-Trained Model Output", language="python", lines=20)
-                trained_status = gr.Markdown(_model_badge(None, "ADAPT-Trained Model"))
-
-        metrics_dashboard = gr.HTML(playground_metrics_view())
+    session_id = gr.Textbox(label="Session ID", interactive=False)
+    state_payload = gr.JSON(label="Observation Payload")
+
+    gr.Markdown(
+        """
+        # ADAPT DSA Tutor
+        Sample a problem, inspect the verifier feedback, and compare your repair attempt with the currently loaded model path.
+        """,
+        elem_classes=["hero"],
+    )
 
-        generate_btn.click(
-            fn=compare_models,
-            inputs=[problem_text, input_format_text, constraints_text],
-            outputs=[base_code, trained_code, base_status, trained_status],
-        )
-        clear_btn.click(
-            fn=lambda: (
-                "",
+    with gr.Row():
+        problem_id = gr.Dropdown(
+            choices=[
                 "",
-                "",
-                "",
-                "",
-                _model_badge(None, "Base Model"),
-                _model_badge(None, "ADAPT-Trained Model"),
-                playground_metrics_view(),
-            ),
-            outputs=[
-                problem_text,
-                input_format_text,
-                constraints_text,
-                base_code,
-                trained_code,
-                base_status,
-                trained_status,
-                metrics_dashboard,
+                "sum_even_numbers",
+                "range_span",
+                "count_vowels",
+                "max_consecutive_ones",
+                "fizzbuzz_variant",
+                "running_total",
+                "count_local_peaks",
+                "longest_non_decreasing_run",
+                "two_sum_count",
+                "max_subarray_sum",
+                "group_anagrams_count",
+                "balanced_brackets",
+                "matrix_diagonal_sum",
+                "smallest_most_frequent",
+                "reverse_words",
+                "longest_common_subsequence",
+                "word_ladder_steps",
+                "merge_intervals",
+                "min_coins",
+                "rotate_matrix_90",
             ],
+            value="",
+            label="Problem Family",
+            info="Leave blank to sample automatically.",
         )
-        playground_timer.tick(fn=playground_metrics_view, outputs=[metrics_dashboard])
-        demo.load(fn=playground_metrics_view, outputs=[metrics_dashboard])
+        difficulty = gr.Radio(choices=["easy", "medium", "hard"], value="easy", label="Difficulty")
+        sample_btn = gr.Button("Sample Problem", variant="primary")
+
+    problem_view = gr.Markdown(elem_classes=["panel"])
+    with gr.Row():
+        code = gr.Textbox(label="Python Submission", lines=18, max_lines=24, placeholder="Write code that reads stdin and prints stdout.")
+        with gr.Column():
+            feedback = gr.Textbox(label="Verifier Feedback", lines=14)
+            status = gr.Textbox(label="Scorecard", lines=4)
+            with gr.Row():
+                verify_btn = gr.Button("Verify Submission", variant="primary")
+                model_btn = gr.Button("Run Current Model", variant="secondary")
+
+    sample_btn.click(
+        fn=sample_problem,
+        inputs=[problem_id, difficulty],
+        outputs=[session_id, problem_view, feedback, code, state_payload],
+    )
+    verify_btn.click(
+        fn=evaluate_submission,
+        inputs=[session_id, code],
+        outputs=[feedback, status, code, state_payload],
+    )
+    model_btn.click(
+        fn=model_attempt,
+        inputs=[session_id],
+        outputs=[feedback, status, code, state_payload],
+    )
 
 
 if __name__ == "__main__":

server/app.py

@@ -99,7 +99,6 @@ class GenerateCodeRequest(BaseModel):
     attempt_number: int = 1
     max_steps: int = 1
     max_new_tokens: int = 512
-    target_model: str = "current"
 
 
 def _metadata() -> dict[str, Any]:
@@ -254,7 +253,6 @@ def generate_code(request: GenerateCodeRequest) -> dict[str, Any]:
             attempt_number=request.attempt_number,
             max_steps=request.max_steps,
             max_new_tokens=request.max_new_tokens,
-            target_model=request.target_model,
         )
     except RuntimeError as exc:
         raise HTTPException(status_code=409, detail=str(exc)) from exc

server/runtime.py

@@ -49,15 +49,6 @@ def _json_safe(value: Any) -> Any:
     return value
 
 
-def _safe_float(value: Any) -> float | None:
-    try:
-        if value is None:
-            return None
-        return float(value)
-    except (TypeError, ValueError):
-        return None
-
-
 @dataclass
 class ModelState:
     loaded: bool = False
@@ -233,28 +224,13 @@ class SpaceModelRegistry:
 
     def _base_generation_stack(self) -> tuple[Any, Any, dict[str, Any]]:
         try:
-            self.load_base_model()
+            base_state = self.load_base_model()
         except Exception as exc:
             raise RuntimeError(f"Base model load failed: {exc}") from exc
         with self._lock:
             if self._base_model is None or self._base_tokenizer is None:
                 raise RuntimeError("Base model could not be loaded for fallback generation.")
-            return self._base_model, self._base_tokenizer, self._base_status_payload()
-
-    def _base_status_payload(self) -> dict[str, Any]:
-        with self._lock:
-            payload = {
-                "loaded": self._base_model is not None and self._base_tokenizer is not None,
-                "active_model_kind": "base",
-                "source_repo_id": self._state.source_repo_id,
-                "local_path": self._base_model_name(),
-                "revision": None,
-                "base_model_name": self._base_model_name(),
-                "loaded_at": _iso_or_none(self._state.loaded_at),
-                "error": None,
-                "cache_dir": str(self.cache_dir),
-            }
-        return payload
+            return self._base_model, self._base_tokenizer, base_state
 
     def _generate_with_possible_base_fallback(
         self,
@@ -293,26 +269,6 @@ class SpaceModelRegistry:
                 return completion, fallback_state
             raise RuntimeError(f"Generation failed: {exc}") from exc
 
-    def _generate_with_stack(
-        self,
-        *,
-        prompt: str,
-        max_new_tokens: int,
-        model: Any,
-        tokenizer: Any,
-        model_state: dict[str, Any],
-    ) -> tuple[str, dict[str, Any]]:
-        try:
-            completion = generate_completion(
-                model=model,
-                tokenizer=tokenizer,
-                prompt=prompt,
-                max_new_tokens=max_new_tokens,
-            )
-        except Exception as exc:
-            raise RuntimeError(f"Generation failed: {exc}") from exc
-        return completion, model_state
-
     def load_base_model(self) -> dict[str, Any]:
         torch, _, model_components = self._require_runtime_dependencies()
         AutoModelForCausalLM, AutoTokenizer = model_components
@@ -320,15 +276,12 @@ class SpaceModelRegistry:
 
         with self._lock:
             if self._base_model is not None and self._base_tokenizer is not None:
-                if self._model is None or self._tokenizer is None:
-                    self._set_state(
-                        base_model_name=base_model_name,
-                        active_model_kind="base",
-                        loaded=True,
-                        error=None,
-                    )
-                else:
-                    self._set_state(base_model_name=base_model_name, error=None)
+                self._set_state(
+                    base_model_name=base_model_name,
+                    active_model_kind="base",
+                    loaded=True,
+                    error=None,
+                )
                 return self.status_payload()
 
             if torch.cuda.is_available() and torch.cuda.is_bf16_supported():
@@ -356,18 +309,15 @@ class SpaceModelRegistry:
                 model.eval()
             self._base_model = model
             self._base_tokenizer = tokenizer
-            if self._model is None or self._tokenizer is None:
-                self._set_state(
-                    loaded=True,
-                    active_model_kind="base",
-                    base_model_name=base_model_name,
-                    local_path=base_model_name,
-                    revision=None,
-                    loaded_at=_utc_now(),
-                    error=None,
-                )
-            else:
-                self._set_state(base_model_name=base_model_name, error=None)
+            self._set_state(
+                loaded=True,
+                active_model_kind="base",
+                base_model_name=base_model_name,
+                local_path=base_model_name,
+                revision=None,
+                loaded_at=_utc_now(),
+                error=None,
+            )
             return self.status_payload()
 
     def load_from_local(
@@ -566,7 +516,6 @@ class SpaceModelRegistry:
         attempt_number: int = 1,
         max_steps: int = 1,
         max_new_tokens: int = 512,
-        target_model: str = "current",
     ) -> dict[str, Any]:
         prompt = build_solver_prompt(
             {
@@ -581,30 +530,11 @@ class SpaceModelRegistry:
                 "feedback": feedback or "No previous attempt yet. Solve the problem directly.",
             }
         )
-        if target_model == "base":
-            model, tokenizer, model_state = self._base_generation_stack()
-            completion, model_state = self._generate_with_stack(
-                prompt=prompt,
-                max_new_tokens=max_new_tokens,
-                model=model,
-                tokenizer=tokenizer,
-                model_state=model_state,
-            )
-        elif target_model == "trained":
-            model, tokenizer, model_state = self._active_generation_stack(allow_base_fallback=False)
-            completion, model_state = self._generate_with_stack(
-                prompt=prompt,
-                max_new_tokens=max_new_tokens,
-                model=model,
-                tokenizer=tokenizer,
-                model_state=model_state,
-            )
-        else:
-            completion, model_state = self._generate_with_possible_base_fallback(
-                prompt=prompt,
-                max_new_tokens=max_new_tokens,
-                allow_base_fallback=True,
-            )
+        completion, model_state = self._generate_with_possible_base_fallback(
+            prompt=prompt,
+            max_new_tokens=max_new_tokens,
+            allow_base_fallback=True,
+        )
         return {
             "problem_id": problem_id,
             "problem_type": problem_type,
@@ -614,8 +544,6 @@ class SpaceModelRegistry:
             "code": extract_code(completion),
             "model": model_state,
             "system_prompt": SYSTEM_PROMPT,
-            "requested_model": target_model,
-            "effective_model": model_state.get("active_model_kind", "unavailable"),
         }
 
 
@@ -713,95 +641,13 @@ class SpaceTrainingManager:
             )
             self._persist_status()
 
-    def _read_json_file(self, path: str | Path | None) -> dict[str, Any] | None:
-        if not path:
-            return None
-        candidate = Path(path)
-        if not candidate.exists():
-            return None
-        try:
-            payload = json.loads(candidate.read_text(encoding="utf-8"))
-        except Exception:
-            return None
-        return payload if isinstance(payload, dict) else None
-
-    def _find_latest_run_summary(self) -> dict[str, Any] | None:
-        current_summary = self._read_json_file(self._job.run_summary_path)
-        if current_summary is not None:
-            return current_summary
-
-        latest_summary: dict[str, Any] | None = None
-        latest_mtime = -1.0
-        for candidate in self.runs_dir.glob("**/logs/run_summary.json"):
-            try:
-                mtime = candidate.stat().st_mtime
-            except OSError:
-                continue
-            if mtime <= latest_mtime:
-                continue
-            payload = self._read_json_file(candidate)
-            if payload is None:
-                continue
-            latest_summary = payload
-            latest_mtime = mtime
-        return latest_summary
-
-    def _demo_metrics_payload(self) -> dict[str, Any]:
-        with self._lock:
-            baseline_summary = dict(self._job.baseline_summary)
-            trained_summary = dict(self._job.trained_summary)
-            training_status = self._job.status
-            phase = self._job.phase
-            progress_ratio = float(self._job.progress_ratio or 0.0)
-            completed_steps = int(self._job.completed_steps or 0)
-            total_steps = int(self._job.total_steps or 0)
-
-        run_summary = self._find_latest_run_summary() or {}
-        final_metrics = run_summary.get("final_metrics", {}) if isinstance(run_summary.get("final_metrics"), dict) else {}
-        rolling_metrics = (
-            run_summary.get("rolling_metrics", {}) if isinstance(run_summary.get("rolling_metrics"), dict) else {}
-        )
-        final_trained_summary = (
-            final_metrics.get("trained_summary", {}) if isinstance(final_metrics.get("trained_summary"), dict) else {}
-        )
-        final_baseline_summary = (
-            final_metrics.get("baseline_summary", {}) if isinstance(final_metrics.get("baseline_summary"), dict) else {}
-        )
-
-        trained_overall = _safe_float(trained_summary.get("overall"))
-        baseline_overall = _safe_float(baseline_summary.get("overall"))
-        if trained_overall is None:
-            trained_overall = _safe_float(final_trained_summary.get("overall"))
-        if baseline_overall is None:
-            baseline_overall = _safe_float(final_baseline_summary.get("overall"))
-
-        live_pass_rate = _safe_float(rolling_metrics.get("avg_pass_rate"))
-        overall_accuracy = trained_overall
-        metric_source = "trained_eval" if overall_accuracy is not None else "unavailable"
-        if overall_accuracy is None and live_pass_rate is not None:
-            overall_accuracy = live_pass_rate
-            metric_source = "rolling_pass_rate"
-
-        return {
-            "overall_accuracy": overall_accuracy,
-            "baseline_accuracy": baseline_overall,
-            "live_pass_rate": live_pass_rate,
-            "training_status": training_status,
-            "phase": phase,
-            "progress_ratio": round(progress_ratio, 4),
-            "completed_steps": completed_steps,
-            "total_steps": total_steps,
-            "metric_source": metric_source,
-        }
-
     def status_payload(self) -> dict[str, Any]:
         with self._lock:
             payload = self._job.to_dict()
             payload["output_root"] = str(self.output_root)
             payload["status_file"] = str(self.status_file)
             payload["active"] = payload["status"] == "running"
-        payload["demo_metrics"] = self._demo_metrics_payload()
-        return payload
+            return payload
 
     def model_status_payload(self) -> dict[str, Any]:
         return self.model_registry.status_payload()
@@ -1048,7 +894,6 @@ class SpaceTrainingManager:
         attempt_number: int = 1,
         max_steps: int = 1,
         max_new_tokens: int = 512,
-        target_model: str = "current",
     ) -> dict[str, Any]:
         return self.model_registry.generate_code(
             problem=problem,
@@ -1061,5 +906,4 @@ class SpaceTrainingManager:
             attempt_number=attempt_number,
             max_steps=max_steps,
             max_new_tokens=max_new_tokens,
-            target_model=target_model,
         )