Upload folder using huggingface_hub

Dockerfile

@@ -0,0 +1,73 @@
+# Multi-stage build for Rust Coder Environment
+# Build context: repo root (contains models.py, problems.json, pyproject.toml, uv.lock)
+ARG BASE_IMAGE=ghcr.io/meta-pytorch/openenv-base:latest
+FROM ${BASE_IMAGE} AS builder
+
+# 1. Environment Setup
+USER root
+WORKDIR /app
+
+# Install build essentials for Rust (linker, etc.)
+RUN apt-get update && \
+    apt-get install -y --no-install-recommends git curl build-essential ca-certificates && \
+    rm -rf /var/lib/apt/lists/*
+
+# 2. Create the non-root user (Hugging Face default)
+RUN useradd -m -u 1000 user
+USER user
+ENV HOME=/home/user \
+    PATH=/home/user/.cargo/bin:/home/user/.local/bin:$PATH
+
+# 3. Install Rust toolchain as 'user'
+RUN curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y --default-toolchain stable
+RUN rustup toolchain install stable
+
+# 4. Copy environment code and install Python dependencies
+WORKDIR $HOME/app/env
+COPY --chown=user . $HOME/app/env
+
+# Install uv (if not present) and then the virtual environment
+RUN if ! command -v uv >/dev/null 2>&1; then \
+        curl -LsSf https://astral.sh/uv/install.sh | sh; \
+    fi
+
+RUN --mount=type=cache,target=/home/user/.cache/uv,uid=1000,gid=1000 \
+    uv sync --no-editable
+
+# -------------------------------------------------------------
+# Final Runtime Stage
+# -------------------------------------------------------------
+FROM ${BASE_IMAGE}
+
+USER root
+RUN apt-get update && \
+    apt-get install -y --no-install-recommends curl build-essential ca-certificates && \
+    rm -rf /var/lib/apt/lists/*
+
+# Create the user again in the final stage
+RUN useradd -m -u 1000 user
+USER user
+ENV HOME=/home/user \
+    PATH="/home/user/app/env/.venv/bin:/home/user/.cargo/bin:$PATH" \
+    PYTHONPATH="/home/user/app/env:$PYTHONPATH"
+
+# Copy Cargo/Rustup from builder and then the local code
+COPY --from=builder --chown=user /home/user/.cargo /home/user/.cargo
+COPY --from=builder --chown=user /home/user/.rustup /home/user/.rustup
+
+WORKDIR $HOME/app/env
+COPY --chown=user . $HOME/app/env
+
+# Install uv and Python dependencies in the FINAL stage
+RUN curl -LsSf https://astral.sh/uv/install.sh | sh
+RUN uv sync --no-editable
+
+# -------------------------------------------------------------
+# Final Config
+# -------------------------------------------------------------
+EXPOSE 8000
+HEALTHCHECK --interval=30s --timeout=5s --start-period=10s --retries=3 \
+    CMD curl -f http://localhost:8000/health || exit 1
+
+ENV ENABLE_WEB_INTERFACE=true
+CMD ["/home/user/app/env/.venv/bin/uvicorn", "server.app:app", "--host", "0.0.0.0", "--port", "8000", "--log-level", "info"]

README.md

@@ -1,10 +1,218 @@
 ---
-title: Rust Coder
-emoji: 🚀
-colorFrom: purple
-colorTo: indigo
+title: Rust Coder OpenEnv
+emoji: 🦀
+colorFrom: red
+colorTo: yellow
 sdk: docker
+app_port: 8000
+base_path: /web
 pinned: false
+tags:
+  - openenv
+  - software-engineering
+  - rust
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Rust Coder: Systems Engineering Environment
+
+Rust Coder is a high-fidelity **OpenEnv** environment designed to evaluate and train LLM agents on real-world Rust systems programming tasks. Unlike toy environments, Rust Coder simulates valid engineering scenarios involving the borrow checker, concurrency, and memory safety.
+
+## Motivation
+
+Rust is uniquely challenging for AI agents due to its strict compile-time safety guarantees. This environment provides a 10-task progression that measures an agent's ability to:
+
+1. Fix borrow checker violations
+2. Correctly annotate lifetimes
+3. Resolve concurrency deadlocks
+4. Write unsafe FFI code correctly
+5. Identify and prevent memory leaks
+6. Optimize data pipelines for performance
+
+---
+
+## Action Space
+
+**Type**: `RustCoderAction`
+
+The agent submits a single string containing the complete, fixed Rust source code.
+
+| Field | Type   | Description                              |
+|-------|--------|------------------------------------------|
+| `code` | string | Full Rust source code to compile and test |
+
+## Observation Space
+
+**Type**: `RustCoderObservation`
+
+The environment returns detailed feedback after each submission:
+
+| Field                  | Type        | Description                                         |
+|------------------------|-------------|-----------------------------------------------------|
+| `problem_description`  | string      | Task requirements and context                       |
+| `starter_code`         | string      | The intentionally broken code to fix                |
+| `compilation_success`  | bool        | Whether `rustc` compiled the submitted code         |
+| `compilation_output`   | string      | Raw compiler errors and warnings                    |
+| `test_results`         | list[dict]  | Per-test pass/fail results with error details       |
+| `reward_breakdown`     | dict        | Weighted score breakdown across 5 dimensions        |
+
+---
+
+## Reward Function
+
+Total reward is a weighted sum of 5 dimensions, each normalized to [0, 1]:
+
+| Dimension       | Weight | Metric                                            |
+|-----------------|--------|---------------------------------------------------|
+| Compilation     | 40%    | Binary success/failure of `rustc`                 |
+| Correctness     | 20%    | Fraction of test assertions that pass             |
+| Coverage        | 20%    | Fraction of tests that successfully ran           |
+| Elegance        | 10%    | Code quality heuristics (avoids `.unwrap()`, long lines, `unsafe`) |
+| Efficiency      | 10%    | Execution time vs. per-problem baseline           |
+
+Reward provides partial signal at every step — compilation alone earns 0.40, passing all tests earns up to 1.0.
+
+---
+
+## Tasks
+
+10 sequential problems with increasing difficulty:
+
+| ID | Title                              | Difficulty | Skill Evaluated               |
+|----|------------------------------------|------------|-------------------------------|
+| 1  | Broken CLI Argument Parser         | Easy       | Enums & pattern matching      |
+| 2  | Conflicting Borrows                | Easy→Med   | Borrow checker                |
+| 3  | Invalid Lifetime Annotations       | Medium     | Lifetime annotations          |
+| 4  | Business Logic Errors              | Medium     | Math & correctness            |
+| 5  | Linked List Management             | Medium     | Ownership & data structures   |
+| 6  | Multi-threaded Deadlocks           | Hard       | Mutex & concurrency           |
+| 7  | Async Borrowing Conflicts          | Hard       | Async/await lifetimes         |
+| 8  | Unsafe FFI Integration             | Hard       | `unsafe` & C interop          |
+| 9  | Inefficient Data Pipeline          | Hard       | Performance optimization      |
+| 10 | Memory Leak Prevention             | Hard+      | Weak pointers & ownership     |
+
+---
+
+## Environment Variables / Secrets
+
+The environment reads the following variables. Set them as **HF Space secrets** (Settings → Variables and Secrets) when deploying to Hugging Face, or in a local `.env` file for development.
+
+| Variable       | Required | Default                              | Description                          |
+|----------------|----------|--------------------------------------|--------------------------------------|
+| `HF_TOKEN`     | Yes      | —                                    | Hugging Face API token for LLM calls |
+| `API_BASE_URL` | No       | `https://router.huggingface.co/v1`   | Inference endpoint                   |
+| `MODEL_NAME`   | No       | `Qwen/Qwen2.5-72B-Instruct`          | Model to use for evaluation          |
+
+> **Note**: The `.env` file is excluded from Docker images by `.dockerignore`. On HF Spaces, secrets are injected as OS environment variables by the platform — `load_dotenv()` silently does nothing if no file is present, and `os.getenv()` reads from the platform-injected vars. This is the correct behavior.
+
+---
+
+## Setup & Usage
+
+### Local Development
+
+```bash
+# 1. Clone and enter the repo
+git clone https://github.com/your-username/rust_coder
+cd rust_coder
+
+# 2. Create .env with your credentials
+cat > .env << EOF
+HF_TOKEN=hf_your_token_here
+API_BASE_URL=https://router.huggingface.co/v1
+MODEL_NAME=Qwen/Qwen2.5-72B-Instruct
+EOF
+
+# 3. Build the Docker image (uses root Dockerfile)
+docker build -t rust_coder:latest .
+
+# 4. Run the environment server
+docker run -d -p 8000:8000 --env-file .env --name rust_env rust_coder:latest
+
+# 5. Verify it's healthy
+curl http://localhost:8000/health
+# → {"status": "healthy"}
+
+# 6. Run the inference benchmark
+python inference.py
+```
+
+### Docker Commands Reference
+
+```bash
+# Build
+docker build -t rust_coder:latest .
+
+# Run with .env file
+docker run -d -p 8000:8000 --env-file .env --name rust_env rust_coder:latest
+
+# View logs
+docker logs rust_env
+
+# Stop
+docker stop rust_env
+```
+
+### Environment API
+
+```bash
+# Reset (returns first problem)
+curl -X POST http://localhost:8000/reset
+
+# Step (submit Rust code)
+curl -X POST http://localhost:8000/step \
+  -H "Content-Type: application/json" \
+  -d '{"action": {"code": "fn main() { println!(\"hello\"); }"}}'
+
+# Health check
+curl http://localhost:8000/health
+```
+
+### HF Spaces Deployment
+
+```bash
+# Install HF CLI
+pip install huggingface_hub
+
+# Login
+huggingface-cli login
+
+# Push to Space
+openenv push --repo-id your-username/rust-coder
+```
+
+Then go to your Space settings and add secrets:
+- `HF_TOKEN` → your Hugging Face API token
+- `MODEL_NAME` → e.g. `Qwen/Qwen2.5-72B-Instruct`
+
+---
+
+## Baseline Scores
+
+Baseline using **Qwen/Qwen2.5-72B-Instruct** via Hugging Face router:
+
+| Metric         | Score |
+|----------------|-------|
+| Average reward | 0.59  |
+| Compilation %  | ~85%  |
+| Correctness %  | ~45%  |
+
+---
+
+## Project Structure
+
+```
+rust_coder/
+├── Dockerfile                     # Root Dockerfile (used by validator + HF Spaces)
+├── server/Dockerfile              # Identical copy (used for -f flag builds)
+├── openenv.yaml                   # OpenEnv spec metadata
+├── pyproject.toml                 # Python package config
+├── uv.lock                        # Locked dependencies
+├── problems.json                  # 10 coding problems dataset
+├── models.py                      # Pydantic action/observation types
+├── client.py                      # WebSocket client for RustCoderEnv
+├── inference.py                   # Baseline inference script (entry point)
+├── __init__.py                    # Package exports
+└── server/
+    ├── app.py                     # FastAPI + Gradio server
+    └── rust_coder_environment.py  # Core environment logic
+```

__init__.py

@@ -0,0 +1,16 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+"""Rust Coder Environment."""
+
+from .client import RustCoderEnv
+from .models import RustCoderAction, RustCoderObservation
+
+__all__ = [
+    "RustCoderAction",
+    "RustCoderObservation",
+    "RustCoderEnv",
+]

client.py

@@ -0,0 +1,67 @@
+"""Rust Coder Environment Client."""
+
+from typing import Dict
+
+from openenv.core import EnvClient
+from openenv.core.client_types import StepResult
+from openenv.core.env_server.types import State
+
+from models import RustCoderAction, RustCoderObservation
+
+
+class RustCoderEnv(
+    EnvClient[RustCoderAction, RustCoderObservation, State]
+):
+    """
+    Client for the Rust Coder Environment.
+
+    Maintains a persistent WebSocket connection to the environment server.
+
+    Example:
+        >>> with RustCoderEnv(base_url="http://localhost:8000") as client:
+        ...     result = client.reset()
+        ...     print(result.observation.problem_description)
+        ...     result = client.step(RustCoderAction(code="fn main() {}"))
+        ...     print(result.reward)
+
+    Example with Docker:
+        >>> client = RustCoderEnv.from_docker_image("rust_coder-env:latest")
+        >>> try:
+        ...     result = client.reset()
+        ...     result = client.step(RustCoderAction(code="fn main() {}"))
+        ... finally:
+        ...     client.close()
+    """
+
+    def _step_payload(self, action: RustCoderAction) -> Dict:
+        """Convert RustCoderAction to JSON payload for step message."""
+        return {
+            "code": action.code,
+        }
+
+    def _parse_result(self, payload: Dict) -> StepResult[RustCoderObservation]:
+        """Parse server response into StepResult[RustCoderObservation]."""
+        obs_data = payload.get("observation", {})
+        observation = RustCoderObservation(
+            problem_description=obs_data.get("problem_description", ""),
+            starter_code=obs_data.get("starter_code", ""),
+            compilation_success=obs_data.get("compilation_success", False),
+            compilation_output=obs_data.get("compilation_output", ""),
+            test_results=obs_data.get("test_results", []),
+            reward_breakdown=obs_data.get("reward_breakdown", {}),
+            done=payload.get("done", False),
+            reward=payload.get("reward", 0.0),
+        )
+
+        return StepResult(
+            observation=observation,
+            reward=payload.get("reward", 0.0),
+            done=payload.get("done", False),
+        )
+
+    def _parse_state(self, payload: Dict) -> State:
+        """Parse server response into State object."""
+        return State(
+            episode_id=payload.get("episode_id"),
+            step_count=payload.get("step_count", 0),
+        )

inference.py

@@ -0,0 +1,128 @@
+import os
+import re
+import json
+import asyncio
+from typing import List, Optional
+from openai import OpenAI
+from dotenv import load_dotenv
+
+load_dotenv()
+
+# --- Competition Configuration ---
+API_BASE_URL = os.getenv("API_BASE_URL") or "https://router.huggingface.co/v1"
+MODEL_NAME = os.getenv("MODEL_NAME") or "Qwen/Qwen2.5-72B-Instruct"
+HF_TOKEN = os.getenv("HF_TOKEN") or os.getenv("API_KEY")
+ENV_URL = os.getenv("ENV_URL") or "http://localhost:8000"
+
+# Episode constants: 10 problems, each worth max reward 1.0
+MAX_STEPS = 10
+MAX_TOTAL_REWARD = 10.0
+SUCCESS_SCORE_THRESHOLD = 0.5
+
+# Import client (ensure rust_coder is in PYTHONPATH)
+from client import RustCoderEnv
+from models import RustCoderAction
+
+# --- Strict Logging Helpers ---
+def log_start(task: str, env: str, model: str):
+    print(f'[START] task="{task}" env="{env}" model="{model}"', flush=True)
+
+def log_step(step: int, action: str, reward: float, done: bool, error: Optional[str] = None):
+    escaped_action = action.replace('\n', '\\n')[:100] + "..."
+    log_line = f'[STEP] step={step} action="{escaped_action}" reward={reward:.4f} done={str(done).lower()}'
+    if error:
+        log_line += f' error="{error}"'
+    print(log_line, flush=True)
+
+def log_end(success: bool, steps: int, score: float, rewards: List[float]):
+    print(f'[END] success={str(success).lower()} steps={steps} score={score:.4f} rewards={json.dumps(rewards)}', flush=True)
+
+# --- LLM Solution Logic ---
+async def get_model_code(prompt: str, client: OpenAI) -> str:
+    """Call the LLM to get a Rust solution."""
+    try:
+        completion = client.chat.completions.create(
+            model=MODEL_NAME,
+            messages=[
+                {"role": "system", "content": "You are a senior Rust systems engineer. Return ONLY the complete, fixed Rust code. No explanation."},
+                {"role": "user", "content": prompt},
+            ],
+            temperature=0.1,
+        )
+        text = (completion.choices[0].message.content or "").strip()
+
+        # Extract code from markdown
+        if "```rust" in text:
+            text = text.split("```rust")[1].split("```")[0]
+        elif "```" in text:
+            text = text.split("```")[1].split("```")[0]
+        return text.strip()
+    except Exception as e:
+        print(f"[DEBUG] LLM Request failed: {e}", flush=True)
+        return f"// Error: {e}"
+
+# --- Main Evaluation Loop ---
+async def main():
+    if not HF_TOKEN:
+        print("Error: HF_TOKEN/API_KEY not found in environment.")
+        return
+
+    client = OpenAI(base_url=API_BASE_URL, api_key=HF_TOKEN)
+    env = RustCoderEnv(base_url=ENV_URL)
+
+    log_start(task="rust_coder", env="RustCoder-v1", model=MODEL_NAME)
+
+    rewards: List[float] = []
+    steps_taken = 0
+    score = 0.0
+    success = False
+
+    try:
+        # Start the single episode (10 problems)
+        result = await env.reset()
+        obs = result.observation
+
+        for step in range(1, MAX_STEPS + 1):
+            if result.done:
+                break
+
+            steps_taken = step
+
+            # Format prompt including starter code if available
+            prompt = obs.problem_description
+            if obs.starter_code:
+                prompt += f"\n\nStarter Code:\n```rust\n{obs.starter_code}\n```"
+
+            # 1. Ask model for solution to current task
+            code_solution = await get_model_code(prompt, client)
+
+            # 2. Environment step
+            result = await env.step(RustCoderAction(code=code_solution))
+            obs = result.observation
+            reward = result.reward or 0.0
+            done = result.done
+
+            rewards.append(reward)
+            log_step(step=step, action=code_solution, reward=reward, done=done)
+
+            if done:
+                break
+
+        # Normalize score to [0, 1] matching sample format
+        score = sum(rewards) / MAX_TOTAL_REWARD if MAX_TOTAL_REWARD > 0 else 0.0
+        score = min(max(score, 0.0), 1.0)
+        success = score >= SUCCESS_SCORE_THRESHOLD
+
+    except Exception as e:
+        print(f"[DEBUG] Runtime error: {e}", flush=True)
+        log_step(step=steps_taken + 1, action="error", reward=0.0, done=True, error=str(e))
+
+    finally:
+        try:
+            await env.close()
+        except Exception as e:
+            print(f"[DEBUG] env.close() error: {e}", flush=True)
+        log_end(success=success, steps=steps_taken, score=score, rewards=rewards)
+
+if __name__ == "__main__":
+    asyncio.run(main())

models.py

@@ -0,0 +1,31 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+"""
+Data models for the Rust Coder Environment.
+
+The rust_coder environment is a simple test environment that echoes back messages.
+"""
+
+from openenv.core.env_server.types import Action, Observation
+from pydantic import Field
+
+
+class RustCoderAction(Action):
+    """Action for the Rust Coder environment - contains the Rust code to evaluate."""
+
+    code: str = Field(..., description="Rust source code to compile and run")
+
+
+class RustCoderObservation(Observation):
+    """Observation space for the Rust Coder environment."""
+
+    problem_description: str = Field(default="", description="The text description of the current coding task, including requirements.")
+    starter_code: str = Field(default="", description="The specific Rust code snippet that needs fixing for this task.")
+    compilation_success: bool = Field(default=False, description="Binary flag indicating if the last submission compiled.")
+    compilation_output: str = Field(default="", description="Raw stdout/stderr from the rustc compiler.")
+    test_results: list[dict] = Field(default_factory=list, description="A list of results from automated test assertions.")
+    reward_breakdown: dict = Field(default_factory=dict, description="Detailed components of the 0.0-1.0 reward.")

openenv.yaml

@@ -0,0 +1,56 @@
+spec_version: 1
+name: rust_coder
+description: "High-fidelity RL environment for evaluating LLM agents on Rust systems programming, including borrow checking, safe concurrency, and memory management."
+type: space
+runtime: fastapi
+app: server.app:app
+port: 8000
+dockerfile: Dockerfile
+tags:
+  - openenv
+  - software-engineering
+  - rust
+  - coding-benchmark
+
+# Task Definition (Easy -> Medium -> Hard)
+tasks:
+  - id: 1
+    title: "Broken CLI Argument Parser"
+    difficulty: "Easy"
+  - id: 2
+    title: "Conflicting Borrows"
+    difficulty: "Easy"
+  - id: 3
+    title: "Lifetime Annotations"
+    difficulty: "Medium"
+  - id: 4
+    title: "Business Logic"
+    difficulty: "Medium"
+  - id: 5
+    title: "Linked List Management"
+    difficulty: "Medium"
+  - id: 6
+    title: "Multi-threaded Deadlocks"
+    difficulty: "Hard"
+  - id: 7
+    title: "Async Borrowing"
+    difficulty: "Hard"
+  - id: 8
+    title: "Unsafe FFI Integration"
+    difficulty: "Hard"
+  - id: 9
+    title: "Inefficient Data Pipelines"
+    difficulty: "Hard"
+  - id: 10
+    title: "Memory Leak Prevention"
+    difficulty: "Hard+"
+
+# Definitions for Documentation and Graders
+action_space:
+  type: "RustCoderAction"
+  description: "A single string containing the fixed Rust code."
+
+observation_space:
+  type: "RustCoderObservation"
+  description: "Observation containing problem description, compilation logs, test results, and reward breakdown."
+

openenv_rust_coder.egg-info/PKG-INFO

@@ -0,0 +1,11 @@
+Metadata-Version: 2.4
+Name: openenv-rust_coder
+Version: 0.1.0
+Summary: Rust Coder environment for OpenEnv
+Requires-Python: >=3.10
+Requires-Dist: openenv-core[core]>=0.2.2
+Requires-Dist: openai>=1.0.0
+Requires-Dist: pydantic>=2.0.0
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.0.0; extra == "dev"

openenv_rust_coder.egg-info/SOURCES.txt

@@ -0,0 +1,15 @@
+README.md
+pyproject.toml
+./__init__.py
+./client.py
+./inference.py
+./models.py
+openenv_rust_coder.egg-info/PKG-INFO
+openenv_rust_coder.egg-info/SOURCES.txt
+openenv_rust_coder.egg-info/dependency_links.txt
+openenv_rust_coder.egg-info/entry_points.txt
+openenv_rust_coder.egg-info/requires.txt
+openenv_rust_coder.egg-info/top_level.txt
+server/__init__.py
+server/app.py
+server/rust_coder_environment.py

openenv_rust_coder.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

openenv_rust_coder.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+server = rust_coder.server.app:main

openenv_rust_coder.egg-info/requires.txt

@@ -0,0 +1,7 @@
+openenv-core[core]>=0.2.2
+openai>=1.0.0
+pydantic>=2.0.0
+
+[dev]
+pytest>=8.0.0
+pytest-cov>=4.0.0

openenv_rust_coder.egg-info/top_level.txt

@@ -0,0 +1 @@
+rust_coder

problems.json

@@ -0,0 +1,254 @@
+[
+    {
+        "id": 1,
+        "title": "Broken CLI Argument Parser",
+        "difficulty": "Easy",
+        "description": "Fix a command-line tool that parses user input to determine file operations (read, write, append). The implementation uses enums and pattern matching but contains: Mismatched types in enum variants, Incomplete match arms, Incorrect handling of optional arguments. The parser must compile and correctly interpret valid command-line inputs like: 'read file.txt' -> FileOp::Read('file.txt'), 'write file.txt content' -> FileOp::Write('file.txt', Some('content')), 'append file.txt' -> FileOp::Append('file.txt')",
+        "starter_code": "#[derive(Debug, PartialEq)]\nenum FileOp {\n    Read(String),\n    Write(String, Option<String>),\n    Append(String),\n}\n\nfn parse_command(input: &str) -> Option<FileOp> {\n    let parts: Vec<&str> = input.split_whitespace().collect();\n    \n    match parts.get(0) {\n        Some(&\"read\") => {\n            let filename = parts.get(1)?;\n            FileOp::Read(filename.to_string())  // BUG: Missing Some()\n        }\n        Some(&\"write\") => {\n            let filename = parts.get(1)?;\n            let content = parts.get(2).map(|s| s.to_string());\n            Some(FileOp::Write(filename.to_string(), content))\n        }\n        Some(&\"append\") => {\n            let filename = parts.get(1)?;\n            // BUG: Missing return statement\n        }\n        _ => None,\n    }\n}\n\nfn main() {\n    println!(\"CLI Parser Test\");\n}",
+        "tests": [
+            {
+                "name": "parse_read_command",
+                "input_code": "parse_command(\"read file.txt\")",
+                "expected_output": "Some\\(FileOp::Read\\(\"file\\.txt\"\\)\\)",
+                "should_compile": false,
+                "test_assertion": "assert_eq!(parse_command(\"read file.txt\"), Some(FileOp::Read(\"file.txt\".to_string())))"
+            },
+            {
+                "name": "parse_write_command",
+                "input_code": "parse_command(\"write file.txt hello\")",
+                "expected_output": "Some\\(FileOp::Write\\(\"file\\.txt\", Some\\(\"hello\"\\)\\)\\)",
+                "should_compile": false,
+                "test_assertion": "assert_eq!(parse_command(\"write file.txt hello\"), Some(FileOp::Write(\"file.txt\".to_string(), Some(\"hello\".to_string()))))"
+            },
+            {
+                "name": "parse_append_command",
+                "input_code": "parse_command(\"append file.txt\")",
+                "expected_output": "Some\\(FileOp::Append\\(\"file\\.txt\"\\)\\)",
+                "should_compile": false,
+                "test_assertion": "assert_eq!(parse_command(\"append file.txt\"), Some(FileOp::Append(\"file.txt\".to_string())))"
+            }
+        ],
+        "performance_baseline_ms": 10.0
+    },
+    {
+        "id": 2,
+        "title": "Conflicting Borrows in Collection Processing",
+        "difficulty": "Easy\u2192Medium",
+        "description": "Fix a function that processes a vector of strings while conditionally modifying elements and storing references for later use. The implementation mixes mutable and immutable borrows within the same scope, causing borrow checker conflicts. Requirements: Iterate through vector of strings, Store uppercase versions in a results vector, Handle optional transformations without borrowing conflicts, Must compile and execute without panics",
+        "starter_code": "fn process_strings(strings: &mut Vec<String>) -> Vec<String> {\n    let mut results = Vec::new();\n    \n    for s in strings {\n        // BUG: Cannot borrow as mutable while immutable borrow is active\n        let upper = s.to_uppercase();\n        s.push_str(\"_processed\");  // Mutable borrow\n        results.push(upper);\n    }\n    \n    results\n}\n\nfn main() {\n    println!(\"String processing\");\n}",
+        "tests": [
+            {
+                "name": "process_single_string",
+                "input_code": "let mut v = vec![\"hello\".to_string()]; process_strings(&mut v);",
+                "should_compile": false,
+                "test_assertion": "assert_eq!(process_strings(&mut vec![\"hello\".to_string()]), vec![\"HELLO\".to_string()])"
+            },
+            {
+                "name": "process_multiple_strings",
+                "input_code": "let mut v = vec![\"a\".to_string(), \"b\".to_string()]; process_strings(&mut v);",
+                "should_compile": false,
+                "test_assertion": "assert_eq!(process_strings(&mut vec![\"a\".to_string(), \"b\".to_string()]), vec![\"A\".to_string(), \"B\".to_string()])"
+            }
+        ],
+        "performance_baseline_ms": 50.0
+    },
+    {
+        "id": 3,
+        "title": "Invalid Lifetime Annotations in Text API",
+        "difficulty": "Medium",
+        "description": "Fix a text-processing utility that accepts multiple string slices and returns a reference derived from them. The function either fails to compile or produces incorrect lifetime relationships, risking references that outlive their input data. Requirements: Function must accept multiple &str parameters, Return a &str derived from the inputs, Properly annotate lifetimes, Must be safe (no dangling references)",
+        "starter_code": "// BUG: Invalid lifetime annotations - which lifetime should the return type use?\nfn longest_text<'a>(s1: &'a str, s2: &'a str) -> &'a str {\n    if s1.len() > s2.len() {\n        s1\n    } else {\n        s2\n    }\n}\n\n// BUG: This function has a lifetime issue\nfn find_first_word(s: &str) -> &str {\n    let bytes = s.as_bytes();\n    for (i, &byte) in bytes.iter().enumerate() {\n        if byte == b' ' {\n            return &s[0..i];\n        }\n    }\n    &s[..]\n}\n\nfn main() {\n    println!(\"Lifetime test\");\n}",
+        "tests": [
+            {
+                "name": "longest_text_basic",
+                "input_code": "longest_text(\"abc\", \"de\")",
+                "expected_output": "\"abc\"",
+                "should_compile": true,
+                "test_assertion": "assert_eq!(longest_text(\"abc\", \"de\"), \"abc\")"
+            },
+            {
+                "name": "find_first_word_with_space",
+                "input_code": "find_first_word(\"hello world\")",
+                "expected_output": "\"hello\"",
+                "should_compile": true,
+                "test_assertion": "assert_eq!(find_first_word(\"hello world\"), \"hello\")"
+            },
+            {
+                "name": "find_first_word_no_space",
+                "input_code": "find_first_word(\"hello\")",
+                "expected_output": "\"hello\"",
+                "should_compile": true,
+                "test_assertion": "assert_eq!(find_first_word(\"hello\"), \"hello\")"
+            }
+        ],
+        "performance_baseline_ms": 10.0
+    },
+    {
+        "id": 4,
+        "title": "Business Logic Producing Incorrect Results",
+        "difficulty": "Medium",
+        "description": "Fix a module implementing order validation logic including pricing, discounts, and boundary conditions. The code compiles but produces incorrect outputs for edge cases such as: Zero values, Overlapping discounts, Large numeric inputs, Negative prices. Requirements: Calculate order total correctly, Apply discounts properly (no double-counting), Handle edge cases (zero items, negative values), Be mathematically sound",
+        "starter_code": "#[derive(Debug, Clone)]\nstruct Order {\n    quantity: i32,\n    unit_price: f64,\n    discount_percent: f64,\n}\n\nimpl Order {\n    fn new(quantity: i32, unit_price: f64) -> Self {\n        Order {\n            quantity,\n            unit_price,\n            discount_percent: 0.0,\n        }\n    }\n\n    fn with_discount(mut self, discount: f64) -> Self {\n        self.discount_percent = discount;\n        self\n    }\n\n    fn calculate_total(&self) -> f64 {\n        let subtotal = self.quantity as f64 * self.unit_price;\n        // BUG: Incorrect discount calculation\n        let discount = subtotal * (self.discount_percent / 100.0);\n        subtotal - discount  // Missing rounding/validation\n    }\n}\n\nfn main() {\n    println!(\"Order test\");\n}",
+        "tests": [
+            {
+                "name": "simple_order",
+                "input_code": "Order::new(10, 5.0).calculate_total()",
+                "expected_output": "50\\.0",
+                "should_compile": true,
+                "test_assertion": "assert_eq!(Order::new(10, 5.0).calculate_total(), 50.0)"
+            },
+            {
+                "name": "order_with_discount",
+                "input_code": "Order::new(10, 5.0).with_discount(10.0).calculate_total()",
+                "expected_output": "45\\.0",
+                "should_compile": true,
+                "test_assertion": "assert_eq!(Order::new(10, 5.0).with_discount(10.0).calculate_total(), 45.0)"
+            },
+            {
+                "name": "zero_quantity",
+                "input_code": "Order::new(0, 5.0).calculate_total()",
+                "expected_output": "0\\.0",
+                "should_compile": true,
+                "test_assertion": "assert_eq!(Order::new(0, 5.0).calculate_total(), 0.0)"
+            }
+        ],
+        "performance_baseline_ms": 10.0
+    },
+    {
+        "id": 5,
+        "title": "Corrupted Singly Linked List",
+        "difficulty": "Medium\u2192Hard",
+        "description": "Fix a custom singly linked list that supports insertion, deletion, and traversal. The implementation incorrectly manages node ownership and pointer transitions, resulting in: Lost nodes, Inconsistent traversal output, Occasional runtime panics. Requirements: Insert elements at head, Delete elements correctly, Traverse without panics, No memory leaks or lost data",
+        "starter_code": "use std::ptr;\n\n#[derive(Debug)]\nstruct Node<T> {\n    value: T,\n    next: Option<Box<Node<T>>>,\n}\n\n#[derive(Debug)]\nstruct LinkedList<T> {\n    head: Option<Box<Node<T>>>,\n}\n\nimpl<T> LinkedList<T> {\n    fn new() -> Self {\n        LinkedList { head: None }\n    }\n\n    fn insert(&mut self, value: T) {\n        let new_node = Box::new(Node {\n            value,\n            next: None,  // BUG: Should move self.head into next\n        });\n        self.head = Some(new_node);\n    }\n\n    fn len(&self) -> usize {\n        let mut count = 0;\n        let mut current = &self.head;\n        while let Some(node) = current {\n            count += 1;\n            current = &node.next;  // Correct, but insert is broken\n        }\n        count\n    }\n}\n\nfn main() {\n    println!(\"LinkedList test\");\n}",
+        "tests": [
+            {
+                "name": "insert_single_element",
+                "input_code": "let mut ll = LinkedList::new(); ll.insert(5); ll.len()",
+                "expected_output": "1",
+                "should_compile": true,
+                "test_assertion": "let mut ll = LinkedList::new(); ll.insert(5); assert_eq!(ll.len(), 1)"
+            },
+            {
+                "name": "insert_multiple_elements",
+                "input_code": "let mut ll = LinkedList::new(); ll.insert(1); ll.insert(2); ll.insert(3); ll.len()",
+                "expected_output": "3",
+                "should_compile": true,
+                "test_assertion": "let mut ll = LinkedList::new(); ll.insert(1); ll.insert(2); ll.insert(3); assert_eq!(ll.len(), 3)"
+            }
+        ],
+        "performance_baseline_ms": 20.0
+    },
+    {
+        "id": 6,
+        "title": "Deadlock in Multi-threaded Worker System",
+        "difficulty": "Hard",
+        "description": "Fix a worker system using multiple threads to process jobs from a shared queue protected by synchronization primitives. Under certain workloads, threads block indefinitely due to: Improper lock acquisition order, Shared state handling issues, Missing signal/wake mechanisms. Requirements: Spawn N worker threads, Process jobs from shared queue without deadlock, Handle shutdown gracefully, No panics under load",
+        "starter_code": "use std::sync::{Arc, Mutex, mpsc};\nuse std::thread;\n\nfn worker_system(num_workers: usize, jobs: Vec<i32>) -> Vec<i32> {\n    let (tx, rx) = mpsc::channel();\n    let rx = Arc::new(Mutex::new(rx));\n    let results = Arc::new(Mutex::new(Vec::new()));\n    \n    let mut handles = vec![];\n    \n    for _ in 0..num_workers {\n        let rx = Arc::clone(&rx);\n        let results = Arc::clone(&results);\n        \n        let handle = thread::spawn(move || {\n            loop {\n                // BUG: Lock acquired but never released before trying to acquire results lock\n                let receiver = rx.lock().unwrap();\n                match receiver.try_recv() {\n                    Ok(job) => {\n                        let result = job * 2;\n                        // BUG: Tries to lock results while still holding rx lock - DEADLOCK\n                        results.lock().unwrap().push(result);\n                    }\n                    Err(_) => break,\n                }\n            }\n        });\n        handles.push(handle);\n    }\n    \n    for job in jobs {\n        let _ = tx.send(job);  // Ignore send errors\n    }\n    drop(tx);\n    \n    for handle in handles {\n        let _ = handle.join();\n    }\n    \n    Arc::try_unwrap(results)\n        .unwrap()\n        .into_inner()\n        .unwrap()\n}\n\nfn main() {\n    println!(\"Worker system test\");\n}",
+        "tests": [
+            {
+                "name": "single_worker_single_job",
+                "input_code": "worker_system(1, vec![5])",
+                "expected_output": "vec!\\[10\\]",
+                "should_compile": true,
+                "test_assertion": "assert_eq!(worker_system(1, vec![5]), vec![10])"
+            },
+            {
+                "name": "multiple_workers",
+                "input_code": "worker_system(2, vec![1, 2, 3])",
+                "expected_output": "vec!\\[(2|4|6)\\].*vec!\\[(2|4|6)\\].*vec!\\[(2|4|6)\\]",
+                "should_compile": true,
+                "test_assertion": "let mut result = worker_system(2, vec![1, 2, 3]); result.sort(); assert_eq!(result, vec![2, 4, 6])"
+            }
+        ],
+        "performance_baseline_ms": 500.0
+    },
+    {
+        "id": 7,
+        "title": "Async Function with Borrowing Conflicts",
+        "difficulty": "Hard",
+        "description": "Fix an asynchronous function that processes input data and performs non-blocking operations while returning references tied to the input. The implementation violates borrowing constraints in an async context, leading to: Compilation errors when using references across await points, Invalid reference usage. Requirements: Accept &str input, Perform async operation, Return derived reference, Must be sound and compile",
+        "starter_code": "use std::pin::Pin;\nuse std::future::Future;\n\n// BUG: Cannot return reference that outlives await point\nasync fn process_async(input: &str) -> &str {\n    // Simulating async work\n    // tokio::time::sleep(tokio::time::Duration::from_millis(10)).await;\n    \n    // BUG: input reference cannot be returned from async context like this\n    input\n}\n\n// Better approach: return owned data or 'static reference\nfn process_sync(input: &str) -> String {\n    input.to_uppercase()\n}\n\nfn main() {\n    println!(\"Async test\");\n}",
+        "tests": [
+            {
+                "name": "process_sync_basic",
+                "input_code": "process_sync(\"hello\")",
+                "expected_output": "\"HELLO\"",
+                "should_compile": true,
+                "test_assertion": "assert_eq!(process_sync(\"hello\"), \"HELLO\")"
+            },
+            {
+                "name": "process_sync_uppercase",
+                "input_code": "process_sync(\"Hello World\")",
+                "expected_output": "\"HELLO WORLD\"",
+                "should_compile": true,
+                "test_assertion": "assert_eq!(process_sync(\"Hello World\"), \"HELLO WORLD\")"
+            }
+        ],
+        "performance_baseline_ms": 50.0
+    },
+    {
+        "id": 8,
+        "title": "Unsafe FFI Integration Causing Crashes",
+        "difficulty": "Hard",
+        "description": "Fix Rust code that interfaces with an external C library using raw pointers. The implementation incorrectly handles: Pointer ownership, Memory allocation and deallocation, Undefined behavior risks. Requirements: Safely wrap C library calls, Properly manage memory (allocate/deallocate), No undefined behavior, Handle errors gracefully",
+        "starter_code": "extern \"C\" {\n    fn malloc(size: usize) -> *mut u8;\n    fn free(ptr: *mut u8);\n}\n\nfn allocate_and_init(size: usize) -> Vec<u8> {\n    unsafe {\n        let ptr = malloc(size);\n        // BUG: No null check - ptr could be null\n        // BUG: Memory not initialized before use\n        let slice = std::slice::from_raw_parts_mut(ptr, size);\n        \n        // Copy to vec and free\n        let vec = slice.to_vec();\n        free(ptr);  // BUG: Freeing memory still referenced in vec\n        vec\n    }\n}\n\nfn main() {\n    println!(\"FFI test\");\n}",
+        "tests": [
+            {
+                "name": "allocate_small_buffer",
+                "input_code": "allocate_and_init(10).len()",
+                "expected_output": "10",
+                "should_compile": false,
+                "test_assertion": "assert_eq!(allocate_and_init(10).len(), 10)"
+            }
+        ],
+        "performance_baseline_ms": 100.0
+    },
+    {
+        "id": 9,
+        "title": "Inefficient Data Processing Pipeline",
+        "difficulty": "Hard",
+        "description": "Fix a data pipeline that reads large datasets, applies transformations, and aggregates results. While functionally correct, the implementation has: Excessive memory allocations, Redundant iterations, Inefficient data copying. Requirements: Process data efficiently, Minimize allocations and copies, Use iterators when possible, Produce correct results with better performance",
+        "starter_code": "fn process_data(numbers: Vec<i32>) -> i32 {\n    // BUG: Multiple unnecessary allocations and iterations\n    \n    // First pass: filter evens (allocates new vector)\n    let evens: Vec<i32> = numbers.iter()\n        .filter(|n| n % 2 == 0)\n        .copied()\n        .collect();\n    \n    // Second pass: double values (allocates another vector)\n    let doubled: Vec<i32> = evens.iter()\n        .map(|n| n * 2)\n        .collect();\n    \n    // Third pass: sum (unnecessary iteration)\n    let sum: i32 = doubled.iter().sum();\n    \n    // Fourth pass: filter again (redundant)\n    let final_sum: i32 = doubled.iter()\n        .filter(|n| n % 4 == 0)\n        .sum();\n    \n    final_sum\n}\n\nfn main() {\n    println!(\"Efficiency test\");\n}",
+        "tests": [
+            {
+                "name": "simple_pipeline",
+                "input_code": "process_data(vec![1, 2, 3, 4, 5, 6])",
+                "expected_output": "16",
+                "should_compile": true,
+                "test_assertion": "assert_eq!(process_data(vec![1, 2, 3, 4, 5, 6]), 16)"
+            },
+            {
+                "name": "all_odd_numbers",
+                "input_code": "process_data(vec![1, 3, 5, 7])",
+                "expected_output": "0",
+                "should_compile": true,
+                "test_assertion": "assert_eq!(process_data(vec![1, 3, 5, 7]), 0)"
+            }
+        ],
+        "performance_baseline_ms": 50.0
+    },
+    {
+        "id": 10,
+        "title": "Reference-counted Cache with Memory Leak",
+        "difficulty": "Hard+",
+        "description": "Fix a caching system using reference-counted pointers to share data across components. The design creates cyclic references between cached objects, preventing memory from being released and causing memory usage to grow over time. Requirements: Implement caching without memory leaks, Break circular reference patterns, Use Rc/Arc correctly with Weak pointers when needed, Memory should be released when cache is cleared",
+        "starter_code": "use std::rc::Rc;\nuse std::cell::RefCell;\n\n#[derive(Debug)]\nstruct CacheNode<T> {\n    key: String,\n    value: T,\n    // BUG: This creates a cycle that prevents garbage collection\n    related: RefCell<Option<Rc<CacheNode<T>>>>,\n}\n\n#[derive(Debug)]\nstruct Cache<T> {\n    items: RefCell<Vec<Rc<CacheNode<T>>>>,\n}\n\nimpl<T: Clone> Cache<T> {\n    fn new() -> Self {\n        Cache {\n            items: RefCell::new(Vec::new()),\n        }\n    }\n\n    fn insert(&self, key: String, value: T) {\n        let node = Rc::new(CacheNode {\n            key,\n            value,\n            related: RefCell::new(None),\n        });\n        \n        // BUG: Creating cyclic references\n        if let Some(last) = self.items.borrow().last() {\n            // Rc to Rc creates a cycle\n            if let Ok(mut r) = last.related.try_borrow_mut() {\n                *r = Some(Rc::clone(&node));  // Cycle here!\n            }\n        }\n        \n        self.items.borrow_mut().push(node);\n    }\n}\n\nfn main() {\n    println!(\"Cache test\");\n}",
+        "tests": [
+            {
+                "name": "cache_insert_single",
+                "input_code": "let c = Cache::new(); c.insert(\"key\".to_string(), \"value\".to_string()); c.items.borrow().len()",
+                "expected_output": "1",
+                "should_compile": true,
+                "test_assertion": "let c = Cache::new(); c.insert(\"key\".to_string(), \"value\".to_string()); assert_eq!(c.items.borrow().len(), 1)"
+            },
+            {
+                "name": "cache_insert_multiple",
+                "input_code": "let c = Cache::new(); c.insert(\"k1\".to_string(), \"v1\".to_string()); c.insert(\"k2\".to_string(), \"v2\".to_string()); c.items.borrow().len()",
+                "expected_output": "2",
+                "should_compile": true,
+                "test_assertion": "let c = Cache::new(); c.insert(\"k1\".to_string(), \"v1\".to_string()); c.insert(\"k2\".to_string(), \"v2\".to_string()); assert_eq!(c.items.borrow().len(), 2)"
+            }
+        ],
+        "performance_baseline_ms": 100.0
+    }
+]

pyproject.toml

@@ -0,0 +1,48 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+[build-system]
+requires = ["setuptools>=45", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "openenv-rust_coder"
+version = "0.1.0"
+description = "Rust Coder environment for OpenEnv"
+requires-python = ">=3.10"
+dependencies = [
+    # Core OpenEnv runtime (provides FastAPI server + HTTP client types)
+    # install from github
+    # "openenv-core[core] @ git+https://github.com/meta-pytorch/OpenEnv.git",
+    "openenv-core[core]>=0.2.2",
+    "openai>=1.0.0",
+    "pydantic>=2.0.0",
+    "gradio>=4.0.0",
+    # Environment-specific dependencies
+    # Add all dependencies needed for your environment here
+    # Examples:
+    # "numpy>=1.19.0",
+    # "torch>=2.0.0",
+    # "gymnasium>=0.29.0",
+    # "openspiel>=1.0.0",
+    # "smolagents>=1.22.0,<2",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=8.0.0",
+    "pytest-cov>=4.0.0",
+]
+
+[project.scripts]
+# Server entry point - enables running via: uv run --project . server
+# or: python -m rust_coder.server.app
+server = "rust_coder.server.app:main"
+
+[tool.setuptools]
+include-package-data = true
+packages = ["rust_coder", "rust_coder.server"]
+package-dir = { "rust_coder" = ".", "rust_coder.server" = "server" }

scripts/validate-submission.sh

@@ -0,0 +1,73 @@
+#!/usr/bin/env bash
+#
+# validate-submission.sh — OpenEnv Submission Validator (Hardened)
+#
+# Checks that your HF Space is live, Docker image builds, and OpenEnv spec compliance.
+# Mandatory Log Format Check included.
+
+set -e
+
+PING_URL=$1
+REPO_DIR=${2:-"."}
+
+if [ -z "$PING_URL" ]; then
+    echo "Usage: $0 <ping_url> [repo_dir]"
+    echo "Example: bash scripts/validate-submission.sh https://huggingface.co/spaces/user/rust-coder"
+    exit 1
+fi
+
+echo "--- 🔍 1. Testing Connection to HF Space ---"
+# Check health or root
+RESPONSE=$(curl -s -o /dev/null -w "%{http_code}" "$PING_URL/health" || curl -s -o /dev/null -w "%{http_code}" "$PING_URL/")
+
+if [ "$RESPONSE" -ne 200 ]; then
+    echo "❌ FAILED: Space at $PING_URL returned $RESPONSE (expected 200)"
+    echo "   Ensure your Space is 'Running' and public."
+    exit 1
+fi
+echo "✅ PASSED: Connection OK"
+
+echo "--- 🔍 2. Validating OpenEnv Spec ---"
+cd "$REPO_DIR"
+if command -v openenv &>/dev/null; then
+    if ! openenv validate; then
+        echo "❌ FAILED: openenv validate failed. Check your openenv.yaml syntax."
+        exit 1
+    fi
+    echo "✅ PASSED: openenv.yaml is valid"
+else
+    echo "⚠️  WARNING: 'openenv' command not found. Skipping local spec validation."
+    echo "   (Ensure you've run 'pip install openenv-core' if you want this check)"
+fi
+
+echo "--- 🔍 3. Checking Mandatory Logging Format ---"
+# The judge requires [START], [STEP], and [END] in stdout
+if grep -q "\[START\]" "inference.py" && grep -q "\[STEP\]" "inference.py" && grep -q "\[END\]" "inference.py"; then
+    echo "✅ PASSED: inference.py contains mandatory [START/STEP/END] logs."
+else
+    echo "❌ FAILED: inference.py is missing mandatory structured logging."
+    echo "   See documentation for [START], [STEP], and [END] format."
+    exit 1
+fi
+
+echo "--- 🔍 4. Verifying File Structure ---"
+FILES=("inference.py" "problems.json" "server/Dockerfile" "openenv.yaml")
+for f in "${FILES[@]}"; do
+    if [ ! -f "$f" ]; then
+        echo "❌ FAILED: Missing required file: $f"
+        exit 1
+    fi
+done
+echo "✅ PASSED: All core files exist."
+
+echo "--- 🔍 5. Checking Task Count ---"
+TASK_COUNT=$(grep -c "id:" "openenv.yaml" || true)
+if [ "$TASK_COUNT" -lt 3 ]; then
+    echo "❌ FAILED: Found only $TASK_COUNT tasks in openenv.yaml (minimum 3 required)."
+    exit 1
+fi
+echo "✅ PASSED: Found $TASK_COUNT tasks."
+
+echo ""
+echo "🎉 SUCCESS: Your submission has passed all local checks!"
+echo "You are ready to submit your Space URL: $PING_URL"

server/Dockerfile

@@ -0,0 +1,72 @@
+# Multi-stage build for Rust Coder Environment
+ARG BASE_IMAGE=ghcr.io/meta-pytorch/openenv-base:latest
+FROM ${BASE_IMAGE} AS builder
+
+# 1. Environment Setup
+USER root
+WORKDIR /app
+
+# Install build essentials for Rust (linker, etc.)
+RUN apt-get update && \
+    apt-get install -y --no-install-recommends git curl build-essential ca-certificates && \
+    rm -rf /var/lib/apt/lists/*
+
+# 2. Create the non-root user (Hugging Face default)
+RUN useradd -m -u 1000 user
+USER user
+ENV HOME=/home/user \
+    PATH=/home/user/.cargo/bin:/home/user/.local/bin:$PATH
+
+# 3. Install Rust toolchain as 'user'
+RUN curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y --default-toolchain stable
+RUN rustup toolchain install stable
+
+# 4. Copy environment code and install Python dependencies
+WORKDIR $HOME/app/env
+COPY --chown=user . $HOME/app/env
+
+# Install uv (if not present) and then the virtual environment
+RUN if ! command -v uv >/dev/null 2>&1; then \
+        curl -LsSf https://astral.sh/uv/install.sh | sh; \
+    fi
+
+RUN --mount=type=cache,target=/home/user/.cache/uv,uid=1000,gid=1000 \
+    uv sync --no-editable
+
+# -------------------------------------------------------------
+# Final Runtime Stage
+# -------------------------------------------------------------
+FROM ${BASE_IMAGE}
+
+USER root
+RUN apt-get update && \
+    apt-get install -y --no-install-recommends curl build-essential ca-certificates && \
+    rm -rf /var/lib/apt/lists/*
+
+# Create the user again in the final stage
+RUN useradd -m -u 1000 user
+USER user
+ENV HOME=/home/user \
+    PATH="/home/user/app/env/.venv/bin:/home/user/.cargo/bin:$PATH" \
+    PYTHONPATH="/home/user/app/env:$PYTHONPATH"
+
+# 4. Copy Cargo/Rustup from builder and then the local code
+COPY --from=builder --chown=user /home/user/.cargo /home/user/.cargo
+COPY --from=builder --chown=user /home/user/.rustup /home/user/.rustup
+
+WORKDIR $HOME/app/env
+COPY --chown=user . $HOME/app/env
+
+# 5. Install uv and Python dependencies in the FINAL stage
+RUN curl -LsSf https://astral.sh/uv/install.sh | sh
+RUN uv sync --no-editable
+
+# -------------------------------------------------------------
+# Final Config
+# -------------------------------------------------------------
+EXPOSE 8000
+HEALTHCHECK --interval=30s --timeout=5s --start-period=10s --retries=3 \
+    CMD curl -f http://localhost:8000/health || exit 1
+
+# Start the server using 'uv run' to ensure .venv context is preserved
+CMD ["/home/user/app/env/.venv/bin/uvicorn", "server.app:app", "--host", "0.0.0.0", "--port", "8000", "--log-level", "debug"]

server/__init__.py

@@ -0,0 +1,11 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+"""Rust Coder environment server components."""
+
+from .rust_coder_environment import RustCoderEnvironment
+
+__all__ = ["RustCoderEnvironment"]

server/app.py

@@ -0,0 +1,176 @@
+"""
+FastAPI application for the Rust Coder Environment.
+
+Endpoints:
+    POST /reset  — Start new episode (loads next problem)
+    POST /step   — Submit Rust code for evaluation
+    GET  /state  — Get current episode state
+    GET  /schema — Action/observation JSON schemas
+    WS   /ws     — WebSocket for persistent sessions
+"""
+
+import os
+import gradio as gr
+from openai import OpenAI
+from dotenv import load_dotenv
+from openenv.core.env_server.http_server import create_app
+
+from models import RustCoderAction, RustCoderObservation
+from server.rust_coder_environment import RustCoderEnvironment
+
+load_dotenv()
+
+# --- Core OpenEnv Server Setup ---
+# Use a distinct name for the OpenEnv FastAPI instance
+openenv_app = create_app(
+    RustCoderEnvironment,
+    RustCoderAction,
+    RustCoderObservation,
+    env_name="rust_coder",
+    max_concurrent_envs=1,
+)
+
+# Add a health check endpoint for Docker directly to the base app
+@openenv_app.get("/health")
+async def health_check():
+    return {"status": "healthy"}
+
+# --- Shared Logic ---
+API_BASE_URL = os.getenv("API_BASE_URL") or "https://router.huggingface.co/v1"
+MODEL_NAME = os.getenv("MODEL_NAME") or "Qwen/Qwen2.5-72B-Instruct"
+HF_TOKEN = os.getenv("HF_TOKEN") or os.getenv("API_KEY")
+
+def get_llm_solution(problem_desc: str):
+    """Call LLM to get a Rust solution"""
+    try:
+        client_llm = OpenAI(base_url=API_BASE_URL, api_key=HF_TOKEN)
+        completion = client_llm.chat.completions.create(
+            model=MODEL_NAME,
+            messages=[
+                {"role": "system", "content": "You are an expert Rust developer. Respond ONLY with the code solution, no explanation."},
+                {"role": "user", "content": f"Fix the following Rust problem:\n{problem_desc}"},
+            ],
+            temperature=0.2,
+        )
+        text = (completion.choices[0].message.content or "").strip()
+        # Clean markdown code blocks
+        if "```rust" in text:
+            text = text.split("```rust")[1].split("```")[0]
+        elif "```" in text:
+            text = text.split("```")[1].split("```")[0]
+        return text.strip()
+    except Exception as e:
+        return f"// LLM Error: {e}"
+
+def evaluate_single(problem_id, code=None):
+    """Run evaluation for a specific problem. If code is None, it asks the LLM."""
+    try:
+        idx = int(problem_id.split(":")[0]) - 1
+        problem = RustCoderEnvironment().problems[idx]
+        
+        # 1. Get code from LLM if not provided
+        solution_code = code if code else get_llm_solution(problem["description"])
+        
+        # 2. Guard: If LLM failed, do not evaluate
+        if solution_code.startswith("// LLM Error"):
+            return solution_code, {"error": "LLM failed to generate a solution. Check your HF_TOKEN."}
+
+        # 3. Evaluate properly
+        env = RustCoderEnvironment()
+        # Reset to the specifically requested index
+        state = env.reset(start_index=idx)
+        state = env.step(RustCoderAction(code=solution_code))
+        
+        metrics = {
+            "Total Reward": f"{state.reward:.2f}",
+            "Compilation": "Success" if state.compilation_success else "Failed",
+            "Metrics": state.reward_breakdown
+        }
+        return solution_code, metrics
+    except Exception as e:
+        return f"// Error: {e}", {"error": f"Evaluation system error: {e}"}
+
+def run_benchmark(progress=gr.Progress()):
+    """Run all 10 problems through the LLM and show summary"""
+    try:
+        env = RustCoderEnvironment()
+        rows = []
+        total_score = 0.0
+        
+        # Check if token is actually present
+        test_token = os.getenv("HF_TOKEN") or os.getenv("API_KEY")
+        if not test_token:
+            return "## Error: HF_TOKEN is not set. Add it to your HF Space secrets or local .env file.", []
+
+        for i in range(len(env.problems)):
+            progress(i/len(env.problems), desc=f"Benchmarking Task {i+1}...")
+            problem = env.problems[i]
+            code = get_llm_solution(problem["description"])
+            
+            reward = 0.0
+            compiled = "Failed (LLM Error)"
+            
+            if not code.startswith("// LLM Error"):
+                env.reset(start_index=i)
+                state = env.step(RustCoderAction(code=code))
+                reward = state.reward
+                compiled = "Success" if state.compilation_success else "Failed"
+            
+            rows.append([problem["id"], problem["title"], problem.get("difficulty", "N/A"), f"{reward:.2f}", compiled])
+            total_score += reward
+
+        avg_score = total_score / len(env.problems)
+        summary_md = f"## Benchmark Summary\n**Final Environment Score: {avg_score:.2f} / 1.0**"
+        return summary_md, rows
+    except Exception as e:
+        return f"### Benchmark Error: {e}", []
+
+# --- Build the Gradio UI ---
+def create_dashboard():
+    with gr.Blocks(title="Rust Coder Evaluation Dashboard") as demo:
+        gr.Markdown("# 🦀 Rust Coder: LLM Evaluation Dashboard")
+        
+        with gr.Tab("Individual Task Evaluation"):
+            with gr.Row():
+                with gr.Column(scale=1):
+                    p_env = RustCoderEnvironment()
+                    p_list = [f"{p['id']}: {p['title']} ({p.get('difficulty', 'N/A')})" for p in p_env.problems]
+                    dropdown = gr.Dropdown(choices=p_list, label="Select Question", value=p_list[0])
+                    desc = gr.Markdown(value=f"### Question [{p_env.problems[0].get('difficulty', 'N/A')}]\n{p_env.problems[0]['description']}")
+                    
+                with gr.Column(scale=1):
+                    run_llm_btn = gr.Button("Generate Solution & Evaluate", variant="primary")
+                    code_display = gr.Code(label="AI Generated Solution", interactive=False)
+                    results_json = gr.JSON(label="Metric Breakdown")
+                
+            def update_desc(p_str):
+                idx = int(p_str.split(":")[0]) - 1
+                p = p_env.problems[idx]
+                return f"### Question [{p.get('difficulty', 'N/A')}]\n{p['description']}", "" # Clear solution on change
+            
+            dropdown.change(update_desc, inputs=[dropdown], outputs=[desc, code_display])
+            run_llm_btn.click(evaluate_single, inputs=[dropdown], outputs=[code_display, results_json])
+
+        with gr.Tab("Full Environment Benchmark"):
+            gr.Markdown("### Complete Environment Suite")
+            gr.Markdown("Runs the LLM against all 10 tasks sequentially to determine the global OpenEnv score.")
+            
+            b_summarize = gr.Button("Run Performance Benchmark", variant="stop")
+            b_sum = gr.Markdown()
+            b_grid = gr.Dataframe(headers=["ID", "Title", "Difficulty", "Reward", "Compiled"], label="Task Results")
+            
+            b_summarize.click(run_benchmark, outputs=[b_sum, b_grid])
+            
+    return demo
+
+# Final consolidated Gradio App mounted on the FastAPI server
+app = gr.mount_gradio_app(openenv_app, create_dashboard(), path="/")
+
+def main(host: str = "0.0.0.0", port: int = 8000) -> None:
+    """Entry point: uv run server or python -m server.app"""
+    import uvicorn  
+    uvicorn.run(app, host=host, port=port)
+
+
+if __name__ == "__main__":
+    main()

server/requirements.txt

@@ -0,0 +1,6 @@
+openenv[core]>=0.2.0
+fastapi>=0.115.0
+uvicorn>=0.24.0
+
+
+

server/rust_coder_environment.py

@@ -0,0 +1,434 @@
+"""
+Rust Coder Environment Implementation.
+
+Evaluates LLM-generated Rust code against 10 sequential coding problems.
+Multi-dimensional reward system: Compilation(40%), Correctness(20%),
+Coverage(20%), Elegance(10%), Efficiency(10%).
+"""
+
+import json
+import os
+import re
+import subprocess
+import tempfile
+import time
+from typing import Dict, List, Optional, Tuple
+
+from openenv.core.env_server.interfaces import Environment
+
+from models import RustCoderAction, RustCoderObservation
+
+
+# Resolve problems.json: look in same dir as this file, then parent
+_HERE = os.path.dirname(os.path.abspath(__file__))
+_PROBLEMS_PATHS = [
+    os.path.join(_HERE, "problems.json"),           # server/problems.json
+    os.path.join(_HERE, "..", "problems.json"),     # root problems.json
+    "problems.json",                                 # cwd fallback
+]
+
+
+def _find_problems_file() -> str:
+    """Return the first existing problems.json path."""
+    for path in _PROBLEMS_PATHS:
+        if os.path.exists(path):
+            return os.path.abspath(path)
+    raise FileNotFoundError(
+        f"problems.json not found. Searched: {_PROBLEMS_PATHS}"
+    )
+
+
+class RustCoderEnvironment(Environment):
+    """
+    OpenEnv-compliant environment for evaluating Rust code submissions.
+
+    Manages 10 sequential coding problems. Each episode is a single problem:
+      - reset() → loads the current problem, returns its description
+      - step(action) → compiles & tests submitted code, returns reward
+      - After step(), the episode is done; next reset() loads the next problem.
+
+    Reward breakdown (all components normalized to [0, 1]):
+      Compilation  40%  — code compiles without errors
+      Correctness  20%  — fraction of test assertions that pass
+      Coverage     20%  — fraction of tests attempted to run
+      Elegance     10%  — code quality heuristics
+      Efficiency   10%  — execution time vs. problem baseline
+    """
+
+    SUPPORTS_CONCURRENT_SESSIONS: bool = True
+
+    # Compile / run timeouts (seconds)
+    COMPILE_TIMEOUT = 30
+    RUN_TIMEOUT = 10
+
+    def __init__(self) -> None:
+        """Initialize environment and load problems from JSON."""
+        self.problems: List[Dict] = self._load_problems()
+        self.current_problem_idx: int = 0
+        self.step_count: int = 0
+
+    # ------------------------------------------------------------------
+    # Internal helpers
+    # ------------------------------------------------------------------
+
+    def _load_problems(self) -> List[Dict]:
+        """Load and validate the problems list from problems.json."""
+        path = _find_problems_file()
+        with open(path, "r", encoding="utf-8") as f:
+            data = json.load(f)
+        if not isinstance(data, list) or len(data) == 0:
+            raise ValueError("problems.json must be a non-empty JSON array.")
+        return data
+
+    def _current_problem(self) -> Dict:
+        idx = self.current_problem_idx % len(self.problems)
+        return self.problems[idx]
+
+    # ------------------------------------------------------------------
+    # OpenEnv interface
+    # ------------------------------------------------------------------
+
+    @property
+    def state(self):
+        """Return minimal state info (step count, problem index)."""
+        from openenv.core.env_server.types import State
+        return State(episode_id=None, step_count=self.step_count)
+
+    def reset(self, start_index: int = 0) -> RustCoderObservation:
+        """Start a new episode, defaulting to the first problem."""
+        self.current_problem_idx = start_index % len(self.problems)
+        self.step_count = 0
+        problem = self.problems[self.current_problem_idx]
+
+        return RustCoderObservation(
+            problem_description=problem["description"],
+            starter_code=problem["starter_code"],
+            compilation_success=False,
+            compilation_output="",
+            test_results=[],
+            reward_breakdown={},
+            done=False,
+            reward=0.0,
+        )
+
+    def step(self, action: RustCoderAction) -> RustCoderObservation:
+        """Evaluate the submitted code and advance the task index within the single episode."""
+        self.step_count += 1
+        problem = self.problems[self.current_problem_idx]
+        code = action.code
+
+        # ── 1. Compilation (40%) ──────────────────────────────────────
+        compilation_success, compilation_output = self._compile_check(code)
+        r_compilation = 1.0 if compilation_success else 0.0
+
+        # ── 2. Correctness + Coverage (20% each) ─────────────────────
+        test_results: List[Dict] = []
+        r_correctness = 0.0
+        r_coverage = 0.0
+
+        if compilation_success:
+            tests = problem.get("tests", [])
+            if tests:
+                test_results = self._run_tests(code, tests)
+                passed = sum(1 for t in test_results if t.get("passed", False))
+                ran    = sum(1 for t in test_results if t.get("ran", False))
+                r_correctness = passed / len(tests)
+                r_coverage    = ran    / len(tests)
+            else:
+                # No tests defined — give full credit to both dimensions
+                r_correctness = 1.0
+                r_coverage    = 1.0
+
+        # ── 3. Elegance (10%) ─────────────────────────────────────────
+        r_elegance = self._score_elegance(code)
+
+        # ── 4. Efficiency (10%) ───────────────────────────────────────
+        baseline_ms: float = problem.get("performance_baseline_ms", 100.0)
+        r_efficiency = 0.0
+        if compilation_success:
+            r_efficiency = self._score_efficiency(code, baseline_ms)
+
+        # ── Total reward ──────────────────────────────────────────────
+        reward_breakdown = {
+            "Compilation":  round(r_compilation,  4),
+            "Correctness":  round(r_correctness,  4),
+            "Coverage":     round(r_coverage,     4),
+            "Elegance":     round(r_elegance,     4),
+            "Efficiency":   round(r_efficiency,   4),
+        }
+        # Calculate weighted total reward
+        total_reward = round(
+            r_compilation * 0.40
+            + r_correctness * 0.20
+            + r_coverage    * 0.20
+            + r_elegance    * 0.10
+            + r_efficiency  * 0.10,
+            4,
+        )
+
+        # ── Advance Logic ─────────────────────────────────────────────
+        self.current_problem_idx += 1
+        done = self.current_problem_idx >= len(self.problems)
+        
+        next_prob_desc = "--- ALL TASKS COMPLETED in this episode ---"
+        next_starter = ""
+        if not done:
+            next_prob = self.problems[self.current_problem_idx]
+            next_prob_desc = f"--- NEXT TASK: {next_prob['title']} ---\n\n{next_prob['description']}"
+            next_starter = next_prob['starter_code']
+
+        return RustCoderObservation(
+            problem_description=next_prob_desc,
+            starter_code=next_starter,
+            compilation_success=compilation_success,
+            compilation_output=compilation_output[:2000],   # cap length
+            test_results=test_results,
+            reward_breakdown=reward_breakdown,
+            done=done,
+            reward=total_reward,
+        )
+
+    # ------------------------------------------------------------------
+    # Compilation
+    # ------------------------------------------------------------------
+
+    def _compile_check(self, code: str) -> Tuple[bool, str]:
+        """
+        Compile code as a Rust library crate.
+        Returns (success, compiler output).
+        """
+        with tempfile.TemporaryDirectory() as tmpdir:
+            src = os.path.join(tmpdir, "submission.rs")
+            out = os.path.join(tmpdir, "submission.rlib")
+            with open(src, "w", encoding="utf-8") as f:
+                f.write(code)
+            try:
+                proc = subprocess.run(
+                    ["rustc", "--crate-type=lib", src, "-o", out,
+                     "--edition=2021"],
+                    capture_output=True,
+                    text=True,
+                    timeout=self.COMPILE_TIMEOUT,
+                )
+                return proc.returncode == 0, (proc.stdout + proc.stderr).strip()
+            except subprocess.TimeoutExpired:
+                return False, "Compilation timed out."
+            except FileNotFoundError:
+                return False, "rustc not found — is the Rust toolchain installed?"
+
+    # ------------------------------------------------------------------
+    # Correctness / Coverage
+    # ------------------------------------------------------------------
+
+    def _strip_main(self, code: str) -> str:
+        """
+        Remove fn main() { ... } blocks from submitted code so we can
+        inject our own test main. Handles simple single-level braces.
+        """
+        # Remove pub/private fn main() { ... }
+        pattern = re.compile(
+            r'(pub\s+)?fn\s+main\s*\(\s*\)\s*(?:->\s*[^{]+)?\s*\{',
+            re.MULTILINE,
+        )
+        match = pattern.search(code)
+        if not match:
+            return code
+        start = match.start()
+        depth = 0
+        i = match.end() - 1  # position of the opening '{'
+        while i < len(code):
+            if code[i] == '{':
+                depth += 1
+            elif code[i] == '}':
+                depth -= 1
+                if depth == 0:
+                    return code[:start] + code[i + 1:]
+            i += 1
+        return code  # malformed; return as-is
+
+    def _build_test_binary(
+        self, code: str, assertion: str, tmpdir: str, test_name: str
+    ) -> Tuple[bool, str, str]:
+        """
+        Build a runnable Rust binary that executes one test assertion.
+        Returns (compiled_ok, binary_path, compiler_output).
+        """
+        body = self._strip_main(code)
+        src_code = f"""
+#[allow(unused_imports, dead_code, unused_variables, unused_mut)]
+{body}
+
+fn main() {{
+    {assertion};
+    println!("PASS:{test_name}");
+}}
+"""
+        src_path = os.path.join(tmpdir, f"{test_name}.rs")
+        bin_path = os.path.join(tmpdir, test_name)
+        with open(src_path, "w", encoding="utf-8") as f:
+            f.write(src_code)
+        try:
+            proc = subprocess.run(
+                ["rustc", src_path, "-o", bin_path, "--edition=2021"],
+                capture_output=True,
+                text=True,
+                timeout=self.COMPILE_TIMEOUT,
+            )
+            return proc.returncode == 0, bin_path, (proc.stdout + proc.stderr).strip()
+        except subprocess.TimeoutExpired:
+            return False, "", "Compile timed out for test."
+        except FileNotFoundError:
+            return False, "", "rustc not found."
+
+    def _run_tests(self, code: str, tests: List[Dict]) -> List[Dict]:
+        """
+        Run each test assertion as a separate Rust binary.
+        Returns list of result dicts with keys: name, passed, ran, error.
+        """
+        results = []
+        with tempfile.TemporaryDirectory() as tmpdir:
+            for i, test in enumerate(tests):
+                name = test.get("name", f"test_{i}")
+                assertion = test.get("test_assertion", "")
+                should_compile = test.get("should_compile", True)
+
+                result: Dict = {
+                    "name": name,
+                    "passed": False,
+                    "ran": False,
+                    "error": None,
+                }
+
+                if not assertion:
+                    result["error"] = "No test assertion defined."
+                    results.append(result)
+                    continue
+
+                # Some tests are expected to fail compilation (should_compile=False)
+                # treat successful compilation + correct output as pass
+                bin_test_name = f"t{i}_{name[:20]}"
+                compiled, bin_path, compiler_out = self._build_test_binary(
+                    code, assertion, tmpdir, bin_test_name
+                )
+
+                if not compiled:
+                    if not should_compile:
+                        # The problem's starter code deliberately doesn't compile;
+                        # if the submission also doesn't compile this test → skip
+                        result["error"] = "Binary compile failed (expected for broken starter)."
+                    else:
+                        result["error"] = f"Compile error: {compiler_out[:300]}"
+                    result["ran"] = False
+                    results.append(result)
+                    continue
+
+                # Run the binary
+                result["ran"] = True
+                try:
+                    run_proc = subprocess.run(
+                        [bin_path],
+                        capture_output=True,
+                        text=True,
+                        timeout=self.RUN_TIMEOUT,
+                    )
+                    stdout = run_proc.stdout.strip()
+                    if run_proc.returncode == 0 and f"PASS:{bin_test_name}" in stdout:
+                        result["passed"] = True
+                    else:
+                        result["error"] = (
+                            f"Test failed. Exit={run_proc.returncode}. "
+                            f"stderr={run_proc.stderr[:200]}"
+                        )
+                except subprocess.TimeoutExpired:
+                    result["error"] = "Test execution timed out."
+                except Exception as exc:
+                    result["error"] = str(exc)
+
+                results.append(result)
+
+        return results
+
+    # ------------------------------------------------------------------
+    # Elegance scoring
+    # ------------------------------------------------------------------
+
+    def _score_elegance(self, code: str) -> float:
+        """
+        Heuristic code-quality score in [0, 1].
+
+        Penalties:
+          - Each `.unwrap()` call           → -0.15 (max -0.45)
+          - Each `.expect(` call            → -0.05 (max -0.15)
+          - Lines > 100 chars               → -0.05 per violation (max -0.20)
+          - `unsafe` blocks                 → -0.20 unless problem requires FFI
+
+        Bonuses:
+          - Uses `?` operator               → +0.10
+          - Uses `match` expressions        → +0.05
+          - Has doc comments (`///`)        → +0.05
+        """
+        score = 1.0
+
+        unwrap_count = len(re.findall(r'\.unwrap\(\)', code))
+        score -= min(unwrap_count * 0.15, 0.45)
+
+        expect_count = len(re.findall(r'\.expect\(', code))
+        score -= min(expect_count * 0.05, 0.15)
+
+        long_lines = sum(1 for line in code.splitlines() if len(line) > 100)
+        score -= min(long_lines * 0.05, 0.20)
+
+        if "unsafe" in code:
+            score -= 0.20
+
+        if "?" in code:
+            score += 0.10
+        if "match " in code or "match\n" in code:
+            score += 0.05
+        if "///" in code:
+            score += 0.05
+
+        return round(max(0.0, min(1.0, score)), 4)
+
+    # ------------------------------------------------------------------
+    # Efficiency scoring
+    # ------------------------------------------------------------------
+
+    def _score_efficiency(self, code: str, baseline_ms: float) -> float:
+        """
+        Time the execution by compiling + running a minimal binary.
+        Score = min(1.0, baseline_ms / actual_ms).
+        Returns 0.0 if compilation or execution fails.
+        """
+        body = self._strip_main(code)
+        # Build a binary with an empty main to measure startup + run overhead
+        test_src = f"""
+#[allow(unused_imports, dead_code, unused_variables)]
+{body}
+
+fn main() {{}}
+"""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            src_path = os.path.join(tmpdir, "eff.rs")
+            bin_path = os.path.join(tmpdir, "eff")
+            with open(src_path, "w", encoding="utf-8") as f:
+                f.write(test_src)
+            try:
+                # Compile
+                proc = subprocess.run(
+                    ["rustc", src_path, "-o", bin_path, "--edition=2021"],
+                    capture_output=True, text=True, timeout=self.COMPILE_TIMEOUT,
+                )
+                if proc.returncode != 0:
+                    return 0.0
+                # Time the run
+                t0 = time.monotonic()
+                run_proc = subprocess.run(
+                    [bin_path], capture_output=True, timeout=self.RUN_TIMEOUT
+                )
+                elapsed_ms = (time.monotonic() - t0) * 1000.0
+                if run_proc.returncode != 0:
+                    return 0.0
+                return round(min(1.0, baseline_ms / max(elapsed_ms, 0.1)), 4)
+            except Exception:
+                return 0.0